483 lines
17 KiB
C++
483 lines
17 KiB
C++
#include "QtWidgets/QTableWidget/qtablewidget_wrap.h"
|
|
|
|
#include "Extras/Utils/nutils.h"
|
|
#include "QtWidgets/QTableWidgetItem/qtablewidgetitem_wrap.h"
|
|
#include "QtWidgets/QWidget/qwidget_wrap.h"
|
|
|
|
Napi::FunctionReference QTableWidgetWrap::constructor;
|
|
|
|
Napi::Object QTableWidgetWrap::init(Napi::Env env, Napi::Object exports) {
|
|
Napi::HandleScope scope(env);
|
|
char CLASSNAME[] = "QTableWidget";
|
|
Napi::Function func = DefineClass(
|
|
env, CLASSNAME,
|
|
{InstanceMethod("selectedRanges", &QTableWidgetWrap::selectedRanges),
|
|
InstanceMethod("closePersistentEditor",
|
|
&QTableWidgetWrap::closePersistentEditor),
|
|
InstanceMethod("editItem", &QTableWidgetWrap::editItem),
|
|
InstanceMethod("setCellWidget", &QTableWidgetWrap::setCellWidget),
|
|
InstanceMethod("setItem", &QTableWidgetWrap::setItem),
|
|
InstanceMethod("setHorizontalHeaderItem",
|
|
&QTableWidgetWrap::setHorizontalHeaderItem),
|
|
InstanceMethod("setHorizontalHeaderLabels",
|
|
&QTableWidgetWrap::setHorizontalHeaderLabels),
|
|
InstanceMethod("setVerticalHeaderItem",
|
|
&QTableWidgetWrap::setVerticalHeaderItem),
|
|
InstanceMethod("setVerticalHeaderLabels",
|
|
&QTableWidgetWrap::setVerticalHeaderLabels),
|
|
InstanceMethod("clear", &QTableWidgetWrap::clear),
|
|
InstanceMethod("clearContents", &QTableWidgetWrap::clearContents),
|
|
InstanceMethod("insertColumn", &QTableWidgetWrap::insertColumn),
|
|
InstanceMethod("removeColumn", &QTableWidgetWrap::removeColumn),
|
|
InstanceMethod("insertRow", &QTableWidgetWrap::insertRow),
|
|
InstanceMethod("removeRow", &QTableWidgetWrap::removeRow),
|
|
InstanceMethod("scrollToItem", &QTableWidgetWrap::scrollToItem),
|
|
// FROM TABLEVIEW
|
|
InstanceMethod("hideColumn", &QTableWidgetWrap::hideColumn),
|
|
InstanceMethod("hideRow", &QTableWidgetWrap::hideRow),
|
|
InstanceMethod("resizeColumnToContents",
|
|
&QTableWidgetWrap::resizeColumnToContents),
|
|
InstanceMethod("resizeColumnsToContents",
|
|
&QTableWidgetWrap::resizeColumnsToContents),
|
|
InstanceMethod("resizeRowToContents",
|
|
&QTableWidgetWrap::resizeRowToContents),
|
|
InstanceMethod("resizeRowsToContents",
|
|
&QTableWidgetWrap::resizeRowsToContents),
|
|
InstanceMethod("selectColumn", &QTableWidgetWrap::selectColumn),
|
|
InstanceMethod("selectRow", &QTableWidgetWrap::selectRow),
|
|
InstanceMethod("setShowGrid", &QTableWidgetWrap::setShowGrid),
|
|
InstanceMethod("showGrid", &QTableWidgetWrap::showGrid),
|
|
InstanceMethod("showColumn", &QTableWidgetWrap::showColumn),
|
|
InstanceMethod("showRow", &QTableWidgetWrap::showRow),
|
|
InstanceMethod("sortByColumn", &QTableWidgetWrap::sortByColumn),
|
|
InstanceMethod("setColumnWidth", &QTableWidgetWrap::setColumnWidth),
|
|
InstanceMethod("setRowHeight", &QTableWidgetWrap::setRowHeight),
|
|
InstanceMethod("columnCount", &QTableWidgetWrap::columnCount),
|
|
InstanceMethod("rowCount", &QTableWidgetWrap::rowCount),
|
|
InstanceMethod("setColumnCount", &QTableWidgetWrap::setColumnCount),
|
|
InstanceMethod("setRowCount", &QTableWidgetWrap::setRowCount),
|
|
InstanceMethod("setSortingEnabled",
|
|
&QTableWidgetWrap::setSortingEnabled),
|
|
InstanceMethod("isSortingEnabled", &QTableWidgetWrap::isSortingEnabled),
|
|
|
|
QABSTRACTSCROLLAREA_WRAPPED_METHODS_EXPORT_DEFINE(QTableWidgetWrap)});
|
|
constructor = Napi::Persistent(func);
|
|
exports.Set(CLASSNAME, func);
|
|
return exports;
|
|
}
|
|
|
|
NTableWidget* QTableWidgetWrap::getInternalInstance() { return this->instance; }
|
|
QTableWidgetWrap::~QTableWidgetWrap() {
|
|
extrautils::safeDelete(this->instance);
|
|
}
|
|
|
|
QTableWidgetWrap::QTableWidgetWrap(const Napi::CallbackInfo& info)
|
|
: Napi::ObjectWrap<QTableWidgetWrap>(info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
|
|
if (info.Length() == 2 || info.Length() == 3) {
|
|
int rows = info[0].As<Napi::Number>().Int32Value();
|
|
int columns = info[1].As<Napi::Number>().Int32Value();
|
|
|
|
if (info.Length() == 3) {
|
|
Napi::Object parentObject = info[2].As<Napi::Object>();
|
|
NodeWidgetWrap* parentWidgetWrap =
|
|
Napi::ObjectWrap<NodeWidgetWrap>::Unwrap(parentObject);
|
|
this->instance = new NTableWidget(
|
|
rows, columns, parentWidgetWrap->getInternalInstance());
|
|
} else {
|
|
this->instance = new NTableWidget(rows, columns);
|
|
}
|
|
|
|
} else if (info.Length() == 1) {
|
|
Napi::Object parentObject = info[0].As<Napi::Object>();
|
|
NodeWidgetWrap* parentWidgetWrap =
|
|
Napi::ObjectWrap<NodeWidgetWrap>::Unwrap(parentObject);
|
|
this->instance = new NTableWidget(parentWidgetWrap->getInternalInstance());
|
|
} else if (info.Length() == 0) {
|
|
this->instance = new NTableWidget();
|
|
} else {
|
|
Napi::TypeError::New(env, "Wrong number of arguments")
|
|
.ThrowAsJavaScriptException();
|
|
}
|
|
this->rawData = extrautils::configureQWidget(
|
|
this->getInternalInstance(), this->getInternalInstance()->getFlexNode(),
|
|
false);
|
|
}
|
|
Napi::Value QTableWidgetWrap::selectedRanges(const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
|
|
QList<QTableWidgetSelectionRange> range = this->instance->selectedRanges();
|
|
Napi::Array napiRange = Napi::Array::New(env, range.size());
|
|
|
|
for (int i = 0; i < range.size(); i++) {
|
|
int topRow = range[0].topRow();
|
|
int leftColumn = range[0].leftColumn();
|
|
int bottomRow = range[0].bottomRow();
|
|
int rightColumn = range[0].rightColumn();
|
|
int columnCount = range[0].columnCount();
|
|
int rowCount = range[0].rowCount();
|
|
Napi::Object newRange = Napi::Object::New(env);
|
|
newRange.Set("topRow", Napi::Number::New(env, topRow));
|
|
newRange.Set("leftColumn", Napi::Number::New(env, leftColumn));
|
|
newRange.Set("bottomRow", Napi::Number::New(env, bottomRow));
|
|
newRange.Set("rightColumn", Napi::Number::New(env, rightColumn));
|
|
newRange.Set("columnCount", Napi::Number::New(env, columnCount));
|
|
newRange.Set("rowCount", Napi::Number::New(env, rowCount));
|
|
napiRange[i] = newRange;
|
|
}
|
|
return napiRange;
|
|
return env.Null();
|
|
}
|
|
Napi::Value QTableWidgetWrap::closePersistentEditor(
|
|
const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
|
|
Napi::Object itemObject = info[0].As<Napi::Object>();
|
|
QTableWidgetItemWrap* itemWrap =
|
|
Napi::ObjectWrap<QTableWidgetItemWrap>::Unwrap(itemObject);
|
|
|
|
this->instance->closePersistentEditor(itemWrap->getInternalInstance());
|
|
return env.Null();
|
|
}
|
|
|
|
Napi::Value QTableWidgetWrap::editItem(const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
|
|
Napi::Object itemObject = info[0].As<Napi::Object>();
|
|
QTableWidgetItemWrap* itemWrap =
|
|
Napi::ObjectWrap<QTableWidgetItemWrap>::Unwrap(itemObject);
|
|
|
|
this->instance->editItem(itemWrap->getInternalInstance());
|
|
return env.Null();
|
|
}
|
|
|
|
Napi::Value QTableWidgetWrap::setCellWidget(const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
|
|
int row = info[0].As<Napi::Number>().Int32Value();
|
|
int column = info[1].As<Napi::Number>().Int32Value();
|
|
Napi::Object widgetObject = info[2].As<Napi::Object>();
|
|
NodeWidgetWrap* widgetWrap =
|
|
Napi::ObjectWrap<NodeWidgetWrap>::Unwrap(widgetObject);
|
|
|
|
this->instance->setCellWidget(row, column, widgetWrap->getInternalInstance());
|
|
return env.Null();
|
|
}
|
|
Napi::Value QTableWidgetWrap::setItem(const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
|
|
int row = info[0].As<Napi::Number>().Int32Value();
|
|
int column = info[1].As<Napi::Number>().Int32Value();
|
|
Napi::Object itemObject = info[2].As<Napi::Object>();
|
|
QTableWidgetItemWrap* itemWrap =
|
|
Napi::ObjectWrap<QTableWidgetItemWrap>::Unwrap(itemObject);
|
|
|
|
this->instance->setItem(row, column, itemWrap->getInternalInstance());
|
|
return env.Null();
|
|
}
|
|
Napi::Value QTableWidgetWrap::setHorizontalHeaderItem(
|
|
const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
|
|
int column = info[0].As<Napi::Number>().Int32Value();
|
|
Napi::Object itemObject = info[1].As<Napi::Object>();
|
|
QTableWidgetItemWrap* itemWrap =
|
|
Napi::ObjectWrap<QTableWidgetItemWrap>::Unwrap(itemObject);
|
|
|
|
this->instance->setHorizontalHeaderItem(column,
|
|
itemWrap->getInternalInstance());
|
|
return env.Null();
|
|
}
|
|
|
|
Napi::Value QTableWidgetWrap::setHorizontalHeaderLabels(
|
|
const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
|
|
Napi::Array labelsNapi = info[0].As<Napi::Array>();
|
|
QList<QString> list;
|
|
for (int i = 0; i < labelsNapi.Length(); i++) {
|
|
Napi::Value labelNapi = labelsNapi[i];
|
|
list.append(labelNapi.As<Napi::String>().Utf8Value().c_str());
|
|
}
|
|
QStringList labels = QStringList(list);
|
|
|
|
this->instance->setHorizontalHeaderLabels(labels);
|
|
return env.Null();
|
|
}
|
|
Napi::Value QTableWidgetWrap::setVerticalHeaderItem(
|
|
const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
|
|
int row = info[0].As<Napi::Number>().Int32Value();
|
|
Napi::Object itemObject = info[0].As<Napi::Object>();
|
|
QTableWidgetItemWrap* itemWrap =
|
|
Napi::ObjectWrap<QTableWidgetItemWrap>::Unwrap(itemObject);
|
|
|
|
this->instance->setVerticalHeaderItem(row, itemWrap->getInternalInstance());
|
|
return env.Null();
|
|
}
|
|
|
|
Napi::Value QTableWidgetWrap::setVerticalHeaderLabels(
|
|
const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
|
|
Napi::Array labelsNapi = info[0].As<Napi::Array>();
|
|
QList<QString> list;
|
|
for (int i = 0; i < labelsNapi.Length(); i++) {
|
|
Napi::Value labelNapi = labelsNapi[i];
|
|
list.append(labelNapi.As<Napi::String>().Utf8Value().c_str());
|
|
}
|
|
QStringList labels = QStringList(list);
|
|
|
|
this->instance->setVerticalHeaderLabels(labels);
|
|
return env.Null();
|
|
}
|
|
|
|
Napi::Value QTableWidgetWrap::clear(const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
this->instance->clear();
|
|
return env.Null();
|
|
}
|
|
Napi::Value QTableWidgetWrap::clearContents(const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
this->instance->clearContents();
|
|
return env.Null();
|
|
}
|
|
Napi::Value QTableWidgetWrap::insertColumn(const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
|
|
int column = info[0].As<Napi::Number>().Int32Value();
|
|
this->instance->insertColumn(column);
|
|
return env.Null();
|
|
}
|
|
Napi::Value QTableWidgetWrap::removeColumn(const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
|
|
int column = info[0].As<Napi::Number>().Int32Value();
|
|
this->instance->removeColumn(column);
|
|
return env.Null();
|
|
}
|
|
Napi::Value QTableWidgetWrap::insertRow(const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
|
|
int row = info[0].As<Napi::Number>().Int32Value();
|
|
this->instance->insertRow(row);
|
|
return env.Null();
|
|
}
|
|
Napi::Value QTableWidgetWrap::removeRow(const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
|
|
int row = info[0].As<Napi::Number>().Int32Value();
|
|
this->instance->removeRow(row);
|
|
return env.Null();
|
|
}
|
|
Napi::Value QTableWidgetWrap::scrollToItem(const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
|
|
Napi::Object itemObject = info[0].As<Napi::Object>();
|
|
QTableWidgetItemWrap* itemWrap =
|
|
Napi::ObjectWrap<QTableWidgetItemWrap>::Unwrap(itemObject);
|
|
|
|
int hintInt = info[1].As<Napi::Number>().Int32Value();
|
|
QAbstractItemView::ScrollHint hint =
|
|
static_cast<QAbstractItemView::ScrollHint>(hintInt);
|
|
this->instance->scrollToItem(itemWrap->getInternalInstance(), hint);
|
|
return env.Null();
|
|
}
|
|
// FROM TABLEVIEW
|
|
|
|
Napi::Value QTableWidgetWrap::hideColumn(const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
|
|
int column = info[0].As<Napi::Number>().Int32Value();
|
|
this->instance->hideColumn(column);
|
|
return env.Null();
|
|
}
|
|
Napi::Value QTableWidgetWrap::hideRow(const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
|
|
int row = info[0].As<Napi::Number>().Int32Value();
|
|
this->instance->hideRow(row);
|
|
return env.Null();
|
|
}
|
|
|
|
Napi::Value QTableWidgetWrap::resizeColumnToContents(
|
|
const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
|
|
int column = info[0].As<Napi::Number>().Int32Value();
|
|
this->instance->resizeColumnToContents(column);
|
|
return env.Null();
|
|
}
|
|
Napi::Value QTableWidgetWrap::resizeColumnsToContents(
|
|
const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
|
|
this->instance->resizeColumnsToContents();
|
|
return env.Null();
|
|
}
|
|
Napi::Value QTableWidgetWrap::resizeRowToContents(
|
|
const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
|
|
int row = info[0].As<Napi::Number>().Int32Value();
|
|
this->instance->resizeRowToContents(row);
|
|
return env.Null();
|
|
}
|
|
Napi::Value QTableWidgetWrap::resizeRowsToContents(
|
|
const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
|
|
this->instance->resizeRowsToContents();
|
|
return env.Null();
|
|
}
|
|
|
|
Napi::Value QTableWidgetWrap::selectColumn(const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
|
|
int column = info[0].As<Napi::Number>().Int32Value();
|
|
this->instance->selectColumn(column);
|
|
return env.Null();
|
|
}
|
|
Napi::Value QTableWidgetWrap::selectRow(const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
|
|
int row = info[0].As<Napi::Number>().Int32Value();
|
|
this->instance->selectRow(row);
|
|
return env.Null();
|
|
}
|
|
|
|
Napi::Value QTableWidgetWrap::setShowGrid(const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
|
|
bool show = info[0].As<Napi::Boolean>().Value();
|
|
this->instance->setShowGrid(show);
|
|
return env.Null();
|
|
}
|
|
Napi::Value QTableWidgetWrap::showGrid(const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
|
|
bool show = this->instance->showGrid();
|
|
return Napi::Boolean::New(env, show);
|
|
}
|
|
|
|
Napi::Value QTableWidgetWrap::showColumn(const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
|
|
int column = info[0].As<Napi::Number>().Int32Value();
|
|
this->instance->showColumn(column);
|
|
return env.Null();
|
|
}
|
|
Napi::Value QTableWidgetWrap::showRow(const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
|
|
int row = info[0].As<Napi::Number>().Int32Value();
|
|
this->instance->showRow(row);
|
|
return env.Null();
|
|
}
|
|
Napi::Value QTableWidgetWrap::sortByColumn(const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
|
|
int column = info[0].As<Napi::Number>().Int32Value();
|
|
int orderInt = info[1].As<Napi::Number>().Int32Value();
|
|
Qt::SortOrder order = static_cast<Qt::SortOrder>(orderInt);
|
|
this->instance->sortByColumn(column, order);
|
|
return env.Null();
|
|
}
|
|
Napi::Value QTableWidgetWrap::setColumnWidth(const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
|
|
int column = info[0].As<Napi::Number>().Int32Value();
|
|
int width = info[1].As<Napi::Number>().Int32Value();
|
|
this->instance->setColumnWidth(column, width);
|
|
return env.Null();
|
|
}
|
|
Napi::Value QTableWidgetWrap::setRowHeight(const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
|
|
int row = info[0].As<Napi::Number>().Int32Value();
|
|
int height = info[1].As<Napi::Number>().Int32Value();
|
|
this->instance->setRowHeight(row, height);
|
|
return env.Null();
|
|
}
|
|
Napi::Value QTableWidgetWrap::columnCount(const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
|
|
int count = static_cast<int>(this->instance->columnCount());
|
|
return Napi::Number::New(env, count);
|
|
}
|
|
Napi::Value QTableWidgetWrap::rowCount(const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
|
|
int count = static_cast<int>(this->instance->rowCount());
|
|
return Napi::Number::New(env, count);
|
|
}
|
|
Napi::Value QTableWidgetWrap::setColumnCount(const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
|
|
int count = info[0].As<Napi::Number>().Int32Value();
|
|
this->instance->setColumnCount(count);
|
|
return env.Null();
|
|
}
|
|
Napi::Value QTableWidgetWrap::setRowCount(const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
|
|
int count = info[0].As<Napi::Number>().Int32Value();
|
|
this->instance->setRowCount(count);
|
|
return env.Null();
|
|
}
|
|
|
|
Napi::Value QTableWidgetWrap::setSortingEnabled(
|
|
const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
|
|
bool enable = info[0].As<Napi::Boolean>().Value();
|
|
this->instance->setSortingEnabled(enable);
|
|
return env.Null();
|
|
}
|
|
Napi::Value QTableWidgetWrap::isSortingEnabled(const Napi::CallbackInfo& info) {
|
|
Napi::Env env = info.Env();
|
|
Napi::HandleScope scope(env);
|
|
|
|
bool enabled = this->instance->isSortingEnabled();
|
|
return Napi::Boolean::New(env, enabled);
|
|
}
|