From e0e883bb9a4afd1f8302537386eacaee3b9710d4 Mon Sep 17 00:00:00 2001 From: wuxiaofeng Date: Tue, 24 Mar 2020 22:39:02 +0800 Subject: [PATCH 1/7] Add QDoubleSpinBox --- CMakeLists.txt | 2 + .../QDoubleSpinBox/ndoublespinbox.hpp | 29 +++++ .../QDoubleSpinBox/qdoublespinbox_wrap.h | 28 +++++ .../QDoubleSpinBox/qdoublespinbox_wrap.cpp | 79 ++++++++++++++ src/cpp/main.cpp | 2 + src/index.ts | 1 + src/lib/QtWidgets/QDoubleSpinBox.ts | 101 ++++++++++++++++++ 7 files changed, 242 insertions(+) create mode 100644 src/cpp/include/nodegui/QtWidgets/QDoubleSpinBox/ndoublespinbox.hpp create mode 100644 src/cpp/include/nodegui/QtWidgets/QDoubleSpinBox/qdoublespinbox_wrap.h create mode 100644 src/cpp/lib/QtWidgets/QDoubleSpinBox/qdoublespinbox_wrap.cpp create mode 100644 src/lib/QtWidgets/QDoubleSpinBox.ts diff --git a/CMakeLists.txt b/CMakeLists.txt index b8a623a15f..a6abbabb75 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -71,6 +71,7 @@ add_library(${CORE_WIDGETS_ADDON} SHARED "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QComboBox/qcombobox_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QDateEdit/qdateedit_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QDateTimeEdit/qdatetimeedit_wrap.cpp" + "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QDoubleSpinBox/qdoublespinbox_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QFileDialog/qfiledialog_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QFrame/qframe_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QListWidget/qlistwidget_wrap.cpp" @@ -126,6 +127,7 @@ add_library(${CORE_WIDGETS_ADDON} SHARED "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QDateEdit/ndateedit.hpp" "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QDateTimeEdit/ndatetimeedit.hpp" "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QDial/ndial.hpp" + "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QDoubleSpinBox/ndoublespinbox.hpp" "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QFileDialog/nfiledialog.hpp" "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QFrame/nframe.hpp" "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QListWidget/nlistwidget.hpp" diff --git a/src/cpp/include/nodegui/QtWidgets/QDoubleSpinBox/ndoublespinbox.hpp b/src/cpp/include/nodegui/QtWidgets/QDoubleSpinBox/ndoublespinbox.hpp new file mode 100644 index 0000000000..f1a089f564 --- /dev/null +++ b/src/cpp/include/nodegui/QtWidgets/QDoubleSpinBox/ndoublespinbox.hpp @@ -0,0 +1,29 @@ +#pragma once + +#include + +#include "Extras/Export/export.h" +#include "QtWidgets/QAbstractSpinBox/qabstractspinbox_macro.h" +#include "core/NodeWidget/nodewidget.h" +#include "napi.h" + +class DLL_EXPORT NDoubleSpinBox : public QDoubleSpinBox, public NodeWidget { + Q_OBJECT + NODEWIDGET_IMPLEMENTATIONS(QDoubleSpinBox) + public: + using QDoubleSpinBox::QDoubleSpinBox; // inherit all constructors of + // QDoubleSpinBox + + void connectSignalsToEventEmitter() { + QABSTRACTSPINBOX_SIGNALS + // Qt Connects: Implement all signal connects here + QObject::connect( + this, QOverload::of(&QDoubleSpinBox::valueChanged), + [=](double val) { + Napi::Env env = this->emitOnNode.Env(); + Napi::HandleScope scope(env); + this->emitOnNode.Call({Napi::String::New(env, "valueChanged"), + Napi::Number::New(env, val)}); + }); + } +}; diff --git a/src/cpp/include/nodegui/QtWidgets/QDoubleSpinBox/qdoublespinbox_wrap.h b/src/cpp/include/nodegui/QtWidgets/QDoubleSpinBox/qdoublespinbox_wrap.h new file mode 100644 index 0000000000..435aa3a2d3 --- /dev/null +++ b/src/cpp/include/nodegui/QtWidgets/QDoubleSpinBox/qdoublespinbox_wrap.h @@ -0,0 +1,28 @@ +#pragma once + +#include + +#include + +#include "Extras/Export/export.h" +#include "QtWidgets/QAbstractSpinBox/qabstractspinbox_macro.h" +#include "ndoublespinbox.hpp" + +class DLL_EXPORT QDoubleSpinBoxWrap + : public Napi::ObjectWrap { + QABSTRACTSPINBOX_WRAPPED_METHODS_DECLARATION + private: + QPointer instance; + + public: + static Napi::Object init(Napi::Env env, Napi::Object exports); + QDoubleSpinBoxWrap(const Napi::CallbackInfo& info); + ~QDoubleSpinBoxWrap(); + NDoubleSpinBox* getInternalInstance(); + // class constructor + static Napi::FunctionReference constructor; + // wrapped methods + Napi::Value setRange(const Napi::CallbackInfo& info); + Napi::Value textFromValue(const Napi::CallbackInfo& info); + Napi::Value valueFromText(const Napi::CallbackInfo& info); +}; diff --git a/src/cpp/lib/QtWidgets/QDoubleSpinBox/qdoublespinbox_wrap.cpp b/src/cpp/lib/QtWidgets/QDoubleSpinBox/qdoublespinbox_wrap.cpp new file mode 100644 index 0000000000..83ae49cbe5 --- /dev/null +++ b/src/cpp/lib/QtWidgets/QDoubleSpinBox/qdoublespinbox_wrap.cpp @@ -0,0 +1,79 @@ +#include "QtWidgets/QDoubleSpinBox/qdoublespinbox_wrap.h" + +#include "Extras/Utils/nutils.h" +#include "QtWidgets/QWidget/qwidget_wrap.h" + +Napi::FunctionReference QDoubleSpinBoxWrap::constructor; + +Napi::Object QDoubleSpinBoxWrap::init(Napi::Env env, Napi::Object exports) { + Napi::HandleScope scope(env); + char CLASSNAME[] = "QDoubleSpinBox"; + Napi::Function func = DefineClass( + env, CLASSNAME, + {InstanceMethod("setRange", &QDoubleSpinBoxWrap::setRange), + InstanceMethod("textFromValue", &QDoubleSpinBoxWrap::textFromValue), + InstanceMethod("valueFromText", &QDoubleSpinBoxWrap::valueFromText), + QABSTRACTSPINBOX_WRAPPED_METHODS_EXPORT_DEFINE(QDoubleSpinBoxWrap)}); + constructor = Napi::Persistent(func); + exports.Set(CLASSNAME, func); + return exports; +} + +NDoubleSpinBox* QDoubleSpinBoxWrap::getInternalInstance() { + return this->instance; +} + +QDoubleSpinBoxWrap::QDoubleSpinBoxWrap(const Napi::CallbackInfo& info) + : Napi::ObjectWrap(info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + if (info.Length() == 1) { + Napi::Object parentObject = info[0].As(); + NodeWidgetWrap* parentWidgetWrap = + Napi::ObjectWrap::Unwrap(parentObject); + this->instance = + new NDoubleSpinBox(parentWidgetWrap->getInternalInstance()); + } else if (info.Length() == 0) { + this->instance = new NDoubleSpinBox(); + } else { + Napi::TypeError::New(env, "Wrong number of arguments") + .ThrowAsJavaScriptException(); + } + this->rawData = extrautils::configureQWidget( + this->getInternalInstance(), this->getInternalInstance()->getFlexNode(), + true); +} + +QDoubleSpinBoxWrap::~QDoubleSpinBoxWrap() { + extrautils::safeDelete(this->instance); +} + +Napi::Value QDoubleSpinBoxWrap::setRange(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + double minimum = info[0].As().DoubleValue(); + double maximum = info[1].As().DoubleValue(); + this->instance->setRange(minimum, maximum); + return env.Null(); +} + +Napi::Value QDoubleSpinBoxWrap::textFromValue(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + double value = info[0].As().DoubleValue(); + QString text = this->instance->textFromValue(value); + return Napi::String::New(env, text.toStdString()); +} + +Napi::Value QDoubleSpinBoxWrap::valueFromText(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + std::string napiText = info[0].As().Utf8Value(); + QString text = QString::fromUtf8(napiText.c_str()); + double value = this->instance->valueFromText(text); + return Napi::Number::New(env, value); +} diff --git a/src/cpp/main.cpp b/src/cpp/main.cpp index 56c5484b9f..5ca3ba9f2d 100644 --- a/src/cpp/main.cpp +++ b/src/cpp/main.cpp @@ -37,6 +37,7 @@ #include "QtWidgets/QDateTimeEdit/qdatetimeedit_wrap.h" #include "QtWidgets/QDial/qdial_wrap.h" #include "QtWidgets/QDialog/qdialog_wrap.h" +#include "QtWidgets/QDoubleSpinBox/qdoublespinbox_wrap.h" #include "QtWidgets/QFileDialog/qfiledialog_wrap.h" #include "QtWidgets/QFrame/qframe_wrap.h" #include "QtWidgets/QGridLayout/qgridlayout_wrap.h" @@ -112,6 +113,7 @@ Napi::Object Main(Napi::Env env, Napi::Object exports) { QCalendarWidgetWrap::init(env, exports); QColorDialogWrap::init(env, exports); QComboBoxWrap::init(env, exports); + QDoubleSpinBoxWrap::init(env, exports); QBoxLayoutWrap::init(env, exports); QDateEditWrap::init(env, exports); QDateTimeEditWrap::init(env, exports); diff --git a/src/index.ts b/src/index.ts index 21ec9d36a5..57f939390e 100644 --- a/src/index.ts +++ b/src/index.ts @@ -41,6 +41,7 @@ export { QDateEdit } from './lib/QtWidgets/QDateEdit'; export { QDateTimeEdit, NodeDateTimeEdit, QDateTimeEditSignals } from './lib/QtWidgets/QDateTimeEdit'; export { QLabel, QLabelSignals } from './lib/QtWidgets/QLabel'; export { QDial, QDialSignals } from './lib/QtWidgets/QDial'; +export { QDoubleSpinBox, QDoubleSpinBoxSignals } from './lib/QtWidgets/QDoubleSpinBox'; export { QFileDialog, QFileDialogSignals } from './lib/QtWidgets/QFileDialog'; export { QFrame, QFrameSignals, Shadow, Shape } from './lib/QtWidgets/QFrame'; export { QLineEdit, QLineEditSignals, EchoMode } from './lib/QtWidgets/QLineEdit'; diff --git a/src/lib/QtWidgets/QDoubleSpinBox.ts b/src/lib/QtWidgets/QDoubleSpinBox.ts new file mode 100644 index 0000000000..38d08e5a2e --- /dev/null +++ b/src/lib/QtWidgets/QDoubleSpinBox.ts @@ -0,0 +1,101 @@ +import addon from '../utils/addon'; +import { NodeWidget } from './QWidget'; +import { NativeElement } from '../core/Component'; +import { QAbstractSpinBox, QAbstractSpinBoxSignals, StepType } from './QAbstractSpinBox'; + +/** + +> Create and control double spin box widgets. + +* **This class is a JS wrapper around Qt's [QDoubleSpinBox class](https://doc.qt.io/qt-5/qdoublespinbox.html)** + +A `QDoubleSpinBox` provides ability to add and manipulate native double spin box widgets. + +### Example + +```javascript +const { QDoubleSpinBox } = require("@nodegui/nodegui"); + +const doublespinBox = new QDoubleSpinBox(); +``` + */ +export class QDoubleSpinBox extends QAbstractSpinBox { + native: NativeElement; + constructor(); + constructor(parent: NodeWidget); + constructor(parent?: NodeWidget) { + let native; + if (parent) { + native = new addon.QDoubleSpinBox(parent.native); + } else { + native = new addon.QDoubleSpinBox(); + } + super(native); + this.native = native; + parent && this.setNodeParent(parent); + } + cleanText(): string { + return this.property('cleanText').toString(); + } + setDecimals(prec: number): void { + this.setProperty('decimals', prec); + } + decimals(): number { + return this.property('decimals').toInt(); + } + setMaximum(max: number): void { + this.setProperty('maximum', max); + } + maximum(): number { + return this.property('maximum').toDouble(); + } + setMinimum(min: number): void { + this.setProperty('minimum', min); + } + minimum(): number { + return this.property('minimum').toDouble(); + } + setPrefix(prefix: string): void { + this.setProperty('prefix', prefix); + } + prefix(): string { + return this.property('prefix').toString(); + } + setSingleStep(val: number): void { + this.setProperty('singleStep', val); + } + singleStep(): number { + return this.property('singleStep').toDouble(); + } + setStepType(stepType: StepType): void { + this.setProperty('stepType', stepType); + } + stepType(): StepType { + return this.property('stepType').toInt(); + } + setSuffix(suffix: string): void { + this.setProperty('suffix', suffix); + } + suffix(): string { + return this.property('suffix').toString(); + } + setValue(val: number): void { + this.setProperty('value', val); + } + value(): number { + return this.property('value').toDouble(); + } + setRange(minimum: number, maximum: number): void { + this.native.setRange(minimum, maximum); + } + textFromValue(value: number): string { + return this.native.textFromValue(value); + } + valueFromText(text: string): number { + return this.native.valueFromText(text); + } +} + +export interface QDoubleSpinBoxSignals extends QAbstractSpinBoxSignals { + valueChanged: (value: number) => void; +} From c3ee5b4c4829b80d231856e5b3c91cb99465be23 Mon Sep 17 00:00:00 2001 From: wuxiaofeng Date: Thu, 26 Mar 2020 19:14:44 +0800 Subject: [PATCH 2/7] Add QBrush --- CMakeLists.txt | 1 + .../nodegui/QtGui/QBrush/qbrush_wrap.h | 33 ++++ src/cpp/lib/QtGui/QBrush/qbrush_wrap.cpp | 149 ++++++++++++++++++ src/cpp/main.cpp | 2 + src/index.ts | 1 + src/lib/QtGui/QBrush.ts | 71 +++++++++ 6 files changed, 257 insertions(+) create mode 100644 src/cpp/include/nodegui/QtGui/QBrush/qbrush_wrap.h create mode 100644 src/cpp/lib/QtGui/QBrush/qbrush_wrap.cpp create mode 100644 src/lib/QtGui/QBrush.ts diff --git a/CMakeLists.txt b/CMakeLists.txt index 60a24aa149..773385708e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -38,6 +38,7 @@ add_library(${CORE_WIDGETS_ADDON} SHARED "${PROJECT_SOURCE_DIR}/src/cpp/include/deps/yoga/event/event.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/include/deps/yoga/internal/experiments.cpp" # wrapped cpps + "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtGui/QBrush/qbrush_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtGui/QColor/qcolor_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtGui/QApplication/qapplication_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtGui/QClipboard/qclipboard_wrap.cpp" diff --git a/src/cpp/include/nodegui/QtGui/QBrush/qbrush_wrap.h b/src/cpp/include/nodegui/QtGui/QBrush/qbrush_wrap.h new file mode 100644 index 0000000000..7161c2aeed --- /dev/null +++ b/src/cpp/include/nodegui/QtGui/QBrush/qbrush_wrap.h @@ -0,0 +1,33 @@ +#pragma once + +#include + +#include + +#include "Extras/Export/export.h" +#include "core/Component/component_macro.h" + +class DLL_EXPORT QBrushWrap : public Napi::ObjectWrap { + COMPONENT_WRAPPED_METHODS_DECLARATION + private: + std::unique_ptr instance; + + public: + static Napi::FunctionReference constructor; + static Napi::Object init(Napi::Env env, Napi::Object exports); + QBrushWrap(const Napi::CallbackInfo& info); + ~QBrushWrap(); + QBrush* getInternalInstance(); + // Wrapped methods + Napi::Value isOpaque(const Napi::CallbackInfo& info); + Napi::Value setColor(const Napi::CallbackInfo& info); + Napi::Value color(const Napi::CallbackInfo& info); + Napi::Value setStyle(const Napi::CallbackInfo& info); + Napi::Value style(const Napi::CallbackInfo& info); + Napi::Value setTexture(const Napi::CallbackInfo& info); + Napi::Value texture(const Napi::CallbackInfo& info); +}; + +namespace StaticQBrushWrapMethods { +Napi::Value fromQVariant(const Napi::CallbackInfo& info); +} // namespace StaticQBrushWrapMethods diff --git a/src/cpp/lib/QtGui/QBrush/qbrush_wrap.cpp b/src/cpp/lib/QtGui/QBrush/qbrush_wrap.cpp new file mode 100644 index 0000000000..ffe6a1dbe6 --- /dev/null +++ b/src/cpp/lib/QtGui/QBrush/qbrush_wrap.cpp @@ -0,0 +1,149 @@ +#include "QtGui/QBrush/qbrush_wrap.h" + +#include "Extras/Utils/nutils.h" +#include "QtCore/QVariant/qvariant_wrap.h" +#include "QtGui/QColor/qcolor_wrap.h" +#include "QtGui/QPixmap/qpixmap_wrap.h" + +Napi::FunctionReference QBrushWrap::constructor; + +Napi::Object QBrushWrap::init(Napi::Env env, Napi::Object exports) { + Napi::HandleScope scope(env); + char CLASSNAME[] = "QBrush"; + Napi::Function func = DefineClass( + env, CLASSNAME, + {InstanceMethod("isOpaque", &QBrushWrap::isOpaque), + InstanceMethod("setColor", &QBrushWrap::setColor), + InstanceMethod("color", &QBrushWrap::color), + InstanceMethod("setStyle", &QBrushWrap::setStyle), + InstanceMethod("style", &QBrushWrap::style), + InstanceMethod("setTexture", &QBrushWrap::setTexture), + InstanceMethod("texture", &QBrushWrap::texture), + StaticMethod("fromQVariant", &StaticQBrushWrapMethods::fromQVariant), + COMPONENT_WRAPPED_METHODS_EXPORT_DEFINE(QBrushWrap)}); + constructor = Napi::Persistent(func); + exports.Set(CLASSNAME, func); + return exports; +} + +QBrushWrap::QBrushWrap(const Napi::CallbackInfo& info) + : Napi::ObjectWrap(info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + if (info.Length() == 2) { + if (info[0].IsNumber()) { + Qt::GlobalColor color = + (Qt::GlobalColor)info[0].As().Int32Value(); + Qt::BrushStyle style = + (Qt::BrushStyle)info[1].As().Int32Value(); + this->instance = std::make_unique(color, style); + } else { + Napi::Object colorObject = info[0].As(); + QColorWrap* colorWrap = Napi::ObjectWrap::Unwrap(colorObject); + Qt::BrushStyle style = + (Qt::BrushStyle)info[1].As().Int32Value(); + this->instance = + std::make_unique(*colorWrap->getInternalInstance(), style); + } + } else if (info.Length() == 1) { + this->instance = + std::unique_ptr(info[0].As>().Data()); + } else if (info.Length() == 0) { + this->instance = std::make_unique(); + } else { + Napi::TypeError::New(env, "Wrong number of arguments") + .ThrowAsJavaScriptException(); + } + this->rawData = extrautils::configureComponent(this->getInternalInstance()); +} + +QBrushWrap::~QBrushWrap() { this->instance.reset(); } + +QBrush* QBrushWrap::getInternalInstance() { return this->instance.get(); } + +Napi::Value QBrushWrap::isOpaque(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + return Napi::Boolean::New(env, this->instance->isOpaque()); +} + +Napi::Value QBrushWrap::setColor(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + if (info[0].IsNumber()) { + Qt::GlobalColor color = + (Qt::GlobalColor)info[0].As().Int32Value(); + this->instance->setColor(color); + } else { + Napi::Object colorObject = info[0].As(); + QColorWrap* colorWrap = Napi::ObjectWrap::Unwrap(colorObject); + this->instance->setColor(*colorWrap->getInternalInstance()); + } + return env.Null(); +} + +Napi::Value QBrushWrap::color(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + QColor color = this->instance->color(); + auto instance = QColorWrap::constructor.New( + {Napi::External::New(env, new QColor(color))}); + return instance; +} + +Napi::Value QBrushWrap::setStyle(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + Qt::BrushStyle style = + (Qt::BrushStyle)info[0].As().Int32Value(); + this->instance->setStyle(style); + return env.Null(); +} + +Napi::Value QBrushWrap::style(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + Qt::BrushStyle style = this->instance->style(); + return Napi::Number::New(env, static_cast(style)); +} + +Napi::Value QBrushWrap::setTexture(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + Napi::Object pixmapObject = info[0].As(); + QPixmapWrap* pixmapWrap = Napi::ObjectWrap::Unwrap(pixmapObject); + this->instance->setTexture(*pixmapWrap->getInternalInstance()); + return env.Null(); +} + +Napi::Value QBrushWrap::texture(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + QPixmap pixmap = this->instance->texture(); + auto instance = QPixmapWrap::constructor.New( + {Napi::External::New(env, new QPixmap(pixmap))}); + return instance; +} + +Napi::Value StaticQBrushWrapMethods::fromQVariant( + const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + Napi::Object variantObject = info[0].As(); + QVariantWrap* variantWrap = + Napi::ObjectWrap::Unwrap(variantObject); + QVariant* variant = variantWrap->getInternalInstance(); + QBrush brush = variant->value(); + auto instance = QBrushWrap::constructor.New( + {Napi::External::New(env, new QBrush(brush))}); + return instance; +} diff --git a/src/cpp/main.cpp b/src/cpp/main.cpp index 8cf29c7bcf..73cea906ac 100644 --- a/src/cpp/main.cpp +++ b/src/cpp/main.cpp @@ -13,6 +13,7 @@ #include "QtCore/QUrl/qurl_wrap.h" #include "QtCore/QVariant/qvariant_wrap.h" #include "QtGui/QApplication/qapplication_wrap.h" +#include "QtGui/QBrush/qbrush_wrap.h" #include "QtGui/QClipboard/qclipboard_wrap.h" #include "QtGui/QColor/qcolor_wrap.h" #include "QtGui/QCursor/qcursor_wrap.h" @@ -99,6 +100,7 @@ Napi::Object Main(Napi::Env env, Napi::Object exports) { QTimeWrap::init(env, exports); QUrlWrap::init(env, exports); QVariantWrap::init(env, exports); + QBrushWrap::init(env, exports); QColorWrap::init(env, exports); QClipboardWrap::init(env, exports); QDialogWrap::init(env, exports); diff --git a/src/index.ts b/src/index.ts index bc3809c556..7fb93d2ce5 100644 --- a/src/index.ts +++ b/src/index.ts @@ -4,6 +4,7 @@ import './lib/core/bootstrap'; export * from './lib/QtEnums'; // Gui: export { QApplication } from './lib/QtGui/QApplication'; +export { QBrush } from './lib/QtGui/QBrush'; export { QKeySequence } from './lib/QtGui/QKeySequence'; export { QPicture } from './lib/QtGui/QPicture'; export { QPixmap, ImageFormats } from './lib/QtGui/QPixmap'; diff --git a/src/lib/QtGui/QBrush.ts b/src/lib/QtGui/QBrush.ts new file mode 100644 index 0000000000..8783e1cb59 --- /dev/null +++ b/src/lib/QtGui/QBrush.ts @@ -0,0 +1,71 @@ +import { Component, NativeElement } from '../core/Component'; +import addon from '../utils/addon'; +import { checkIfNativeElement } from '../utils/helpers'; +import { QVariant } from '../QtCore/QVariant'; +import { GlobalColor, BrushStyle } from '../QtEnums'; +import { QColor } from './QColor'; +import { QPixmap } from './QPixmap'; + +/** + +> The QBrush class defines the fill pattern of shapes drawn by QPainter. + +* **This class is a JS wrapper around Qt's [QBrush class](https://doc.qt.io/qt-5/qbrush.html)** + +### Example + +```javascript +const { QBrush } = require("@nodegui/nodegui"); + +const brush = new QBrush(); +``` + */ +export class QBrush extends Component { + native: NativeElement; + constructor(); + constructor(nativeElement: NativeElement); + constructor(color: GlobalColor, style: BrushStyle); + constructor(color: QColor, style: BrushStyle); + constructor(arg?: NativeElement | GlobalColor | QColor, style = BrushStyle.SolidPattern) { + super(); + if (arguments.length === 2) { + if (typeof arg === 'number') { + this.native = new addon.QBrush(arg, style); + } else { + this.native = new addon.QBrush(arg?.native, style); + } + } else if (checkIfNativeElement(arg)) { + this.native = arg as NativeElement; + } else { + this.native = new addon.QBrush(); + } + } + isOpaque(): boolean { + return this.native.isOpaque(); + } + setColor(color: QColor | GlobalColor): void { + if (typeof color === 'number') { + this.native.setColor(color); + } else { + this.native.setColor(color.native); + } + } + color(): QColor { + return new QColor(this.native.color()); + } + setStyle(style: BrushStyle): void { + this.native.setStyle(style); + } + style(): BrushStyle { + return this.native.style(); + } + setTexture(pixmap: QPixmap): void { + this.native.setTexture(pixmap.native); + } + texture(): QPixmap { + return new QPixmap(this.native.texture()); + } + static fromQVariant(variant: QVariant): QBrush { + return new QBrush(addon.QBrush.fromQVariant(variant.native)); + } +} From 86ffd6cbfc7d7adf7791ad495b250d933f3e15c3 Mon Sep 17 00:00:00 2001 From: wuxiaofeng Date: Sat, 28 Mar 2020 18:48:53 +0800 Subject: [PATCH 3/7] Add QListView and improve QListWidget --- CMakeLists.txt | 2 + .../nodegui/QtWidgets/QListView/nlistview.hpp | 16 ++ .../QtWidgets/QListView/qlistview_macro.h | 18 +- .../QtWidgets/QListView/qlistview_wrap.h | 25 +++ .../QtWidgets/QListWidget/nlistwidget.hpp | 82 +++++++- .../QtWidgets/QListWidget/qlistwidget_wrap.h | 7 +- .../QListWidgetItem/qlistwidgetitem_wrap.h | 12 +- .../QtWidgets/QListView/qlistview_wrap.cpp | 53 +++++ .../QListWidget/qlistwidget_wrap.cpp | 50 ++++- .../QListWidgetItem/qlistwidgetitem_wrap.cpp | 100 +++++++++- src/cpp/main.cpp | 2 + src/index.ts | 9 + src/lib/QtWidgets/QListView.ts | 163 +++++++++++++++ src/lib/QtWidgets/QListWidget.ts | 186 ++++-------------- src/lib/QtWidgets/QListWidgetItem.ts | 38 +++- 15 files changed, 588 insertions(+), 175 deletions(-) create mode 100644 src/cpp/include/nodegui/QtWidgets/QListView/nlistview.hpp create mode 100644 src/cpp/include/nodegui/QtWidgets/QListView/qlistview_wrap.h create mode 100644 src/cpp/lib/QtWidgets/QListView/qlistview_wrap.cpp create mode 100644 src/lib/QtWidgets/QListView.ts diff --git a/CMakeLists.txt b/CMakeLists.txt index 773385708e..1b9e33b9bd 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -75,6 +75,7 @@ add_library(${CORE_WIDGETS_ADDON} SHARED "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QDoubleSpinBox/qdoublespinbox_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QFileDialog/qfiledialog_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QFrame/qframe_wrap.cpp" + "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QListView/qlistview_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QListWidget/qlistwidget_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QListWidgetItem/qlistwidgetitem_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QTableView/qtableview_wrap.cpp" @@ -133,6 +134,7 @@ add_library(${CORE_WIDGETS_ADDON} SHARED "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QDoubleSpinBox/ndoublespinbox.hpp" "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QFileDialog/nfiledialog.hpp" "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QFrame/nframe.hpp" + "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QListView/nlistview.hpp" "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QListWidget/nlistwidget.hpp" "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QTableView/ntableview.hpp" "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QTableWidget/ntablewidget.hpp" diff --git a/src/cpp/include/nodegui/QtWidgets/QListView/nlistview.hpp b/src/cpp/include/nodegui/QtWidgets/QListView/nlistview.hpp new file mode 100644 index 0000000000..d054824bf5 --- /dev/null +++ b/src/cpp/include/nodegui/QtWidgets/QListView/nlistview.hpp @@ -0,0 +1,16 @@ +#pragma once + +#include + +#include "Extras/Export/export.h" +#include "QtWidgets/QListView/qlistview_macro.h" +#include "core/NodeWidget/nodewidget.h" + +class DLL_EXPORT NListView : public QListView, public NodeWidget { + Q_OBJECT + NODEWIDGET_IMPLEMENTATIONS(QListView) + public: + using QListView::QListView; + + void connectSignalsToEventEmitter() { QLISTVIEW_SIGNALS } +}; diff --git a/src/cpp/include/nodegui/QtWidgets/QListView/qlistview_macro.h b/src/cpp/include/nodegui/QtWidgets/QListView/qlistview_macro.h index 9dc941487c..4dc17093b5 100644 --- a/src/cpp/include/nodegui/QtWidgets/QListView/qlistview_macro.h +++ b/src/cpp/include/nodegui/QtWidgets/QListView/qlistview_macro.h @@ -12,8 +12,8 @@ and every widget we export. */ -#ifndef QListView_WRAPPED_METHODS_DECLARATION -#define QListView_WRAPPED_METHODS_DECLARATION \ +#ifndef QLISTVIEW_WRAPPED_METHODS_DECLARATION +#define QLISTVIEW_WRAPPED_METHODS_DECLARATION \ QABSTRACTITEMVIEW_WRAPPED_METHODS_DECLARATION \ Napi::Value clearPropertyFlags(const Napi::CallbackInfo& info) { \ Napi::Env env = info.Env(); \ @@ -36,18 +36,18 @@ return Napi::Boolean::New(env, this->instance->isRowHidden(row)); \ } -#endif // QListView_WRAPPED_METHODS_DECLARATION +#endif // QLISTVIEW_WRAPPED_METHODS_DECLARATION -#ifndef QListView_WRAPPED_METHODS_EXPORT_DEFINE -#define QListView_WRAPPED_METHODS_EXPORT_DEFINE(WidgetWrapName) \ +#ifndef QLISTVIEW_WRAPPED_METHODS_EXPORT_DEFINE +#define QLISTVIEW_WRAPPED_METHODS_EXPORT_DEFINE(WidgetWrapName) \ QABSTRACTITEMVIEW_WRAPPED_METHODS_EXPORT_DEFINE(WidgetWrapName) \ InstanceMethod("clearPropertyFlags", &WidgetWrapName::clearPropertyFlags), \ InstanceMethod("setRowHidden", &WidgetWrapName::setRowHidden), \ InstanceMethod("isRowHidden", &WidgetWrapName::isRowHidden), -#endif // QListView_WRAPPED_METHODS_EXPORT_DEFINE +#endif // QLISTVIEW_WRAPPED_METHODS_EXPORT_DEFINE -#ifndef QListView_SIGNALS -#define QListView_SIGNALS QABSTRACTITEMVIEW_SIGNALS +#ifndef QLISTVIEW_SIGNALS +#define QLISTVIEW_SIGNALS QABSTRACTITEMVIEW_SIGNALS -#endif // QListView_SIGNALS +#endif // QLISTVIEW_SIGNALS diff --git a/src/cpp/include/nodegui/QtWidgets/QListView/qlistview_wrap.h b/src/cpp/include/nodegui/QtWidgets/QListView/qlistview_wrap.h new file mode 100644 index 0000000000..ba0d07f584 --- /dev/null +++ b/src/cpp/include/nodegui/QtWidgets/QListView/qlistview_wrap.h @@ -0,0 +1,25 @@ +#pragma once + +#include + +#include + +#include "Extras/Export/export.h" +#include "QtWidgets/QWidget/qwidget_macro.h" +#include "nlistview.hpp" + +class DLL_EXPORT QListViewWrap : public Napi::ObjectWrap { + QLISTVIEW_WRAPPED_METHODS_DECLARATION + private: + QPointer instance; + bool disableDeletion; + + public: + static Napi::Object init(Napi::Env env, Napi::Object exports); + QListViewWrap(const Napi::CallbackInfo& info); + ~QListViewWrap(); + NListView* getInternalInstance(); + // class constructor + static Napi::FunctionReference constructor; + // wrapped methods +}; diff --git a/src/cpp/include/nodegui/QtWidgets/QListWidget/nlistwidget.hpp b/src/cpp/include/nodegui/QtWidgets/QListWidget/nlistwidget.hpp index 546eee712d..8fac0c8614 100644 --- a/src/cpp/include/nodegui/QtWidgets/QListWidget/nlistwidget.hpp +++ b/src/cpp/include/nodegui/QtWidgets/QListWidget/nlistwidget.hpp @@ -1,4 +1,5 @@ #pragma once + #include #include @@ -13,7 +14,24 @@ class DLL_EXPORT NListWidget : public QListWidget, public NodeWidget { NODEWIDGET_IMPLEMENTATIONS(QListWidget) public: using QListWidget::QListWidget; + void connectSignalsToEventEmitter() { + QLISTVIEW_SIGNALS + // Qt Connects: Implement all signal connects here + QObject::connect( + this, &QListWidget::currentItemChanged, + [=](QListWidgetItem* current, QListWidgetItem* previous) { + Napi::Env env = this->emitOnNode.Env(); + Napi::HandleScope scope(env); + auto curInstance = QListWidgetItemWrap::constructor.New( + {Napi::External::New(env, current), + Napi::Boolean::New(env, true)}); + auto preInstance = QListWidgetItemWrap::constructor.New( + {Napi::External::New(env, previous), + Napi::Boolean::New(env, true)}); + this->emitOnNode.Call({Napi::String::New(env, "currentItemChanged"), + curInstance, preInstance}); + }); QObject::connect( this, &QListWidget::currentRowChanged, [=](int currentRow) { Napi::Env env = this->emitOnNode.Env(); @@ -22,19 +40,77 @@ class DLL_EXPORT NListWidget : public QListWidget, public NodeWidget { Napi::Number::New(env, currentRow)}); }); QObject::connect(this, &QListWidget::currentTextChanged, - [=](const QString ¤tText) { + [=](const QString& currentText) { Napi::Env env = this->emitOnNode.Env(); Napi::HandleScope scope(env); this->emitOnNode.Call( {Napi::String::New(env, "currentTextChanged"), Napi::String::New(env, currentText.toStdString())}); }); + QObject::connect(this, &QListWidget::itemActivated, + [=](QListWidgetItem* item) { + Napi::Env env = this->emitOnNode.Env(); + Napi::HandleScope scope(env); + auto instance = QListWidgetItemWrap::constructor.New( + {Napi::External::New(env, item), + Napi::Boolean::New(env, true)}); + this->emitOnNode.Call( + {Napi::String::New(env, "itemActivated"), instance}); + }); + QObject::connect(this, &QListWidget::itemChanged, + [=](QListWidgetItem* item) { + Napi::Env env = this->emitOnNode.Env(); + Napi::HandleScope scope(env); + auto instance = QListWidgetItemWrap::constructor.New( + {Napi::External::New(env, item), + Napi::Boolean::New(env, true)}); + this->emitOnNode.Call( + {Napi::String::New(env, "itemChanged"), instance}); + }); + QObject::connect(this, &QListWidget::itemClicked, + [=](QListWidgetItem* item) { + Napi::Env env = this->emitOnNode.Env(); + Napi::HandleScope scope(env); + auto instance = QListWidgetItemWrap::constructor.New( + {Napi::External::New(env, item), + Napi::Boolean::New(env, true)}); + this->emitOnNode.Call( + {Napi::String::New(env, "itemClicked"), instance}); + }); + QObject::connect( + this, &QListWidget::itemDoubleClicked, [=](QListWidgetItem* item) { + Napi::Env env = this->emitOnNode.Env(); + Napi::HandleScope scope(env); + auto instance = QListWidgetItemWrap::constructor.New( + {Napi::External::New(env, item), + Napi::Boolean::New(env, true)}); + this->emitOnNode.Call( + {Napi::String::New(env, "itemDoubleClicked"), instance}); + }); + QObject::connect(this, &QListWidget::itemEntered, + [=](QListWidgetItem* item) { + Napi::Env env = this->emitOnNode.Env(); + Napi::HandleScope scope(env); + auto instance = QListWidgetItemWrap::constructor.New( + {Napi::External::New(env, item), + Napi::Boolean::New(env, true)}); + this->emitOnNode.Call( + {Napi::String::New(env, "itemEntered"), instance}); + }); + QObject::connect(this, &QListWidget::itemPressed, + [=](QListWidgetItem* item) { + Napi::Env env = this->emitOnNode.Env(); + Napi::HandleScope scope(env); + auto instance = QListWidgetItemWrap::constructor.New( + {Napi::External::New(env, item), + Napi::Boolean::New(env, true)}); + this->emitOnNode.Call( + {Napi::String::New(env, "itemPressed"), instance}); + }); QObject::connect(this, &QListWidget::itemSelectionChanged, [=]() { Napi::Env env = this->emitOnNode.Env(); Napi::HandleScope scope(env); this->emitOnNode.Call({Napi::String::New(env, "itemSelectionChanged")}); }); - - QListView_SIGNALS } }; diff --git a/src/cpp/include/nodegui/QtWidgets/QListWidget/qlistwidget_wrap.h b/src/cpp/include/nodegui/QtWidgets/QListWidget/qlistwidget_wrap.h index a0496ef19d..a2594b9924 100644 --- a/src/cpp/include/nodegui/QtWidgets/QListWidget/qlistwidget_wrap.h +++ b/src/cpp/include/nodegui/QtWidgets/QListWidget/qlistwidget_wrap.h @@ -10,8 +10,9 @@ #include "QtWidgets/QListWidget/nlistwidget.hpp" class DLL_EXPORT QListWidgetWrap : public Napi::ObjectWrap { - QListView_WRAPPED_METHODS_DECLARATION private : QPointer - instance; + QLISTVIEW_WRAPPED_METHODS_DECLARATION + private: + QPointer instance; public: static Napi::Object init(Napi::Env env, Napi::Object exports); @@ -26,6 +27,7 @@ class DLL_EXPORT QListWidgetWrap : public Napi::ObjectWrap { Napi::Value closePersistentEditor(const Napi::CallbackInfo& info); Napi::Value currentItem(const Napi::CallbackInfo& info); Napi::Value editItem(const Napi::CallbackInfo& info); + Napi::Value findItems(const Napi::CallbackInfo& info); Napi::Value insertItem(const Napi::CallbackInfo& info); Napi::Value insertItems(const Napi::CallbackInfo& info); Napi::Value isPersistentEditorOpen(const Napi::CallbackInfo& info); @@ -35,6 +37,7 @@ class DLL_EXPORT QListWidgetWrap : public Napi::ObjectWrap { Napi::Value openPersistentEditor(const Napi::CallbackInfo& info); Napi::Value removeItemWidget(const Napi::CallbackInfo& info); Napi::Value row(const Napi::CallbackInfo& info); + Napi::Value selectedItems(const Napi::CallbackInfo& info); Napi::Value setCurrentItem(const Napi::CallbackInfo& info); Napi::Value setItemWidget(const Napi::CallbackInfo& info); Napi::Value sortItems(const Napi::CallbackInfo& info); diff --git a/src/cpp/include/nodegui/QtWidgets/QListWidgetItem/qlistwidgetitem_wrap.h b/src/cpp/include/nodegui/QtWidgets/QListWidgetItem/qlistwidgetitem_wrap.h index 6e1a2f6009..a052184e0d 100644 --- a/src/cpp/include/nodegui/QtWidgets/QListWidgetItem/qlistwidgetitem_wrap.h +++ b/src/cpp/include/nodegui/QtWidgets/QListWidgetItem/qlistwidgetitem_wrap.h @@ -4,10 +4,12 @@ #include +#include "Extras/Export/export.h" #include "core/Component/component_wrap.h" class DLL_EXPORT QListWidgetItemWrap : public Napi::ObjectWrap { + COMPONENT_WRAPPED_METHODS_DECLARATION private: QListWidgetItem* instance; bool disableDeletion; @@ -20,11 +22,18 @@ class DLL_EXPORT QListWidgetItemWrap // class constructor static Napi::FunctionReference constructor; // wrapped methods + Napi::Value setBackground(const Napi::CallbackInfo& info); + Napi::Value background(const Napi::CallbackInfo& info); Napi::Value setCheckState(const Napi::CallbackInfo& info); Napi::Value checkState(const Napi::CallbackInfo& info); + Napi::Value setData(const Napi::CallbackInfo& info); Napi::Value data(const Napi::CallbackInfo& info); Napi::Value setFlags(const Napi::CallbackInfo& info); Napi::Value flags(const Napi::CallbackInfo& info); + Napi::Value setFont(const Napi::CallbackInfo& info); + Napi::Value font(const Napi::CallbackInfo& info); + Napi::Value setForeground(const Napi::CallbackInfo& info); + Napi::Value foreground(const Napi::CallbackInfo& info); Napi::Value setIcon(const Napi::CallbackInfo& info); Napi::Value icon(const Napi::CallbackInfo& info); Napi::Value setHidden(const Napi::CallbackInfo& info); @@ -43,6 +52,5 @@ class DLL_EXPORT QListWidgetItemWrap Napi::Value toolTip(const Napi::CallbackInfo& info); Napi::Value setWhatsThis(const Napi::CallbackInfo& info); Napi::Value whatsThis(const Napi::CallbackInfo& info); - - COMPONENT_WRAPPED_METHODS_DECLARATION + Napi::Value type(const Napi::CallbackInfo& info); }; diff --git a/src/cpp/lib/QtWidgets/QListView/qlistview_wrap.cpp b/src/cpp/lib/QtWidgets/QListView/qlistview_wrap.cpp new file mode 100644 index 0000000000..baad111a0c --- /dev/null +++ b/src/cpp/lib/QtWidgets/QListView/qlistview_wrap.cpp @@ -0,0 +1,53 @@ +#include "QtWidgets/QListView/qlistview_wrap.h" + +#include "Extras/Utils/nutils.h" + +Napi::FunctionReference QListViewWrap::constructor; + +Napi::Object QListViewWrap::init(Napi::Env env, Napi::Object exports) { + Napi::HandleScope scope(env); + char CLASSNAME[] = "QListView"; + Napi::Function func = DefineClass( + env, CLASSNAME, {QLISTVIEW_WRAPPED_METHODS_EXPORT_DEFINE(QListViewWrap)}); + constructor = Napi::Persistent(func); + exports.Set(CLASSNAME, func); + return exports; +} + +NListView* QListViewWrap::getInternalInstance() { return this->instance; } + +QListViewWrap::~QListViewWrap() { + if (!this->disableDeletion) { + extrautils::safeDelete(this->instance); + } +} + +QListViewWrap::QListViewWrap(const Napi::CallbackInfo& info) + : Napi::ObjectWrap(info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + if (info.Length() > 0 && info[0].IsExternal()) { + // --- if external --- + this->instance = info[0].As>().Data(); + if (info.Length() == 2) { + this->disableDeletion = info[1].As().Value(); + } + } else { + // --- regular cases --- + if (info.Length() == 1) { + Napi::Object parentObject = info[0].As(); + NodeWidgetWrap* parentWidgetWrap = + Napi::ObjectWrap::Unwrap(parentObject); + this->instance = new NListView(parentWidgetWrap->getInternalInstance()); + } else if (info.Length() == 0) { + this->instance = new NListView(); + } else { + Napi::TypeError::New(env, "Wrong number of arguments") + .ThrowAsJavaScriptException(); + } + } + this->rawData = extrautils::configureQWidget( + this->getInternalInstance(), this->getInternalInstance()->getFlexNode(), + true); +} diff --git a/src/cpp/lib/QtWidgets/QListWidget/qlistwidget_wrap.cpp b/src/cpp/lib/QtWidgets/QListWidget/qlistwidget_wrap.cpp index 6d71c74c68..2fed91f235 100644 --- a/src/cpp/lib/QtWidgets/QListWidget/qlistwidget_wrap.cpp +++ b/src/cpp/lib/QtWidgets/QListWidget/qlistwidget_wrap.cpp @@ -18,6 +18,7 @@ Napi::Object QListWidgetWrap::init(Napi::Env env, Napi::Object exports) { &QListWidgetWrap::closePersistentEditor), InstanceMethod("currentItem", &QListWidgetWrap::currentItem), InstanceMethod("editItem", &QListWidgetWrap::editItem), + InstanceMethod("findItems", &QListWidgetWrap::findItems), InstanceMethod("insertItem", &QListWidgetWrap::insertItem), InstanceMethod("insertItems", &QListWidgetWrap::insertItems), InstanceMethod("isPersistentEditorOpen", @@ -29,6 +30,7 @@ Napi::Object QListWidgetWrap::init(Napi::Env env, Napi::Object exports) { &QListWidgetWrap::openPersistentEditor), InstanceMethod("removeItemWidget", &QListWidgetWrap::removeItemWidget), InstanceMethod("row", &QListWidgetWrap::row), + InstanceMethod("selectedItems", &QListWidgetWrap::selectedItems), InstanceMethod("setCurrentItem", &QListWidgetWrap::setCurrentItem), InstanceMethod("setItemWidget", &QListWidgetWrap::setItemWidget), InstanceMethod("sortItems", &QListWidgetWrap::sortItems), @@ -36,7 +38,7 @@ Napi::Object QListWidgetWrap::init(Napi::Env env, Napi::Object exports) { InstanceMethod("visualItemRect", &QListWidgetWrap::visualItemRect), InstanceMethod("clear", &QListWidgetWrap::clear), InstanceMethod("scrollToItem", &QListWidgetWrap::scrollToItem), - QListView_WRAPPED_METHODS_EXPORT_DEFINE(QListWidgetWrap)}); + QLISTVIEW_WRAPPED_METHODS_EXPORT_DEFINE(QListWidgetWrap)}); constructor = Napi::Persistent(func); exports.Set(CLASSNAME, func); return exports; @@ -127,6 +129,27 @@ Napi::Value QListWidgetWrap::editItem(const Napi::CallbackInfo& info) { return env.Null(); } +Napi::Value QListWidgetWrap::findItems(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + std::string napiText = info[0].As().Utf8Value(); + QString text = QString::fromUtf8(napiText.c_str()); + int flags = info[1].As().Int32Value(); + QList items = + this->instance->findItems(text, static_cast(flags)); + Napi::Array napiItems = Napi::Array::New(env, items.size()); + for (int i = 0; i < items.size(); i++) { + QListWidgetItem* item = items[i]; + // disable deletion of the native instance for these by passing true + auto instance = QListWidgetItemWrap::constructor.New( + {Napi::External::New(env, item), + Napi::Boolean::New(env, true)}); + napiItems[i] = instance; + } + return napiItems; +} + Napi::Value QListWidgetWrap::insertItem(const Napi::CallbackInfo& info) { Napi::Env env = info.Env(); Napi::HandleScope scope(env); @@ -165,7 +188,7 @@ Napi::Value QListWidgetWrap::isPersistentEditorOpen( Napi::ObjectWrap::Unwrap(itemObject); bool open = this->instance->isPersistentEditorOpen(itemWrap->getInternalInstance()); - return Napi::Value::From(env, open); + return Napi::Boolean::New(env, open); } Napi::Value QListWidgetWrap::item(const Napi::CallbackInfo& info) { @@ -238,7 +261,24 @@ Napi::Value QListWidgetWrap::row(const Napi::CallbackInfo& info) { QListWidgetItemWrap* itemWrap = Napi::ObjectWrap::Unwrap(itemObject); int row = this->instance->row(itemWrap->getInternalInstance()); - return Napi::Value::From(env, row); + return Napi::Number::New(env, row); +} + +Napi::Value QListWidgetWrap::selectedItems(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + QList items = this->instance->selectedItems(); + Napi::Array napiItems = Napi::Array::New(env, items.size()); + for (int i = 0; i < items.size(); i++) { + QListWidgetItem* item = items[i]; + // disable deletion of the native instance for these by passing true + auto instance = QListWidgetItemWrap::constructor.New( + {Napi::External::New(env, item), + Napi::Boolean::New(env, true)}); + napiItems[i] = instance; + } + return napiItems; } Napi::Value QListWidgetWrap::setCurrentItem(const Napi::CallbackInfo& info) { @@ -293,9 +333,9 @@ Napi::Value QListWidgetWrap::visualItemRect(const Napi::CallbackInfo& info) { QListWidgetItemWrap* itemWrap = Napi::ObjectWrap::Unwrap(itemObject); QRect rect = this->instance->visualItemRect(itemWrap->getInternalInstance()); - auto rectWrap = QRectWrap::constructor.New( + auto instance = QRectWrap::constructor.New( {Napi::External::New(env, new QRect(rect))}); - return rectWrap; + return instance; } Napi::Value QListWidgetWrap::clear(const Napi::CallbackInfo& info) { diff --git a/src/cpp/lib/QtWidgets/QListWidgetItem/qlistwidgetitem_wrap.cpp b/src/cpp/lib/QtWidgets/QListWidgetItem/qlistwidgetitem_wrap.cpp index 930ded64ef..5de8f3a9bf 100644 --- a/src/cpp/lib/QtWidgets/QListWidgetItem/qlistwidgetitem_wrap.cpp +++ b/src/cpp/lib/QtWidgets/QListWidgetItem/qlistwidgetitem_wrap.cpp @@ -3,6 +3,8 @@ #include "Extras/Utils/nutils.h" #include "QtCore/QSize/qsize_wrap.h" #include "QtCore/QVariant/qvariant_wrap.h" +#include "QtGui/QBrush/qbrush_wrap.h" +#include "QtGui/QFont/qfont_wrap.h" #include "QtGui/QIcon/qicon_wrap.h" #include "core/Component/component_wrap.h" @@ -13,11 +15,18 @@ Napi::Object QListWidgetItemWrap::init(Napi::Env env, Napi::Object exports) { char CLASSNAME[] = "QListWidgetItem"; Napi::Function func = DefineClass( env, CLASSNAME, - {InstanceMethod("setCheckState", &QListWidgetItemWrap::setCheckState), + {InstanceMethod("setBackground", &QListWidgetItemWrap::setBackground), + InstanceMethod("background", &QListWidgetItemWrap::background), + InstanceMethod("setCheckState", &QListWidgetItemWrap::setCheckState), InstanceMethod("checkState", &QListWidgetItemWrap::checkState), + InstanceMethod("setData", &QListWidgetItemWrap::setData), InstanceMethod("data", &QListWidgetItemWrap::data), InstanceMethod("setFlags", &QListWidgetItemWrap::setFlags), InstanceMethod("flags", &QListWidgetItemWrap::flags), + InstanceMethod("setFont", &QListWidgetItemWrap::setFont), + InstanceMethod("font", &QListWidgetItemWrap::font), + InstanceMethod("setForeground", &QListWidgetItemWrap::setForeground), + InstanceMethod("foreground", &QListWidgetItemWrap::foreground), InstanceMethod("setIcon", &QListWidgetItemWrap::setIcon), InstanceMethod("icon", &QListWidgetItemWrap::icon), InstanceMethod("setHidden", &QListWidgetItemWrap::setHidden), @@ -37,6 +46,7 @@ Napi::Object QListWidgetItemWrap::init(Napi::Env env, Napi::Object exports) { InstanceMethod("toolTip", &QListWidgetItemWrap::toolTip), InstanceMethod("setWhatsThis", &QListWidgetItemWrap::setWhatsThis), InstanceMethod("whatsThis", &QListWidgetItemWrap::whatsThis), + InstanceMethod("type$", &QListWidgetItemWrap::type), COMPONENT_WRAPPED_METHODS_EXPORT_DEFINE(QListWidgetItemWrap)}); constructor = Napi::Persistent(func); exports.Set(CLASSNAME, func); @@ -80,6 +90,26 @@ QListWidgetItemWrap::QListWidgetItemWrap(const Napi::CallbackInfo& info) this->rawData = extrautils::configureComponent(this->getInternalInstance()); } +Napi::Value QListWidgetItemWrap::setBackground(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + Napi::Object brushObject = info[0].As(); + QBrushWrap* brushWrap = Napi::ObjectWrap::Unwrap(brushObject); + this->instance->setBackground(*brushWrap->getInternalInstance()); + return env.Null(); +} + +Napi::Value QListWidgetItemWrap::background(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + QBrush brush = this->instance->background(); + auto instance = QBrushWrap::constructor.New( + {Napi::External::New(env, new QBrush(brush))}); + return instance; +} + Napi::Value QListWidgetItemWrap::setCheckState(const Napi::CallbackInfo& info) { Napi::Env env = info.Env(); Napi::HandleScope scope(env); @@ -94,12 +124,25 @@ Napi::Value QListWidgetItemWrap::checkState(const Napi::CallbackInfo& info) { Napi::HandleScope scope(env); int state = static_cast(this->instance->checkState()); - return Napi::Value::From(env, state); + return Napi::Number::New(env, state); +} + +Napi::Value QListWidgetItemWrap::setData(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + int role = info[0].As().Int32Value(); + Napi::Object variantObject = info[1].As(); + QVariantWrap* variantWrap = + Napi::ObjectWrap::Unwrap(variantObject); + this->instance->setData(role, *variantWrap->getInternalInstance()); + return env.Null(); } Napi::Value QListWidgetItemWrap::data(const Napi::CallbackInfo& info) { Napi::Env env = info.Env(); Napi::HandleScope scope(env); + int role = info[0].As().Int32Value(); QVariant data = this->instance->data(role); auto instance = QVariantWrap::constructor.New( @@ -121,7 +164,47 @@ Napi::Value QListWidgetItemWrap::flags(const Napi::CallbackInfo& info) { Napi::HandleScope scope(env); int flags = static_cast(this->instance->flags()); - return Napi::Value::From(env, flags); + return Napi::Number::New(env, flags); +} + +Napi::Value QListWidgetItemWrap::setFont(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + Napi::Object fontObject = info[0].As(); + QFontWrap* fontWrap = Napi::ObjectWrap::Unwrap(fontObject); + this->instance->setFont(*fontWrap->getInternalInstance()); + return env.Null(); +} + +Napi::Value QListWidgetItemWrap::font(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + QFont font = this->instance->font(); + auto instance = QFontWrap::constructor.New( + {Napi::External::New(env, new QFont(font))}); + return instance; +} + +Napi::Value QListWidgetItemWrap::setForeground(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + Napi::Object brushObject = info[0].As(); + QBrushWrap* brushWrap = Napi::ObjectWrap::Unwrap(brushObject); + this->instance->setForeground(*brushWrap->getInternalInstance()); + return env.Null(); +} + +Napi::Value QListWidgetItemWrap::foreground(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + QBrush brush = this->instance->foreground(); + auto instance = QBrushWrap::constructor.New( + {Napi::External::New(env, new QBrush(brush))}); + return instance; } Napi::Value QListWidgetItemWrap::setIcon(const Napi::CallbackInfo& info) { @@ -157,7 +240,7 @@ Napi::Value QListWidgetItemWrap::isHidden(const Napi::CallbackInfo& info) { Napi::Env env = info.Env(); Napi::HandleScope scope(env); - return Napi::Value::From(env, this->instance->isHidden()); + return Napi::Boolean::New(env, this->instance->isHidden()); } Napi::Value QListWidgetItemWrap::setSelected(const Napi::CallbackInfo& info) { @@ -173,7 +256,7 @@ Napi::Value QListWidgetItemWrap::isSelected(const Napi::CallbackInfo& info) { Napi::Env env = info.Env(); Napi::HandleScope scope(env); - return Napi::Value::From(env, this->instance->isSelected()); + return Napi::Boolean::New(env, this->instance->isSelected()); } Napi::Value QListWidgetItemWrap::setSizeHint(const Napi::CallbackInfo& info) { @@ -281,3 +364,10 @@ Napi::Value QListWidgetItemWrap::whatsThis(const Napi::CallbackInfo& info) { std::string whatsThis = this->instance->whatsThis().toStdString(); return Napi::String::New(env, whatsThis); } + +Napi::Value QListWidgetItemWrap::type(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + return Napi::Number::New(env, this->instance->type()); +} diff --git a/src/cpp/main.cpp b/src/cpp/main.cpp index 73cea906ac..dd2752d378 100644 --- a/src/cpp/main.cpp +++ b/src/cpp/main.cpp @@ -47,6 +47,7 @@ #include "QtWidgets/QLabel/qlabel_wrap.h" #include "QtWidgets/QLayout/qlayout_wrap.h" #include "QtWidgets/QLineEdit/qlineedit_wrap.h" +#include "QtWidgets/QListView/qlistview_wrap.h" #include "QtWidgets/QListWidget/qlistwidget_wrap.h" #include "QtWidgets/QListWidgetItem/qlistwidgetitem_wrap.h" #include "QtWidgets/QMainWindow/qmainwindow_wrap.h" @@ -123,6 +124,7 @@ Napi::Object Main(Napi::Env env, Napi::Object exports) { QDateTimeEditWrap::init(env, exports); QFileDialogWrap::init(env, exports); QFrameWrap::init(env, exports); + QListViewWrap::init(env, exports); QListWidgetWrap::init(env, exports); QListWidgetItemWrap::init(env, exports); QTableViewWrap::init(env, exports); diff --git a/src/index.ts b/src/index.ts index 7fb93d2ce5..92eb0c41f9 100644 --- a/src/index.ts +++ b/src/index.ts @@ -54,6 +54,15 @@ export { QToolButton, QToolButtonSignals, ToolButtonPopupMode } from './lib/QtWi export { QSpinBox, QSpinBoxSignals } from './lib/QtWidgets/QSpinBox'; export { QRadioButton, QRadioButtonSignals } from './lib/QtWidgets/QRadioButton'; export { QStackedWidget, QStackedWidgetSignals } from './lib/QtWidgets/QStackedWidget'; +export { + QListView, + QListViewSignals, + Flow, + LayoutMode, + Movement, + ResizeMode, + ViewMode, +} from './lib/QtWidgets/QListView'; export { QListWidget, QListWidgetSignals } from './lib/QtWidgets/QListWidget'; export { QListWidgetItem } from './lib/QtWidgets/QListWidgetItem'; export { QTabBar, QTabBarSignals, ButtonPosition, SelectionBehavior, TabBarShape } from './lib/QtWidgets/QTabBar'; diff --git a/src/lib/QtWidgets/QListView.ts b/src/lib/QtWidgets/QListView.ts new file mode 100644 index 0000000000..8554c925b0 --- /dev/null +++ b/src/lib/QtWidgets/QListView.ts @@ -0,0 +1,163 @@ +import addon from '../utils/addon'; +import { NodeWidget } from './QWidget'; +import { NativeElement } from '../core/Component'; +import { QAbstractItemView, QAbstractItemViewSignals } from './QAbstractItemView'; +import { QSize } from '../QtCore/QSize'; +import { AlignmentFlag } from '../..'; + +/** + +> The QListView class provides a list or icon view onto a model. + +* **This class is a JS wrapper around Qt's [QListView class](https://doc.qt.io/qt-5/qlistview.html)** + +### Example + +```javascript +const { QListView } = require("@nodegui/nodegui"); + +const listview = new QListView(); + +``` + */ +export abstract class NodeListView extends QAbstractItemView { + setBatchSize(batchSize: number): void { + this.setProperty('batchSize', batchSize); + } + batchSize(): number { + return this.property('batchSize').toInt(); + } + setFlow(flow: Flow): void { + this.setProperty('flow', flow); + } + flow(): Flow { + return this.property('flow').toInt(); + } + setGridSize(size: QSize): void { + this.setProperty('gridSize', size.native); + } + gridSize(): QSize { + const gridSize = this.property('gridSize'); + return QSize.fromQVariant(gridSize); + } + setWrapping(enable: boolean): void { + this.setProperty('isWrapping', enable); + } + isWrapping(): boolean { + return this.property('isWrapping').toBool(); + } + setItemAlignment(alignment: AlignmentFlag): void { + this.setProperty('itemAlignment', alignment); + } + itemAlignment(): AlignmentFlag { + return this.property('itemAlignment').toInt(); + } + setLayoutMode(mode: LayoutMode): void { + this.setProperty('layoutMode', mode); + } + layoutMode(): LayoutMode { + return this.property('layoutMode').toInt(); + } + setModelColumn(column: number): void { + this.setProperty('modelColumn', column); + } + modelColumn(): number { + return this.property('modelColumn').toInt(); + } + setMovement(movement: Movement): void { + this.setProperty('movement', movement); + } + movement(): Movement { + return this.property('movement').toInt(); + } + setResizeMode(mode: ResizeMode): void { + this.setProperty('resizeMode', mode); + } + resizeMode(): ResizeMode { + return this.property('resizeMode').toInt(); + } + setSelectionRectVisible(show: boolean): void { + this.setProperty('selectionRectVisible', show); + } + isSelectionRectVisible(): boolean { + return this.property('selectionRectVisible').toBool(); + } + setSpacing(space: number): void { + this.setProperty('spacing', space); + } + spacing(): number { + return this.property('spacing').toInt(); + } + setUniformItemSizes(enable: boolean): void { + this.setProperty('uniformItemSizes', enable); + } + uniformItemSizes(): boolean { + return this.property('uniformItemSizes').toBool(); + } + setViewMode(mode: ViewMode): void { + this.setProperty('viewMode', mode); + } + viewMode(): ViewMode { + return this.property('viewMode').toInt(); + } + setWordWrap(on: boolean): void { + this.setProperty('wordWrap', on); + } + wordWrap(): boolean { + return this.property('wordWrap').toBool(); + } + clearPropertyFlags(): void { + this.native.clearPropertyFlags(); + } + setRowHidden(row: number, hide: boolean): void { + this.native.setRowHidden(row, hide); + } + isRowHidden(row: number): boolean { + return this.native.isRowHidden(row); + } +} + +export enum Flow { + LeftToRight, + TopToBottom, +} + +export enum LayoutMode { + SinglePass, + Batched, +} + +export enum Movement { + Static, + Free, + Snap, +} + +export enum ResizeMode { + Fixed, + Adjust, +} + +export enum ViewMode { + ListMode, + IconMode, +} + +export class QListView extends NodeListView { + native: NativeElement; + constructor(); + constructor(parent: NodeWidget); + constructor(parent?: NodeWidget) { + let native; + if (parent) { + native = new addon.QListView(parent.native); + } else { + native = new addon.QListView(); + } + super(native); + this.native = native; + parent && this.setNodeParent(parent); + } +} + +export type QListViewSignals = QAbstractItemViewSignals; diff --git a/src/lib/QtWidgets/QListWidget.ts b/src/lib/QtWidgets/QListWidget.ts index c0971058ca..19fa2cde01 100644 --- a/src/lib/QtWidgets/QListWidget.ts +++ b/src/lib/QtWidgets/QListWidget.ts @@ -2,10 +2,9 @@ import addon from '../utils/addon'; import { NodeWidget, QWidget } from './QWidget'; import { NativeElement, Component } from '../core/Component'; import { QListWidgetItem } from './QListWidgetItem'; -import { QAbstractItemView, QAbstractItemViewSignals } from './QAbstractItemView'; -import { QSize } from '../QtCore/QSize'; +import { NodeListView, QListViewSignals } from './QListView'; import { QRect } from '../QtCore/QRect'; -import { SortOrder, ScrollHint, AlignmentFlag } from '../QtEnums'; +import { SortOrder, ScrollHint, MatchFlag } from '../QtEnums'; /** @@ -32,7 +31,7 @@ for (let i = 0; i < 30; i++) { } ``` */ -export class QListWidget extends QAbstractItemView { +export class QListWidget extends NodeListView { native: NativeElement; items: Set; constructor(); @@ -46,9 +45,24 @@ export class QListWidget extends QAbstractItemView { } super(native); this.native = native; - this.setNodeParent(parent); + parent && this.setNodeParent(parent); this.items = new Set(); } + count(): number { + return this.property('count').toInt(); + } + setCurrentRow(row: number): void { + this.setProperty('currentRow', row); + } + currentRow(): number { + return this.property('currentRow').toInt(); + } + setSortingEnabled(enable: boolean): void { + this.setProperty('sortingEnabled', enable); + } + isSortingEnabled(): boolean { + return this.property('sortingEnabled').toBool(); + } addItem(item: QListWidgetItem): void { this.native.addItem(item.native); this.items.add(item); @@ -65,6 +79,12 @@ export class QListWidget extends QAbstractItemView { editItem(item: Component): void { this.native.editItem(item.native); } + findItems(text: string, flags: MatchFlag): QListWidgetItem[] { + const nativeItems = this.native.findItems(text, flags); + return nativeItems.map(function(item: QListWidgetItem) { + return new QListWidgetItem(item); + }); + } insertItem(row: number, item: QListWidgetItem): void { this.native.insertItem(row, item.native); this.items.add(item); @@ -93,13 +113,19 @@ export class QListWidget extends QAbstractItemView { row(item: QListWidgetItem): number { return this.native.row(item.native); } + selectedItems(): QListWidgetItem[] { + const nativeItems = this.native.selectedItems(); + return nativeItems.map(function(item: QListWidgetItem) { + return new QListWidgetItem(item); + }); + } setCurrentItem(item: QListWidgetItem): void { this.native.setCurrentItem(item.native); } - setItemWidget(item: QListWidgetItem, widget: QWidget): void { + setItemWidget(item: QListWidgetItem, widget: NodeWidget): void { this.native.setItemWidget(item.native, widget.native); } - sortItems(order: SortOrder): void { + sortItems(order = SortOrder.AscendingOrder): void { this.native.sortItems(order); } takeItem(row: number): void { @@ -111,148 +137,20 @@ export class QListWidget extends QAbstractItemView { clear(): void { this.native.clear(); } - scrollToItem(item: QListWidgetItem, hint: ScrollHint): void { + scrollToItem(item: QListWidgetItem, hint = ScrollHint.EnsureVisible): void { this.native.scrollToItem(item.native, hint); } - clearPropertyFlags(): void { - this.native.clearPropertyFlags(); - } - setRowHidden(row: number, hide: boolean): void { - this.native.setRowHidden(row, hide); - } - isRowHidden(row: number): boolean { - return this.native.isRowHidden(row); - } - count(): number { - return this.property('count').toInt(); - } - setCurrentRow(row: number): void { - this.setProperty('currentRow', row); - } - currentRow(): number { - return this.property('currentRow').toInt(); - } - setSortingEnabled(enable: boolean): void { - this.setProperty('sortingEnabled', enable); - } - isSortingEnabled(): boolean { - return this.property('sortingEnabled').toBool(); - } - setBatchSize(batchSize: number): void { - this.setProperty('batchSize', batchSize); - } - batchSize(): number { - return this.property('batchSize').toInt(); - } - setFlow(flow: Flow): void { - this.setProperty('flow', flow); - } - flow(): Flow { - return this.property('flow').toInt(); - } - setGridSize(size: QSize): void { - this.setProperty('gridSize', size.native); - } - gridSize(): QSize { - const gridSize = this.property('gridSize'); - return QSize.fromQVariant(gridSize); - } - setWrapping(enable: boolean): void { - this.setProperty('isWrapping', enable); - } - isWrapping(): boolean { - return this.property('isWrapping').toBool(); - } - setItemAlignment(alignment: AlignmentFlag): void { - this.setProperty('itemAlignment', alignment); - } - itemAlignment(): AlignmentFlag { - return this.property('itemAlignment').toInt(); - } - setLayoutMode(mode: LayoutMode): void { - this.setProperty('layoutMode', mode); - } - layoutMode(): LayoutMode { - return this.property('layoutMode').toInt(); - } - setModelColumn(column: number): void { - this.setProperty('modelColumn', column); - } - modelColumn(): number { - return this.property('modelColumn').toInt(); - } - setMovement(movement: Movement): void { - this.setProperty('movement', movement); - } - movement(): Movement { - return this.property('movement').toInt(); - } - setResizeMode(mode: ResizeMode): void { - this.setProperty('resizeMode', mode); - } - resizeMode(): ResizeMode { - return this.property('resizeMode').toInt(); - } - setSelectionRectVisible(show: boolean): void { - this.setProperty('selectionRectVisible', show); - } - isSelectionRectVisible(): boolean { - return this.property('selectionRectVisible').toBool(); - } - setSpacing(space: number): void { - this.setProperty('spacing', space); - } - spacing(): number { - return this.property('spacing').toInt(); - } - setUniformItemSizes(enable: boolean): void { - this.setProperty('uniformItemSizes', enable); - } - uniformItemSizes(): boolean { - return this.property('uniformItemSizes').toBool(); - } - setViewMode(mode: ViewMode): void { - this.setProperty('viewMode', mode); - } - viewMode(): ViewMode { - return this.property('viewMode').toInt(); - } - setWordWrap(on: boolean): void { - this.setProperty('wordWrap', on); - } - wordWrap(): boolean { - return this.property('wordWrap').toBool(); - } -} - -export enum Flow { - LeftToRight, - TopToBottom, -} - -export enum LayoutMode { - SinglePass, - Batched, -} - -export enum Movement { - Static, - Free, - Snap, -} - -export enum ResizeMode { - Fixed, - Adjust, -} - -export enum ViewMode { - ListMode, - IconMode, } -export interface QListWidgetSignals extends QAbstractItemViewSignals { +export interface QListWidgetSignals extends QListViewSignals { + currentItemChanged: (current: QListWidgetItem, previous: QListWidgetItem) => void; currentRowChanged: (currentRow: number) => void; currentTextChanged: (currentText: string) => void; + itemActivated: (item: QListWidgetItem) => void; + itemChanged: (item: QListWidgetItem) => void; + itemClicked: (item: QListWidgetItem) => void; + itemDoubleClicked: (item: QListWidgetItem) => void; + itemEntered: (item: QListWidgetItem) => void; + itemPressed: (item: QListWidgetItem) => void; itemSelectionChanged: () => void; } diff --git a/src/lib/QtWidgets/QListWidgetItem.ts b/src/lib/QtWidgets/QListWidgetItem.ts index 083c1cb6a6..b4be0fc2c4 100644 --- a/src/lib/QtWidgets/QListWidgetItem.ts +++ b/src/lib/QtWidgets/QListWidgetItem.ts @@ -1,9 +1,11 @@ import addon from '../utils/addon'; +import { checkIfNativeElement } from '../utils/helpers'; import { NativeElement, Component } from '../core/Component'; +import { QBrush } from '../QtGui/QBrush'; +import { QFont } from '../QtGui/QFont'; import { QIcon } from '../QtGui/QIcon'; import { QSize } from '../QtCore/QSize'; import { QVariant } from '../QtCore/QVariant'; -import { checkIfNativeElement } from '../utils/helpers'; import { CheckState } from '../QtEnums'; import { ItemFlag } from '../QtEnums/ItemFlag'; @@ -34,7 +36,11 @@ for (let i = 0; i < 30; i++) { */ export class QListWidgetItem extends Component { native: NativeElement; - constructor(arg?: arg) { + constructor(); + constructor(other: QListWidgetItem); + constructor(native: NativeElement); + constructor(text: string); + constructor(arg?: QListWidgetItem | NativeElement | string) { let native; if (typeof arg === 'string') { native = new addon.QListWidgetItem(arg); @@ -46,12 +52,21 @@ export class QListWidgetItem extends Component { super(); this.native = native; } + setBackground(brush: QBrush): void { + this.native.setBackground(brush.native); + } + background(): QBrush { + return new QBrush(this.native.background()); + } setCheckState(state: CheckState): void { this.native.setCheckState(state); } checkState(): CheckState { return this.native.checkState(); } + setData(role: number, value: QVariant): void { + this.native.setData(role, value.native); + } data(role: number): QVariant { return new QVariant(this.native.data(role)); } @@ -61,6 +76,18 @@ export class QListWidgetItem extends Component { flags(): ItemFlag { return this.native.flags(); } + setFont(font: QFont): void { + this.native.setFont(font.native); + } + font(): QFont { + return new QFont(this.native.font()); + } + setForeground(brush: QBrush): void { + this.native.setForeground(brush.native); + } + foreground(): QBrush { + return new QBrush(this.native.foreground()); + } setIcon(icon: QIcon): void { this.native.setIcon(icon.native); } @@ -98,7 +125,7 @@ export class QListWidgetItem extends Component { return this.native.text(); } setTextAlignment(alignment: number): void { - return this.native.setTextAlignment(alignment); + this.native.setTextAlignment(alignment); } textAlignment(): number { return this.native.textAlignment(); @@ -115,6 +142,7 @@ export class QListWidgetItem extends Component { whatsThis(): string { return this.native.whatsThis(); } + type(): number { + return this.native.type$(); + } } - -type arg = string | NativeElement; From 3af10d4f3b83ac83e16d717fc2992390d3f27bea Mon Sep 17 00:00:00 2001 From: wuxiaofeng Date: Sat, 28 Mar 2020 20:40:07 +0800 Subject: [PATCH 4/7] Add QErrorMessage --- CMakeLists.txt | 2 + .../QtWidgets/QErrorMessage/nerrormessage.hpp | 20 +++++++ .../QErrorMessage/qerrormessage_wrap.h | 25 ++++++++ .../QErrorMessage/qerrormessage_wrap.cpp | 60 +++++++++++++++++++ src/cpp/main.cpp | 2 + src/index.ts | 1 + src/lib/QtWidgets/QErrorMessage.ts | 43 +++++++++++++ 7 files changed, 153 insertions(+) create mode 100644 src/cpp/include/nodegui/QtWidgets/QErrorMessage/nerrormessage.hpp create mode 100644 src/cpp/include/nodegui/QtWidgets/QErrorMessage/qerrormessage_wrap.h create mode 100644 src/cpp/lib/QtWidgets/QErrorMessage/qerrormessage_wrap.cpp create mode 100644 src/lib/QtWidgets/QErrorMessage.ts diff --git a/CMakeLists.txt b/CMakeLists.txt index 1b9e33b9bd..5e7365cc4d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -73,6 +73,7 @@ add_library(${CORE_WIDGETS_ADDON} SHARED "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QDateEdit/qdateedit_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QDateTimeEdit/qdatetimeedit_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QDoubleSpinBox/qdoublespinbox_wrap.cpp" + "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QErrorMessage/qerrormessage_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QFileDialog/qfiledialog_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QFrame/qframe_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QListView/qlistview_wrap.cpp" @@ -132,6 +133,7 @@ add_library(${CORE_WIDGETS_ADDON} SHARED "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QDateTimeEdit/ndatetimeedit.hpp" "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QDial/ndial.hpp" "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QDoubleSpinBox/ndoublespinbox.hpp" + "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QErrorMessage/nerrormessage.hpp" "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QFileDialog/nfiledialog.hpp" "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QFrame/nframe.hpp" "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QListView/nlistview.hpp" diff --git a/src/cpp/include/nodegui/QtWidgets/QErrorMessage/nerrormessage.hpp b/src/cpp/include/nodegui/QtWidgets/QErrorMessage/nerrormessage.hpp new file mode 100644 index 0000000000..4672224880 --- /dev/null +++ b/src/cpp/include/nodegui/QtWidgets/QErrorMessage/nerrormessage.hpp @@ -0,0 +1,20 @@ +#pragma once + +#include + +#include "Extras/Export/export.h" +#include "QtWidgets/QDialog/qdialog_macro.h" +#include "core/NodeWidget/nodewidget.h" +#include "napi.h" + +class DLL_EXPORT NErrorMessage : public QErrorMessage, public NodeWidget { + Q_OBJECT + NODEWIDGET_IMPLEMENTATIONS(QErrorMessage) + public: + using QErrorMessage::QErrorMessage; + + void connectSignalsToEventEmitter() { + QDIALOG_SIGNALS + // Qt Connects: Implement all signal connects here + } +}; diff --git a/src/cpp/include/nodegui/QtWidgets/QErrorMessage/qerrormessage_wrap.h b/src/cpp/include/nodegui/QtWidgets/QErrorMessage/qerrormessage_wrap.h new file mode 100644 index 0000000000..7c9933d37e --- /dev/null +++ b/src/cpp/include/nodegui/QtWidgets/QErrorMessage/qerrormessage_wrap.h @@ -0,0 +1,25 @@ +#pragma once + +#include + +#include + +#include "Extras/Export/export.h" +#include "QtWidgets/QDialog/qdialog_macro.h" +#include "QtWidgets/QErrorMessage/nerrormessage.hpp" + +class DLL_EXPORT QErrorMessageWrap : public Napi::ObjectWrap { + QDIALOG_WRAPPED_METHODS_DECLARATION + private: + QPointer instance; + + public: + static Napi::Object init(Napi::Env env, Napi::Object exports); + QErrorMessageWrap(const Napi::CallbackInfo& info); + ~QErrorMessageWrap(); + NErrorMessage* getInternalInstance(); + // class constructor + static Napi::FunctionReference constructor; + // wrapped methods + Napi::Value showMessage(const Napi::CallbackInfo& info); +}; diff --git a/src/cpp/lib/QtWidgets/QErrorMessage/qerrormessage_wrap.cpp b/src/cpp/lib/QtWidgets/QErrorMessage/qerrormessage_wrap.cpp new file mode 100644 index 0000000000..fa23e35614 --- /dev/null +++ b/src/cpp/lib/QtWidgets/QErrorMessage/qerrormessage_wrap.cpp @@ -0,0 +1,60 @@ +#include "QtWidgets/QErrorMessage/qerrormessage_wrap.h" + +#include + +#include "Extras/Utils/nutils.h" +#include "QtWidgets/QWidget/qwidget_wrap.h" + +Napi::FunctionReference QErrorMessageWrap::constructor; + +Napi::Object QErrorMessageWrap::init(Napi::Env env, Napi::Object exports) { + Napi::HandleScope scope(env); + char CLASSNAME[] = "QErrorMessage"; + Napi::Function func = DefineClass( + env, CLASSNAME, + {InstanceMethod("showMessage", &QErrorMessageWrap::showMessage), + QDIALOG_WRAPPED_METHODS_EXPORT_DEFINE(QErrorMessageWrap)}); + constructor = Napi::Persistent(func); + exports.Set(CLASSNAME, func); + return exports; +} + +NErrorMessage* QErrorMessageWrap::getInternalInstance() { + return this->instance; +} + +QErrorMessageWrap::~QErrorMessageWrap() { + extrautils::safeDelete(this->instance); +} + +QErrorMessageWrap::QErrorMessageWrap(const Napi::CallbackInfo& info) + : Napi::ObjectWrap(info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + if (info.Length() == 1) { + Napi::Object parentObject = info[0].As(); + NodeWidgetWrap* parentWidgetWrap = + Napi::ObjectWrap::Unwrap(parentObject); + QWidget* parent = parentWidgetWrap->getInternalInstance(); + this->instance = new NErrorMessage(parent); + } else if (info.Length() == 0) { + this->instance = new NErrorMessage(); + } else { + Napi::TypeError::New(env, "Wrong number of arguments") + .ThrowAsJavaScriptException(); + } + this->rawData = extrautils::configureQWidget( + this->getInternalInstance(), this->getInternalInstance()->getFlexNode(), + false); +} + +Napi::Value QErrorMessageWrap::showMessage(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + std::string napiMessage = info[0].As().Utf8Value(); + QString message = QString::fromUtf8(napiMessage.c_str()); + this->instance->showMessage(message); + return env.Null(); +} diff --git a/src/cpp/main.cpp b/src/cpp/main.cpp index dd2752d378..e0deefca3b 100644 --- a/src/cpp/main.cpp +++ b/src/cpp/main.cpp @@ -39,6 +39,7 @@ #include "QtWidgets/QDial/qdial_wrap.h" #include "QtWidgets/QDialog/qdialog_wrap.h" #include "QtWidgets/QDoubleSpinBox/qdoublespinbox_wrap.h" +#include "QtWidgets/QErrorMessage/qerrormessage_wrap.h" #include "QtWidgets/QFileDialog/qfiledialog_wrap.h" #include "QtWidgets/QFrame/qframe_wrap.h" #include "QtWidgets/QGridLayout/qgridlayout_wrap.h" @@ -122,6 +123,7 @@ Napi::Object Main(Napi::Env env, Napi::Object exports) { QBoxLayoutWrap::init(env, exports); QDateEditWrap::init(env, exports); QDateTimeEditWrap::init(env, exports); + QErrorMessageWrap::init(env, exports); QFileDialogWrap::init(env, exports); QFrameWrap::init(env, exports); QListViewWrap::init(env, exports); diff --git a/src/index.ts b/src/index.ts index 92eb0c41f9..ed1169dbc4 100644 --- a/src/index.ts +++ b/src/index.ts @@ -43,6 +43,7 @@ export { QDateTimeEdit, NodeDateTimeEdit, QDateTimeEditSignals } from './lib/QtW export { QLabel, QLabelSignals } from './lib/QtWidgets/QLabel'; export { QDial, QDialSignals } from './lib/QtWidgets/QDial'; export { QDoubleSpinBox, QDoubleSpinBoxSignals } from './lib/QtWidgets/QDoubleSpinBox'; +export { QErrorMessage, QErrorMessageSignals } from './lib/QtWidgets/QErrorMessage'; export { QFileDialog, QFileDialogSignals } from './lib/QtWidgets/QFileDialog'; export { QFrame, QFrameSignals, Shadow, Shape } from './lib/QtWidgets/QFrame'; export { QLineEdit, QLineEditSignals, EchoMode } from './lib/QtWidgets/QLineEdit'; diff --git a/src/lib/QtWidgets/QErrorMessage.ts b/src/lib/QtWidgets/QErrorMessage.ts new file mode 100644 index 0000000000..adef879872 --- /dev/null +++ b/src/lib/QtWidgets/QErrorMessage.ts @@ -0,0 +1,43 @@ +import addon from '../utils/addon'; +import { NodeWidget } from './QWidget'; +import { NativeElement } from '../core/Component'; +import { NodeDialog, QDialogSignals } from './QDialog'; + +/** + +> Create and control error message dialogs. + +* **This class is a JS wrapper around Qt's [QErrorMessage class](https://doc.qt.io/qt-5/qerrormessage.html)** + +The `QErrorMessage` class provides an error message display dialog. + +### Example + +```javascript +const { QErrorMessage } = require("@nodegui/nodegui"); + +const errorMessage = new QErrorMessage(); + +``` + */ +export class QErrorMessage extends NodeDialog { + native: NativeElement; + constructor(); + constructor(parent: NodeWidget); + constructor(parent?: NodeWidget) { + let native; + if (parent) { + native = new addon.QErrorMessage(parent.native); + } else { + native = new addon.QErrorMessage(); + } + super(native); + this.native = native; + parent && this.setNodeParent(parent); + } + showMessage(message: string): void { + this.native.showMessage(message); + } +} + +export type QErrorMessageSignals = QDialogSignals; From 7e0b53a81de648e490c6f65326a1db4eebed4c9b Mon Sep 17 00:00:00 2001 From: wuxiaofeng Date: Sat, 28 Mar 2020 21:23:51 +0800 Subject: [PATCH 5/7] Add QFontDialog --- CMakeLists.txt | 2 + .../QErrorMessage/qerrormessage_wrap.h | 3 +- .../QtWidgets/QFontDialog/nfontdialog.hpp | 37 +++++++++ .../QtWidgets/QFontDialog/qfontdialog_wrap.h | 27 +++++++ .../QFontDialog/qfontdialog_wrap.cpp | 79 +++++++++++++++++++ src/cpp/main.cpp | 2 + src/index.ts | 1 + src/lib/QtWidgets/QFontDialog.ts | 77 ++++++++++++++++++ 8 files changed, 227 insertions(+), 1 deletion(-) create mode 100644 src/cpp/include/nodegui/QtWidgets/QFontDialog/nfontdialog.hpp create mode 100644 src/cpp/include/nodegui/QtWidgets/QFontDialog/qfontdialog_wrap.h create mode 100644 src/cpp/lib/QtWidgets/QFontDialog/qfontdialog_wrap.cpp create mode 100644 src/lib/QtWidgets/QFontDialog.ts diff --git a/CMakeLists.txt b/CMakeLists.txt index 5e7365cc4d..78718f0dfa 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -75,6 +75,7 @@ add_library(${CORE_WIDGETS_ADDON} SHARED "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QDoubleSpinBox/qdoublespinbox_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QErrorMessage/qerrormessage_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QFileDialog/qfiledialog_wrap.cpp" + "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QFontDialog/qfontdialog_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QFrame/qframe_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QListView/qlistview_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QListWidget/qlistwidget_wrap.cpp" @@ -135,6 +136,7 @@ add_library(${CORE_WIDGETS_ADDON} SHARED "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QDoubleSpinBox/ndoublespinbox.hpp" "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QErrorMessage/nerrormessage.hpp" "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QFileDialog/nfiledialog.hpp" + "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QFontDialog/nfontdialog.hpp" "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QFrame/nframe.hpp" "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QListView/nlistview.hpp" "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QListWidget/nlistwidget.hpp" diff --git a/src/cpp/include/nodegui/QtWidgets/QErrorMessage/qerrormessage_wrap.h b/src/cpp/include/nodegui/QtWidgets/QErrorMessage/qerrormessage_wrap.h index 7c9933d37e..c9fa3981ca 100644 --- a/src/cpp/include/nodegui/QtWidgets/QErrorMessage/qerrormessage_wrap.h +++ b/src/cpp/include/nodegui/QtWidgets/QErrorMessage/qerrormessage_wrap.h @@ -8,7 +8,8 @@ #include "QtWidgets/QDialog/qdialog_macro.h" #include "QtWidgets/QErrorMessage/nerrormessage.hpp" -class DLL_EXPORT QErrorMessageWrap : public Napi::ObjectWrap { +class DLL_EXPORT QErrorMessageWrap + : public Napi::ObjectWrap { QDIALOG_WRAPPED_METHODS_DECLARATION private: QPointer instance; diff --git a/src/cpp/include/nodegui/QtWidgets/QFontDialog/nfontdialog.hpp b/src/cpp/include/nodegui/QtWidgets/QFontDialog/nfontdialog.hpp new file mode 100644 index 0000000000..02271a8748 --- /dev/null +++ b/src/cpp/include/nodegui/QtWidgets/QFontDialog/nfontdialog.hpp @@ -0,0 +1,37 @@ +#pragma once + +#include + +#include "Extras/Export/export.h" +#include "QtGui/QFont/qfont_wrap.h" +#include "QtWidgets/QDialog/qdialog_macro.h" +#include "core/NodeWidget/nodewidget.h" +#include "napi.h" + +class DLL_EXPORT NFontDialog : public QFontDialog, public NodeWidget { + Q_OBJECT + NODEWIDGET_IMPLEMENTATIONS(QFontDialog) + public: + using QFontDialog::QFontDialog; + + void connectSignalsToEventEmitter() { + QDIALOG_SIGNALS + // Qt Connects: Implement all signal connects here + QObject::connect( + this, &QFontDialog::currentFontChanged, [=](const QFont& font) { + Napi::Env env = this->emitOnNode.Env(); + Napi::HandleScope scope(env); + auto instance = QFontWrap::constructor.New( + {Napi::External::New(env, new QFont(font))}); + this->emitOnNode.Call( + {Napi::String::New(env, "currentFontChanged"), instance}); + }); + QObject::connect(this, &QFontDialog::fontSelected, [=](const QFont& font) { + Napi::Env env = this->emitOnNode.Env(); + Napi::HandleScope scope(env); + auto instance = QFontWrap::constructor.New( + {Napi::External::New(env, new QFont(font))}); + this->emitOnNode.Call({Napi::String::New(env, "fontSelected"), instance}); + }); + } +}; diff --git a/src/cpp/include/nodegui/QtWidgets/QFontDialog/qfontdialog_wrap.h b/src/cpp/include/nodegui/QtWidgets/QFontDialog/qfontdialog_wrap.h new file mode 100644 index 0000000000..d6282f27f3 --- /dev/null +++ b/src/cpp/include/nodegui/QtWidgets/QFontDialog/qfontdialog_wrap.h @@ -0,0 +1,27 @@ +#pragma once + +#include + +#include + +#include "Extras/Export/export.h" +#include "QtWidgets/QDialog/qdialog_macro.h" +#include "QtWidgets/QFontDialog/nfontdialog.hpp" + +class DLL_EXPORT QFontDialogWrap : public Napi::ObjectWrap { + QDIALOG_WRAPPED_METHODS_DECLARATION + private: + QPointer instance; + + public: + static Napi::Object init(Napi::Env env, Napi::Object exports); + QFontDialogWrap(const Napi::CallbackInfo& info); + ~QFontDialogWrap(); + NFontDialog* getInternalInstance(); + // class constructor + static Napi::FunctionReference constructor; + // wrapped methods + Napi::Value selectedFont(const Napi::CallbackInfo& info); + Napi::Value setOption(const Napi::CallbackInfo& info); + Napi::Value testOption(const Napi::CallbackInfo& info); +}; diff --git a/src/cpp/lib/QtWidgets/QFontDialog/qfontdialog_wrap.cpp b/src/cpp/lib/QtWidgets/QFontDialog/qfontdialog_wrap.cpp new file mode 100644 index 0000000000..bcc35c5950 --- /dev/null +++ b/src/cpp/lib/QtWidgets/QFontDialog/qfontdialog_wrap.cpp @@ -0,0 +1,79 @@ +#include "QtWidgets/QFontDialog/qfontdialog_wrap.h" + +#include + +#include "Extras/Utils/nutils.h" +#include "QtWidgets/QWidget/qwidget_wrap.h" + +Napi::FunctionReference QFontDialogWrap::constructor; + +Napi::Object QFontDialogWrap::init(Napi::Env env, Napi::Object exports) { + Napi::HandleScope scope(env); + char CLASSNAME[] = "QFontDialog"; + Napi::Function func = DefineClass( + env, CLASSNAME, + {InstanceMethod("selectedFont", &QFontDialogWrap::selectedFont), + InstanceMethod("setOption", &QFontDialogWrap::setOption), + InstanceMethod("testOption", &QFontDialogWrap::testOption), + QDIALOG_WRAPPED_METHODS_EXPORT_DEFINE(QFontDialogWrap)}); + constructor = Napi::Persistent(func); + exports.Set(CLASSNAME, func); + return exports; +} + +NFontDialog* QFontDialogWrap::getInternalInstance() { return this->instance; } + +QFontDialogWrap::~QFontDialogWrap() { extrautils::safeDelete(this->instance); } + +QFontDialogWrap::QFontDialogWrap(const Napi::CallbackInfo& info) + : Napi::ObjectWrap(info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + if (info.Length() == 1) { + Napi::Object parentObject = info[0].As(); + NodeWidgetWrap* parentWidgetWrap = + Napi::ObjectWrap::Unwrap(parentObject); + QWidget* parent = parentWidgetWrap->getInternalInstance(); + this->instance = new NFontDialog(parent); + } else if (info.Length() == 0) { + this->instance = new NFontDialog(); + } else { + Napi::TypeError::New(env, "Wrong number of arguments") + .ThrowAsJavaScriptException(); + } + this->rawData = extrautils::configureQWidget( + this->getInternalInstance(), this->getInternalInstance()->getFlexNode(), + false); +} + +Napi::Value QFontDialogWrap::selectedFont(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + QFont font = this->instance->selectedFont(); + auto instance = QFontWrap::constructor.New( + {Napi::External::New(env, new QFont(font))}); + return instance; +} + +Napi::Value QFontDialogWrap::setOption(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + int option = info[0].As().Int32Value(); + bool on = info[1].As().Value(); + this->instance->setOption(static_cast(option), + on); + return env.Null(); +} + +Napi::Value QFontDialogWrap::testOption(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + int option = info[0].As().Int32Value(); + bool on = this->instance->testOption( + static_cast(option)); + return Napi::Boolean::New(env, on); +} diff --git a/src/cpp/main.cpp b/src/cpp/main.cpp index e0deefca3b..7d4ecb2811 100644 --- a/src/cpp/main.cpp +++ b/src/cpp/main.cpp @@ -41,6 +41,7 @@ #include "QtWidgets/QDoubleSpinBox/qdoublespinbox_wrap.h" #include "QtWidgets/QErrorMessage/qerrormessage_wrap.h" #include "QtWidgets/QFileDialog/qfiledialog_wrap.h" +#include "QtWidgets/QFontDialog/qfontdialog_wrap.h" #include "QtWidgets/QFrame/qframe_wrap.h" #include "QtWidgets/QGridLayout/qgridlayout_wrap.h" #include "QtWidgets/QGroupBox/qgroupbox_wrap.h" @@ -125,6 +126,7 @@ Napi::Object Main(Napi::Env env, Napi::Object exports) { QDateTimeEditWrap::init(env, exports); QErrorMessageWrap::init(env, exports); QFileDialogWrap::init(env, exports); + QFontDialogWrap::init(env, exports); QFrameWrap::init(env, exports); QListViewWrap::init(env, exports); QListWidgetWrap::init(env, exports); diff --git a/src/index.ts b/src/index.ts index ed1169dbc4..7f2872ad0f 100644 --- a/src/index.ts +++ b/src/index.ts @@ -45,6 +45,7 @@ export { QDial, QDialSignals } from './lib/QtWidgets/QDial'; export { QDoubleSpinBox, QDoubleSpinBoxSignals } from './lib/QtWidgets/QDoubleSpinBox'; export { QErrorMessage, QErrorMessageSignals } from './lib/QtWidgets/QErrorMessage'; export { QFileDialog, QFileDialogSignals } from './lib/QtWidgets/QFileDialog'; +export { QFontDialog, QFontDialogSignals, FontDialogOption } from './lib/QtWidgets/QFontDialog'; export { QFrame, QFrameSignals, Shadow, Shape } from './lib/QtWidgets/QFrame'; export { QLineEdit, QLineEditSignals, EchoMode } from './lib/QtWidgets/QLineEdit'; export { QMainWindow, QMainWindowSignals } from './lib/QtWidgets/QMainWindow'; diff --git a/src/lib/QtWidgets/QFontDialog.ts b/src/lib/QtWidgets/QFontDialog.ts new file mode 100644 index 0000000000..cb553a276f --- /dev/null +++ b/src/lib/QtWidgets/QFontDialog.ts @@ -0,0 +1,77 @@ +import addon from '../utils/addon'; +import { NodeWidget } from './QWidget'; +import { NativeElement } from '../core/Component'; +import { NodeDialog, QDialogSignals } from './QDialog'; +import { QFont } from '../QtGui/QFont'; + +/** + +> Create and control font dialogs. + +* **This class is a JS wrapper around Qt's [QFontDialog class](https://doc.qt.io/qt-5/qfontdialog.html)** + +The `QFontDialog` class provides a dialog widget for selecting a font. + +### Example + +```javascript +const { QFontDialog } = require("@nodegui/nodegui"); + +const fontDialog = new QFontDialog(); +fontDialog.exec(); +const font = fontDialog.currentFont(); +console.log(font); + +``` + */ +export class QFontDialog extends NodeDialog { + native: NativeElement; + constructor(); + constructor(parent: NodeWidget); + constructor(parent?: NodeWidget) { + let native; + if (parent) { + native = new addon.QFontDialog(parent.native); + } else { + native = new addon.QFontDialog(); + } + super(native); + this.native = native; + parent && this.setNodeParent(parent); + } + setCurrentFont(font: QFont): void { + this.setProperty('currentFont', font.native); + } + currentFont(): QFont { + return QFont.fromQVariant(this.property('currentFont')); + } + setOptions(options: FontDialogOption): void { + this.setProperty('options', options); + } + options(): FontDialogOption { + return this.property('options').toInt(); + } + selectedFont(): QFont { + return new QFont(this.native.selectedFont()); + } + setOption(option: FontDialogOption, on = true): void { + this.native.setOption(option, on); + } + testOption(option: FontDialogOption): boolean { + return this.native.testOption(option); + } +} + +export enum FontDialogOption { + NoButtons = 0x00000001, + DontUseNativeDialog = 0x00000002, + ScalableFonts = 0x00000004, + NonScalableFonts = 0x00000008, + MonospacedFonts = 0x00000010, + ProportionalFonts = 0x00000020, +} + +export interface QFontDialogSignals extends QDialogSignals { + fontSelected: (font: QFont) => void; + currentFontChanged: (font: QFont) => void; +} From 4c4b71e3782762311fa0c38c69fa9dfda7ee8521 Mon Sep 17 00:00:00 2001 From: wuxiaofeng Date: Sat, 28 Mar 2020 22:22:54 +0800 Subject: [PATCH 6/7] Add QProgressDialog --- CMakeLists.txt | 2 + .../QProgressDialog/nprogressdialog.hpp | 25 +++++ .../QProgressDialog/qprogressdialog_wrap.h | 29 ++++++ .../QProgressDialog/qprogressdialog_wrap.cpp | 91 +++++++++++++++++ src/cpp/main.cpp | 2 + src/index.ts | 1 + src/lib/QtWidgets/QProgressDialog.ts | 99 +++++++++++++++++++ 7 files changed, 249 insertions(+) create mode 100644 src/cpp/include/nodegui/QtWidgets/QProgressDialog/nprogressdialog.hpp create mode 100644 src/cpp/include/nodegui/QtWidgets/QProgressDialog/qprogressdialog_wrap.h create mode 100644 src/cpp/lib/QtWidgets/QProgressDialog/qprogressdialog_wrap.cpp create mode 100644 src/lib/QtWidgets/QProgressDialog.ts diff --git a/CMakeLists.txt b/CMakeLists.txt index 78718f0dfa..5422d22ad4 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -94,6 +94,7 @@ add_library(${CORE_WIDGETS_ADDON} SHARED "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QSpinBox/qspinbox_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QCheckBox/qcheckbox_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QProgressBar/qprogressbar_wrap.cpp" + "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QProgressDialog/qprogressdialog_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QRadioButton/qradiobutton_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QStackedWidget/qstackedwidget_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QTabBar/qtabbar_wrap.cpp" @@ -145,6 +146,7 @@ add_library(${CORE_WIDGETS_ADDON} SHARED "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QLineEdit/nlineedit.hpp" "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QMainWindow/nmainwindow.hpp" "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QProgressBar/nprogressbar.hpp" + "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QProgressDialog/nprogressdialog.hpp" "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QPushButton/npushbutton.hpp" "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QMessageBox/nmessagebox.hpp" "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QInputDialog/ninputdialog.hpp" diff --git a/src/cpp/include/nodegui/QtWidgets/QProgressDialog/nprogressdialog.hpp b/src/cpp/include/nodegui/QtWidgets/QProgressDialog/nprogressdialog.hpp new file mode 100644 index 0000000000..ae458d2099 --- /dev/null +++ b/src/cpp/include/nodegui/QtWidgets/QProgressDialog/nprogressdialog.hpp @@ -0,0 +1,25 @@ +#pragma once + +#include + +#include "Extras/Export/export.h" +#include "QtWidgets/QDialog/qdialog_macro.h" +#include "core/NodeWidget/nodewidget.h" +#include "napi.h" + +class DLL_EXPORT NProgressDialog : public QProgressDialog, public NodeWidget { + Q_OBJECT + NODEWIDGET_IMPLEMENTATIONS(QProgressDialog) + public: + using QProgressDialog::QProgressDialog; + + void connectSignalsToEventEmitter() { + QDIALOG_SIGNALS + // Qt Connects: Implement all signal connects here + QObject::connect(this, &QProgressDialog::canceled, [=]() { + Napi::Env env = this->emitOnNode.Env(); + Napi::HandleScope scope(env); + this->emitOnNode.Call({Napi::String::New(env, "canceled")}); + }); + } +}; diff --git a/src/cpp/include/nodegui/QtWidgets/QProgressDialog/qprogressdialog_wrap.h b/src/cpp/include/nodegui/QtWidgets/QProgressDialog/qprogressdialog_wrap.h new file mode 100644 index 0000000000..ca2e88153e --- /dev/null +++ b/src/cpp/include/nodegui/QtWidgets/QProgressDialog/qprogressdialog_wrap.h @@ -0,0 +1,29 @@ +#pragma once + +#include + +#include + +#include "Extras/Export/export.h" +#include "QtWidgets/QDialog/qdialog_macro.h" +#include "QtWidgets/QProgressDialog/nprogressdialog.hpp" + +class DLL_EXPORT QProgressDialogWrap + : public Napi::ObjectWrap { + QDIALOG_WRAPPED_METHODS_DECLARATION + private: + QPointer instance; + + public: + static Napi::Object init(Napi::Env env, Napi::Object exports); + QProgressDialogWrap(const Napi::CallbackInfo& info); + ~QProgressDialogWrap(); + NProgressDialog* getInternalInstance(); + // class constructor + static Napi::FunctionReference constructor; + // wrapped methods + Napi::Value cancel(const Napi::CallbackInfo& info); + Napi::Value reset(const Napi::CallbackInfo& info); + Napi::Value setCancelButtonText(const Napi::CallbackInfo& info); + Napi::Value setRange(const Napi::CallbackInfo& info); +}; diff --git a/src/cpp/lib/QtWidgets/QProgressDialog/qprogressdialog_wrap.cpp b/src/cpp/lib/QtWidgets/QProgressDialog/qprogressdialog_wrap.cpp new file mode 100644 index 0000000000..0e4ca79ec1 --- /dev/null +++ b/src/cpp/lib/QtWidgets/QProgressDialog/qprogressdialog_wrap.cpp @@ -0,0 +1,91 @@ +#include "QtWidgets/QProgressDialog/qprogressdialog_wrap.h" + +#include + +#include "Extras/Utils/nutils.h" +#include "QtWidgets/QWidget/qwidget_wrap.h" + +Napi::FunctionReference QProgressDialogWrap::constructor; + +Napi::Object QProgressDialogWrap::init(Napi::Env env, Napi::Object exports) { + Napi::HandleScope scope(env); + char CLASSNAME[] = "QProgressDialog"; + Napi::Function func = + DefineClass(env, CLASSNAME, + {InstanceMethod("cancel", &QProgressDialogWrap::cancel), + InstanceMethod("reset", &QProgressDialogWrap::reset), + InstanceMethod("setCancelButtonText", + &QProgressDialogWrap::setCancelButtonText), + InstanceMethod("setRange", &QProgressDialogWrap::setRange), + QDIALOG_WRAPPED_METHODS_EXPORT_DEFINE(QProgressDialogWrap)}); + constructor = Napi::Persistent(func); + exports.Set(CLASSNAME, func); + return exports; +} + +NProgressDialog* QProgressDialogWrap::getInternalInstance() { + return this->instance; +} + +QProgressDialogWrap::~QProgressDialogWrap() { + extrautils::safeDelete(this->instance); +} + +QProgressDialogWrap::QProgressDialogWrap(const Napi::CallbackInfo& info) + : Napi::ObjectWrap(info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + if (info.Length() == 1) { + Napi::Object parentObject = info[0].As(); + NodeWidgetWrap* parentWidgetWrap = + Napi::ObjectWrap::Unwrap(parentObject); + QWidget* parent = parentWidgetWrap->getInternalInstance(); + this->instance = new NProgressDialog(parent); + } else if (info.Length() == 0) { + this->instance = new NProgressDialog(); + } else { + Napi::TypeError::New(env, "Wrong number of arguments") + .ThrowAsJavaScriptException(); + } + this->rawData = extrautils::configureQWidget( + this->getInternalInstance(), this->getInternalInstance()->getFlexNode(), + false); +} + +Napi::Value QProgressDialogWrap::cancel(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + this->instance->cancel(); + return env.Null(); +} + +Napi::Value QProgressDialogWrap::reset(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + this->instance->reset(); + return env.Null(); +} + +Napi::Value QProgressDialogWrap::setCancelButtonText( + const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + std::string napiText = info[0].As().Utf8Value(); + QString text = QString::fromUtf8(napiText.c_str()); + this->instance->setCancelButtonText(text); + return env.Null(); +} + +Napi::Value QProgressDialogWrap::setRange(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + int minimum = info[0].As().Int32Value(); + int maximum = info[1].As().Int32Value(); + this->instance->setRange(minimum, maximum); + return env.Null(); +} diff --git a/src/cpp/main.cpp b/src/cpp/main.cpp index 7d4ecb2811..fd6c25e3c7 100644 --- a/src/cpp/main.cpp +++ b/src/cpp/main.cpp @@ -59,6 +59,7 @@ #include "QtWidgets/QPainter/qpainter_wrap.h" #include "QtWidgets/QPlainTextEdit/qplaintextedit_wrap.h" #include "QtWidgets/QProgressBar/qprogressbar_wrap.h" +#include "QtWidgets/QProgressDialog/qprogressdialog_wrap.h" #include "QtWidgets/QPushButton/qpushbutton_wrap.h" #include "QtWidgets/QRadioButton/qradiobutton_wrap.h" #include "QtWidgets/QScrollArea/qscrollarea_wrap.h" @@ -146,6 +147,7 @@ Napi::Object Main(Napi::Env env, Napi::Object exports) { QSpinBoxWrap::init(env, exports); QCheckBoxWrap::init(env, exports); QProgressBarWrap::init(env, exports); + QProgressDialogWrap::init(env, exports); QRadioButtonWrap::init(env, exports); QStackedWidgetWrap::init(env, exports); QTabBarWrap::init(env, exports); diff --git a/src/index.ts b/src/index.ts index 7f2872ad0f..b7a05fb2cc 100644 --- a/src/index.ts +++ b/src/index.ts @@ -50,6 +50,7 @@ export { QFrame, QFrameSignals, Shadow, Shape } from './lib/QtWidgets/QFrame'; export { QLineEdit, QLineEditSignals, EchoMode } from './lib/QtWidgets/QLineEdit'; export { QMainWindow, QMainWindowSignals } from './lib/QtWidgets/QMainWindow'; export { QProgressBar, QProgressBarSignals, QProgressBarDirection } from './lib/QtWidgets/QProgressBar'; +export { QProgressDialog, QProgressDialogSignals } from './lib/QtWidgets/QProgressDialog'; export { QComboBox, QComboBoxSignals, InsertPolicy } from './lib/QtWidgets/QComboBox'; export { QPushButton, QPushButtonSignals } from './lib/QtWidgets/QPushButton'; export { QToolButton, QToolButtonSignals, ToolButtonPopupMode } from './lib/QtWidgets/QToolButton'; diff --git a/src/lib/QtWidgets/QProgressDialog.ts b/src/lib/QtWidgets/QProgressDialog.ts new file mode 100644 index 0000000000..fbd86fc6cc --- /dev/null +++ b/src/lib/QtWidgets/QProgressDialog.ts @@ -0,0 +1,99 @@ +import addon from '../utils/addon'; +import { NodeWidget } from './QWidget'; +import { NativeElement } from '../core/Component'; +import { NodeDialog, QDialogSignals } from './QDialog'; + +/** + +> Create and control progress dialogs. + +* **This class is a JS wrapper around Qt's [QProgressDialog class](https://doc.qt.io/qt-5/qprogressdialog.html)** + +The `QProgressDialog` class provides feedback on the progress of a slow operation. + +### Example + +```javascript +const { QProgressDialog } = require("@nodegui/nodegui"); + +const progressDialog = new QProgressDialog(); + +``` + */ +export class QProgressDialog extends NodeDialog { + native: NativeElement; + constructor(); + constructor(parent: NodeWidget); + constructor(parent?: NodeWidget) { + let native; + if (parent) { + native = new addon.QProgressDialog(parent.native); + } else { + native = new addon.QProgressDialog(); + } + super(native); + this.native = native; + parent && this.setNodeParent(parent); + } + setAutoClose(close: boolean): void { + this.setProperty('autoClose', close); + } + autoClose(): boolean { + return this.property('autoClose').toBool(); + } + setAutoReset(reset: boolean): void { + this.setProperty('autoReset', reset); + } + autoReset(): boolean { + return this.property('autoReset').toBool(); + } + setLabelText(text: string): void { + this.setProperty('labelText', text); + } + labelText(): string { + return this.property('labelText').toString(); + } + setMaximum(maximum: number): void { + this.setProperty('maximum', maximum); + } + maximum(): number { + return this.property('maximum').toInt(); + } + setMinimum(minimum: number): void { + this.setProperty('minimum', minimum); + } + minimum(): number { + return this.property('minimum').toInt(); + } + setMinimumDuration(ms: number): void { + this.setProperty('minimumDuration', ms); + } + minimumDuration(): number { + return this.property('minimumDuration').toInt(); + } + setValue(progress: number): void { + this.setProperty('value', progress); + } + value(): number { + return this.property('value').toInt(); + } + wasCanceled(): boolean { + return this.property('wasCanceled').toBool(); + } + cancel(): void { + this.native.cancel(); + } + reset(): void { + this.native.reset(); + } + setCancelButtonText(text: string): void { + this.native.setCancelButtonText(text); + } + setRange(minimum: number, maximum: number): void { + this.native.setRange(minimum, maximum); + } +} + +export interface QProgressDialogSignals extends QDialogSignals { + canceled: () => void; +} From f6841133c3d1fa0edbfcb1e11a66de0e111d06ad Mon Sep 17 00:00:00 2001 From: wuxiaofeng Date: Sat, 28 Mar 2020 23:28:24 +0800 Subject: [PATCH 7/7] Add QLCDNumber --- CMakeLists.txt | 2 + .../QtWidgets/QLCDNumber/nlcdnumber.hpp | 23 ++++ .../QtWidgets/QLCDNumber/qlcdnumber_wrap.h | 30 +++++ .../QtWidgets/QLCDNumber/qlcdnumber_wrap.cpp | 117 ++++++++++++++++++ src/cpp/main.cpp | 2 + src/index.ts | 1 + src/lib/QtWidgets/QLCDNumber.ts | 103 +++++++++++++++ 7 files changed, 278 insertions(+) create mode 100644 src/cpp/include/nodegui/QtWidgets/QLCDNumber/nlcdnumber.hpp create mode 100644 src/cpp/include/nodegui/QtWidgets/QLCDNumber/qlcdnumber_wrap.h create mode 100644 src/cpp/lib/QtWidgets/QLCDNumber/qlcdnumber_wrap.cpp create mode 100644 src/lib/QtWidgets/QLCDNumber.ts diff --git a/CMakeLists.txt b/CMakeLists.txt index 5422d22ad4..c571575263 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -88,6 +88,7 @@ add_library(${CORE_WIDGETS_ADDON} SHARED "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QDial/qdial_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QLabel/qlabel_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QLayout/qlayout_wrap.cpp" + "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QLCDNumber/qlcdnumber_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QMainWindow/qmainwindow_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QPushButton/qpushbutton_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtWidgets/QToolButton/qtoolbutton_wrap.cpp" @@ -139,6 +140,7 @@ add_library(${CORE_WIDGETS_ADDON} SHARED "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QFileDialog/nfiledialog.hpp" "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QFontDialog/nfontdialog.hpp" "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QFrame/nframe.hpp" + "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QLCDNumber/nlcdnumber.hpp" "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QListView/nlistview.hpp" "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QListWidget/nlistwidget.hpp" "${PROJECT_SOURCE_DIR}/src/cpp/include/nodegui/QtWidgets/QTableView/ntableview.hpp" diff --git a/src/cpp/include/nodegui/QtWidgets/QLCDNumber/nlcdnumber.hpp b/src/cpp/include/nodegui/QtWidgets/QLCDNumber/nlcdnumber.hpp new file mode 100644 index 0000000000..9858488001 --- /dev/null +++ b/src/cpp/include/nodegui/QtWidgets/QLCDNumber/nlcdnumber.hpp @@ -0,0 +1,23 @@ +#pragma once + +#include + +#include "Extras/Export/export.h" +#include "QtWidgets/QWidget/qwidget_macro.h" +#include "core/NodeWidget/nodewidget.h" + +class DLL_EXPORT NLCDNumber : public QLCDNumber, public NodeWidget { + Q_OBJECT + NODEWIDGET_IMPLEMENTATIONS(QLCDNumber) + public: + using QLCDNumber::QLCDNumber; // inherit all constructors of QLCDNumber + + void connectSignalsToEventEmitter() { + QWIDGET_SIGNALS + QObject::connect(this, &QLCDNumber::overflow, [=]() { + Napi::Env env = this->emitOnNode.Env(); + Napi::HandleScope scope(env); + this->emitOnNode.Call({Napi::String::New(env, "overflow")}); + }); + } +}; diff --git a/src/cpp/include/nodegui/QtWidgets/QLCDNumber/qlcdnumber_wrap.h b/src/cpp/include/nodegui/QtWidgets/QLCDNumber/qlcdnumber_wrap.h new file mode 100644 index 0000000000..218e2a1bb7 --- /dev/null +++ b/src/cpp/include/nodegui/QtWidgets/QLCDNumber/qlcdnumber_wrap.h @@ -0,0 +1,30 @@ +#pragma once + +#include + +#include + +#include "Extras/Export/export.h" +#include "QtWidgets/QWidget/qwidget_macro.h" +#include "nlcdnumber.hpp" + +class DLL_EXPORT QLCDNumberWrap : public Napi::ObjectWrap { + QWIDGET_WRAPPED_METHODS_DECLARATION + private: + QPointer instance; + + public: + static Napi::Object init(Napi::Env env, Napi::Object exports); + QLCDNumberWrap(const Napi::CallbackInfo& info); + ~QLCDNumberWrap(); + NLCDNumber* getInternalInstance(); + // class constructor + static Napi::FunctionReference constructor; + // wrapped methods + Napi::Value checkOverflow(const Napi::CallbackInfo& info); + Napi::Value display(const Napi::CallbackInfo& info); + Napi::Value setBinMode(const Napi::CallbackInfo& info); + Napi::Value setDecMode(const Napi::CallbackInfo& info); + Napi::Value setHexMode(const Napi::CallbackInfo& info); + Napi::Value setOctMode(const Napi::CallbackInfo& info); +}; diff --git a/src/cpp/lib/QtWidgets/QLCDNumber/qlcdnumber_wrap.cpp b/src/cpp/lib/QtWidgets/QLCDNumber/qlcdnumber_wrap.cpp new file mode 100644 index 0000000000..e7a693ae38 --- /dev/null +++ b/src/cpp/lib/QtWidgets/QLCDNumber/qlcdnumber_wrap.cpp @@ -0,0 +1,117 @@ +#include "QtWidgets/QLCDNumber/qlcdnumber_wrap.h" + +#include + +#include "Extras/Utils/nutils.h" +#include "QtWidgets/QWidget/qwidget_wrap.h" + +Napi::FunctionReference QLCDNumberWrap::constructor; + +Napi::Object QLCDNumberWrap::init(Napi::Env env, Napi::Object exports) { + Napi::HandleScope scope(env); + char CLASSNAME[] = "QLCDNumber"; + Napi::Function func = DefineClass( + env, CLASSNAME, + {InstanceMethod("checkOverflow", &QLCDNumberWrap::checkOverflow), + InstanceMethod("display", &QLCDNumberWrap::display), + InstanceMethod("setBinMode", &QLCDNumberWrap::setBinMode), + InstanceMethod("setDecMode", &QLCDNumberWrap::setDecMode), + InstanceMethod("setHexMode", &QLCDNumberWrap::setHexMode), + InstanceMethod("setOctMode", &QLCDNumberWrap::setOctMode), + QWIDGET_WRAPPED_METHODS_EXPORT_DEFINE(QLCDNumberWrap)}); + constructor = Napi::Persistent(func); + exports.Set(CLASSNAME, func); + return exports; +} + +NLCDNumber* QLCDNumberWrap::getInternalInstance() { return this->instance; } + +QLCDNumberWrap::~QLCDNumberWrap() { extrautils::safeDelete(this->instance); } + +QLCDNumberWrap::QLCDNumberWrap(const Napi::CallbackInfo& info) + : Napi::ObjectWrap(info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + if (info.Length() == 1) { + Napi::Object parentObject = info[0].As(); + NodeWidgetWrap* parentWidgetWrap = + Napi::ObjectWrap::Unwrap(parentObject); + this->instance = new NLCDNumber(parentWidgetWrap->getInternalInstance()); + } else if (info.Length() == 0) { + this->instance = new NLCDNumber(); + } else { + Napi::TypeError::New(env, "Wrong number of arguments") + .ThrowAsJavaScriptException(); + } + this->rawData = extrautils::configureQWidget( + this->getInternalInstance(), this->getInternalInstance()->getFlexNode(), + true); +} + +Napi::Value QLCDNumberWrap::checkOverflow(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + Napi::Value value = info[0]; + bool result; + if (extrautils::isNapiValueInt(env, value)) { + int num = value.As().Int32Value(); + result = this->instance->checkOverflow(num); + } else { + double num = value.As().DoubleValue(); + result = this->instance->checkOverflow(num); + } + return Napi::Boolean::New(env, result); +} + +Napi::Value QLCDNumberWrap::display(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + Napi::Value value = info[0]; + if (value.IsString()) { + std::string napis = value.As().Utf8Value(); + QString s = QString::fromUtf8(napis.c_str()); + this->instance->display(s); + } else if (extrautils::isNapiValueInt(env, value)) { + int num = value.As().Int32Value(); + this->instance->display(num); + } else { + double num = value.As().DoubleValue(); + this->instance->display(num); + } + return env.Null(); +} + +Napi::Value QLCDNumberWrap::setBinMode(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + this->instance->setBinMode(); + return env.Null(); +} + +Napi::Value QLCDNumberWrap::setDecMode(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + this->instance->setDecMode(); + return env.Null(); +} + +Napi::Value QLCDNumberWrap::setHexMode(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + this->instance->setHexMode(); + return env.Null(); +} + +Napi::Value QLCDNumberWrap::setOctMode(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + this->instance->setOctMode(); + return env.Null(); +} diff --git a/src/cpp/main.cpp b/src/cpp/main.cpp index fd6c25e3c7..b208769fef 100644 --- a/src/cpp/main.cpp +++ b/src/cpp/main.cpp @@ -46,6 +46,7 @@ #include "QtWidgets/QGridLayout/qgridlayout_wrap.h" #include "QtWidgets/QGroupBox/qgroupbox_wrap.h" #include "QtWidgets/QInputDialog/qinputdialog_wrap.h" +#include "QtWidgets/QLCDNumber/qlcdnumber_wrap.h" #include "QtWidgets/QLabel/qlabel_wrap.h" #include "QtWidgets/QLayout/qlayout_wrap.h" #include "QtWidgets/QLineEdit/qlineedit_wrap.h" @@ -158,6 +159,7 @@ Napi::Object Main(Napi::Env env, Napi::Object exports) { QPlainTextEditWrap::init(env, exports); QDialWrap::init(env, exports); QLabelWrap::init(env, exports); + QLCDNumberWrap::init(env, exports); QScrollAreaWrap::init(env, exports); QScrollBarWrap::init(env, exports); QSystemTrayIconWrap::init(env, exports); diff --git a/src/index.ts b/src/index.ts index b7a05fb2cc..dac07acff1 100644 --- a/src/index.ts +++ b/src/index.ts @@ -41,6 +41,7 @@ export { QColorDialog, QColorDialogSignals } from './lib/QtWidgets/QColorDialog' export { QDateEdit } from './lib/QtWidgets/QDateEdit'; export { QDateTimeEdit, NodeDateTimeEdit, QDateTimeEditSignals } from './lib/QtWidgets/QDateTimeEdit'; export { QLabel, QLabelSignals } from './lib/QtWidgets/QLabel'; +export { QLCDNumber, QLCDNumberSignals, Mode, SegmentStyle } from './lib/QtWidgets/QLCDNumber'; export { QDial, QDialSignals } from './lib/QtWidgets/QDial'; export { QDoubleSpinBox, QDoubleSpinBoxSignals } from './lib/QtWidgets/QDoubleSpinBox'; export { QErrorMessage, QErrorMessageSignals } from './lib/QtWidgets/QErrorMessage'; diff --git a/src/lib/QtWidgets/QLCDNumber.ts b/src/lib/QtWidgets/QLCDNumber.ts new file mode 100644 index 0000000000..9e875dbb1d --- /dev/null +++ b/src/lib/QtWidgets/QLCDNumber.ts @@ -0,0 +1,103 @@ +import addon from '../utils/addon'; +import { NodeWidget, QWidgetSignals } from './QWidget'; +import { NativeElement } from '../core/Component'; + +/** + +> Create and control number. + +* **This class is a JS wrapper around Qt's [QLCDNumber class](https://doc.qt.io/qt-5/qlcdnumber.html)** + +The `QLCDNumber` widget displays a number with LCD-like digits. + +### Example + +```javascript +const { QLCDNumber } = require("@nodegui/nodegui"); + +const lcd = new QLCDNumber(); + +``` + + */ +export class QLCDNumber extends NodeWidget { + native: NativeElement; + constructor(); + constructor(parent: NodeWidget); + constructor(parent?: NodeWidget) { + let native; + if (parent) { + native = new addon.QLCDNumber(parent.native); + } else { + native = new addon.QLCDNumber(); + } + super(native); + this.native = native; + parent && this.setNodeParent(parent); + } + setDigitCount(numDigits: number): void { + this.setProperty('digitCount', numDigits); + } + digitCount(): number { + return this.property('digitCount').toInt(); + } + intValue(): number { + return this.property('intValue').toInt(); + } + setMode(mode: Mode): void { + this.setProperty('mode', mode); + } + mode(): Mode { + return this.property('mode').toInt(); + } + setSegmentStyle(style: SegmentStyle): void { + this.setProperty('segmentStyle', style); + } + segmentStyle(): SegmentStyle { + return this.property('segmentStyle').toInt(); + } + setSmallDecimalPoint(enabled: boolean): void { + this.setProperty('smallDecimalPoint', enabled); + } + smallDecimalPoint(): boolean { + return this.property('smallDecimalPoint').toBool(); + } + value(): number { + return this.property('value').toDouble(); + } + checkOverflow(num: number): boolean { + return this.native.checkOverflow(num); + } + display(value: string | number): void { + this.native.display(value); + } + setBinMode(): void { + this.native.setBinMode(); + } + setDecMode(): void { + this.native.setDecMode(); + } + setHexMode(): void { + this.native.setHexMode(); + } + setOctMode(): void { + this.native.setOctMode(); + } +} + +export enum Mode { + Hex, + Dec, + Oct, + Bin, +} + +export enum SegmentStyle { + Outline, + Filled, + Flat, +} + +export interface QLCDNumberSignals extends QWidgetSignals { + overflow: () => void; +}