plastichub/nodeguy
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge branch 'master' of https://github.com/nodegui/nodegui

Browse Source
This commit is contained in:
Atul R 2020-04-01 11:56:07 +02:00
commit e5d8c5cb48
19 changed files with 2375 additions and 1036 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
README.md
View File

@ -46,7 +46,7 @@ https://github.com/nodegui/examples
- 🕵️‍♂️ Good Devtools support. - 🕵️‍♂️ Good Devtools support.
- 📚 Good documentation and website. - 📚 Good documentation and website.
- 🧙‍♂️ Good documentation for contributors. - 🧙‍♂️ Good documentation for contributors.
- 🦹🏻‍♀️ Good support for dark mode (Thanks to QT). - 🦹🏻‍♀️ Good support for dark mode (Thanks to Qt).
- 🏅First class Typescript support. (Works on regular JS projects too 😉). - 🏅First class Typescript support. (Works on regular JS projects too 😉).
## Getting Started ## Getting Started

2424
package-lock.json generated
View File

File diff suppressed because it is too large Load Diff

4
src/cpp/include/nodegui/QtWidgets/QBoxLayout/qboxlayout_wrap.h
View File

@ -30,6 +30,10 @@ class DLL_EXPORT QBoxLayoutWrap : public Napi::ObjectWrap<QBoxLayoutWrap> {
Napi::Value insertWidget(const Napi::CallbackInfo& info); Napi::Value insertWidget(const Napi::CallbackInfo& info);
Napi::Value direction(const Napi::CallbackInfo& info); Napi::Value direction(const Napi::CallbackInfo& info);
Napi::Value insertLayout(const Napi::CallbackInfo& info); Napi::Value insertLayout(const Napi::CallbackInfo& info);
Napi::Value insertSpacing(const Napi::CallbackInfo& info);
Napi::Value insertStretch(const Napi::CallbackInfo& info);
Napi::Value removeWidget(const Napi::CallbackInfo& info); Napi::Value removeWidget(const Napi::CallbackInfo& info);
Napi::Value setDirection(const Napi::CallbackInfo& info); Napi::Value setDirection(const Napi::CallbackInfo& info);
Napi::Value setStretch(const Napi::CallbackInfo& info);
Napi::Value count(const Napi::CallbackInfo& info);
}; };

67
src/cpp/include/nodegui/QtWidgets/QLayout/qlayout_macro.h
View File

@ -12,26 +12,49 @@
*/ */
#ifndef QLAYOUT_WRAPPED_METHODS_DECLARATION #ifndef QLAYOUT_WRAPPED_METHODS_DECLARATION
#define QLAYOUT_WRAPPED_METHODS_DECLARATION \ #define QLAYOUT_WRAPPED_METHODS_DECLARATION \
QOBJECT_WRAPPED_METHODS_DECLARATION \ QOBJECT_WRAPPED_METHODS_DECLARATION \
\ \
Napi::Value activate(const Napi::CallbackInfo& info) { \ Napi::Value activate(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \ Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \ Napi::HandleScope scope(env); \
bool wasRedone = this->instance->activate(); \ bool wasRedone = this->instance->activate(); \
return Napi::Boolean::New(env, wasRedone); \ return Napi::Boolean::New(env, wasRedone); \
} \ } \
Napi::Value invalidate(const Napi::CallbackInfo& info) { \ Napi::Value setEnabled(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \ Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \ Napi::HandleScope scope(env); \
this->instance->invalidate(); \ bool enable = info[0].As<Napi::Boolean>().Value(); \
return env.Null(); \ this->instance->setEnabled(enable); \
} \ return env.Null(); \
Napi::Value update(const Napi::CallbackInfo& info) { \ } \
Napi::Env env = info.Env(); \ Napi::Value isEnabled(const Napi::CallbackInfo& info) { \
Napi::HandleScope scope(env); \ Napi::Env env = info.Env(); \
this->instance->update(); \ Napi::HandleScope scope(env); \
return env.Null(); \ bool enabled = this->instance->isEnabled(); \
return Napi::Boolean::New(env, enabled); \
} \
Napi::Value setContentsMargins(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \
int left = info[0].As<Napi::Number>().Int32Value(); \
int top = info[1].As<Napi::Number>().Int32Value(); \
int right = info[2].As<Napi::Number>().Int32Value(); \
int bottom = info[3].As<Napi::Number>().Int32Value(); \
this->instance->setContentsMargins(left, top, right, bottom); \
return env.Null(); \
} \
Napi::Value invalidate(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \
this->instance->invalidate(); \
return env.Null(); \
} \
Napi::Value update(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \
this->instance->update(); \
return env.Null(); \
} }
#endif // QLAYOUT_WRAPPED_METHODS_DECLARATION #endif // QLAYOUT_WRAPPED_METHODS_DECLARATION
@ -41,6 +64,10 @@
\ \
QOBJECT_WRAPPED_METHODS_EXPORT_DEFINE(LayoutWrapName) \ QOBJECT_WRAPPED_METHODS_EXPORT_DEFINE(LayoutWrapName) \
InstanceMethod("activate", &LayoutWrapName::activate), \ InstanceMethod("activate", &LayoutWrapName::activate), \
InstanceMethod("setEnabled", &LayoutWrapName::setEnabled), \
InstanceMethod("isEnabled", &LayoutWrapName::isEnabled), \
InstanceMethod("setContentsMargins", \
&LayoutWrapName::setContentsMargins), \
InstanceMethod("invalidate", &LayoutWrapName::invalidate), \ InstanceMethod("invalidate", &LayoutWrapName::invalidate), \
InstanceMethod("update", &LayoutWrapName::update), InstanceMethod("update", &LayoutWrapName::update),

5
src/cpp/include/nodegui/QtWidgets/QTreeWidget/qtreewidget_wrap.h
View File

@ -36,10 +36,9 @@ class DLL_EXPORT QTreeWidgetWrap : public Napi::ObjectWrap<QTreeWidgetWrap> {
Napi::Value setItemWidget(const Napi::CallbackInfo &info); Napi::Value setItemWidget(const Napi::CallbackInfo &info);
Napi::Value currentItem(const Napi::CallbackInfo &info); Napi::Value currentItem(const Napi::CallbackInfo &info);
Napi::Value findItems(const Napi::CallbackInfo &info); Napi::Value findItems(const Napi::CallbackInfo &info);
Napi::Value takeTopLevelItem(const Napi::CallbackInfo &info);
Napi::Value clear(const Napi::CallbackInfo &info);
// Napi::Value addTopLevelItems(const Napi::CallbackInfo& info);
// Napi::Value setHorizontalScrollBarPolicy(const Napi::CallbackInfo& info); // Napi::Value setHorizontalScrollBarPolicy(const Napi::CallbackInfo& info);
// Napi::Value setVerticalScrollBarPolicy(const Napi::CallbackInfo& info); // Napi::Value setVerticalScrollBarPolicy(const Napi::CallbackInfo& info);
// Napi::Value takeTopLevelItem(const Napi::CallbackInfo& info);
// Napi::Value findItems(const Napi::CallbackInfo& info);
}; };

679
src/cpp/include/nodegui/QtWidgets/QWidget/qwidget_macro.h
View File

@ -4,6 +4,7 @@
#include <QStyle> #include <QStyle>
#include "QtCore/QObject/qobject_macro.h" #include "QtCore/QObject/qobject_macro.h"
#include "QtCore/QPoint/qpoint_wrap.h"
#include "QtCore/QSize/qsize_wrap.h" #include "QtCore/QSize/qsize_wrap.h"
#include "QtGui/QIcon/qicon_wrap.h" #include "QtGui/QIcon/qicon_wrap.h"
#include "QtWidgets/QAction/qaction_wrap.h" #include "QtWidgets/QAction/qaction_wrap.h"
@ -17,322 +18,364 @@
*/ */
#ifndef QWIDGET_WRAPPED_METHODS_DECLARATION #ifndef QWIDGET_WRAPPED_METHODS_DECLARATION
#define QWIDGET_WRAPPED_METHODS_DECLARATION \ #define QWIDGET_WRAPPED_METHODS_DECLARATION \
\ \
QOBJECT_WRAPPED_METHODS_DECLARATION \ QOBJECT_WRAPPED_METHODS_DECLARATION \
YOGAWIDGET_WRAPPED_METHODS_DECLARATION \ YOGAWIDGET_WRAPPED_METHODS_DECLARATION \
\ \
Napi::Value show(const Napi::CallbackInfo& info) { \ Napi::Value show(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \ Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \ Napi::HandleScope scope(env); \
this->instance->show(); \ this->instance->show(); \
return env.Null(); \ return env.Null(); \
} \ } \
Napi::Value resize(const Napi::CallbackInfo& info) { \ Napi::Value resize(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \ Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \ Napi::HandleScope scope(env); \
Napi::Number width = info[0].As<Napi::Number>(); \ Napi::Number width = info[0].As<Napi::Number>(); \
Napi::Number height = info[1].As<Napi::Number>(); \ Napi::Number height = info[1].As<Napi::Number>(); \
this->instance->resize(width.Int32Value(), height.Int32Value()); \ this->instance->resize(width.Int32Value(), height.Int32Value()); \
return env.Null(); \ return env.Null(); \
} \ } \
Napi::Value close(const Napi::CallbackInfo& info) { \ Napi::Value close(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \ Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \ Napi::HandleScope scope(env); \
bool hasClosed = this->instance->close(); \ bool hasClosed = this->instance->close(); \
return Napi::Boolean::New(env, hasClosed); \ return Napi::Boolean::New(env, hasClosed); \
} \ } \
Napi::Value isVisible(const Napi::CallbackInfo& info) { \ Napi::Value mapFromGlobal(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \ Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \ Napi::HandleScope scope(env); \
bool isVisible = this->instance->isVisible(); \ Napi::Object posObject = info[0].As<Napi::Object>(); \
return Napi::Boolean::New(env, isVisible); \ QPointWrap* posWrap = Napi::ObjectWrap<QPointWrap>::Unwrap(posObject); \
} \ QPoint pt = \
\ this->instance->mapFromGlobal(*posWrap->getInternalInstance()); \
Napi::Value setLayout(const Napi::CallbackInfo& info) { \ auto instance = QPointWrap::constructor.New( \
Napi::Env env = info.Env(); \ {Napi::External<QPoint>::New(env, new QPoint(pt.x(), pt.y()))}); \
Napi::HandleScope scope(env); \ return instance; \
Napi::Object layoutObject = info[0].As<Napi::Object>(); \ } \
QLayoutWrap* layoutWrap = \ Napi::Value mapFromParent(const Napi::CallbackInfo& info) { \
Napi::ObjectWrap<QLayoutWrap>::Unwrap(layoutObject); \ Napi::Env env = info.Env(); \
this->instance->setLayout(layoutWrap->getInternalInstance()); \ Napi::HandleScope scope(env); \
return env.Null(); \ Napi::Object posObject = info[0].As<Napi::Object>(); \
} \ QPointWrap* posWrap = Napi::ObjectWrap<QPointWrap>::Unwrap(posObject); \
\ QPoint pt = \
Napi::Value setStyleSheet(const Napi::CallbackInfo& info) { \ this->instance->mapFromParent(*posWrap->getInternalInstance()); \
Napi::Env env = info.Env(); \ auto instance = QPointWrap::constructor.New( \
Napi::HandleScope scope(env); \ {Napi::External<QPoint>::New(env, new QPoint(pt.x(), pt.y()))}); \
Napi::String text = info[0].As<Napi::String>(); \ return instance; \
std::string style = text.Utf8Value(); \ } \
QString newStyle = QString::fromStdString(style); \ Napi::Value mapToGlobal(const Napi::CallbackInfo& info) { \
QString currentStyleSheet = this->instance->styleSheet(); \ Napi::Env env = info.Env(); \
if (newStyle != currentStyleSheet) { \ Napi::HandleScope scope(env); \
this->instance->setStyleSheet(newStyle); \ Napi::Object posObject = info[0].As<Napi::Object>(); \
} \ QPointWrap* posWrap = Napi::ObjectWrap<QPointWrap>::Unwrap(posObject); \
return env.Null(); \ QPoint pt = this->instance->mapToGlobal(*posWrap->getInternalInstance()); \
} \ auto instance = QPointWrap::constructor.New( \
Napi::Value setCursor(const Napi::CallbackInfo& info) { \ {Napi::External<QPoint>::New(env, new QPoint(pt.x(), pt.y()))}); \
Napi::Env env = info.Env(); \ return instance; \
Napi::HandleScope scope(env); \ } \
Napi::Number cursor = info[0].As<Napi::Number>(); \ Napi::Value mapToParent(const Napi::CallbackInfo& info) { \
this->instance->setCursor( \ Napi::Env env = info.Env(); \
static_cast<Qt::CursorShape>(cursor.Int32Value())); \ Napi::HandleScope scope(env); \
return env.Null(); \ Napi::Object posObject = info[0].As<Napi::Object>(); \
} \ QPointWrap* posWrap = Napi::ObjectWrap<QPointWrap>::Unwrap(posObject); \
Napi::Value setWindowIcon(const Napi::CallbackInfo& info) { \ QPoint pt = this->instance->mapToParent(*posWrap->getInternalInstance()); \
Napi::Env env = info.Env(); \ auto instance = QPointWrap::constructor.New( \
Napi::HandleScope scope(env); \ {Napi::External<QPoint>::New(env, new QPoint(pt.x(), pt.y()))}); \
Napi::Object iconObject = info[0].As<Napi::Object>(); \ return instance; \
QIconWrap* iconWrap = Napi::ObjectWrap<QIconWrap>::Unwrap(iconObject); \ } \
this->instance->setWindowIcon(*iconWrap->getInternalInstance()); \ Napi::Value isVisible(const Napi::CallbackInfo& info) { \
return env.Null(); \ Napi::Env env = info.Env(); \
} \ Napi::HandleScope scope(env); \
Napi::Value setWindowState(const Napi::CallbackInfo& info) { \ bool isVisible = this->instance->isVisible(); \
Napi::Env env = info.Env(); \ return Napi::Boolean::New(env, isVisible); \
Napi::HandleScope scope(env); \ } \
Napi::Number state = info[0].As<Napi::Number>(); \ \
this->instance->setWindowState( \ Napi::Value setLayout(const Napi::CallbackInfo& info) { \
static_cast<Qt::WindowState>(state.Int32Value())); \ Napi::Env env = info.Env(); \
return env.Null(); \ Napi::HandleScope scope(env); \
} \ Napi::Object layoutObject = info[0].As<Napi::Object>(); \
Napi::Value windowState(const Napi::CallbackInfo& info) { \ QLayoutWrap* layoutWrap = \
Napi::Env env = info.Env(); \ Napi::ObjectWrap<QLayoutWrap>::Unwrap(layoutObject); \
Napi::HandleScope scope(env); \ this->instance->setLayout(layoutWrap->getInternalInstance()); \
int state = static_cast<int>(this->instance->windowState()); \ return env.Null(); \
return Napi::Value::From(env, state); \ } \
} \ \
Napi::Value setWindowTitle(const Napi::CallbackInfo& info) { \ Napi::Value setStyleSheet(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \ Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \ Napi::HandleScope scope(env); \
Napi::String napiTitle = info[0].As<Napi::String>(); \ Napi::String text = info[0].As<Napi::String>(); \
std::string title = napiTitle.Utf8Value(); \ std::string style = text.Utf8Value(); \
this->instance->setWindowTitle(title.c_str()); \ QString newStyle = QString::fromStdString(style); \
return env.Null(); \ QString currentStyleSheet = this->instance->styleSheet(); \
} \ if (newStyle != currentStyleSheet) { \
Napi::Value windowTitle(const Napi::CallbackInfo& info) { \ this->instance->setStyleSheet(newStyle); \
Napi::Env env = info.Env(); \ } \
Napi::HandleScope scope(env); \ return env.Null(); \
QString title = this->instance->windowTitle(); \ } \
return Napi::String::New(env, title.toStdString()); \ Napi::Value setCursor(const Napi::CallbackInfo& info) { \
} \ Napi::Env env = info.Env(); \
Napi::Value styleSheet(const Napi::CallbackInfo& info) { \ Napi::HandleScope scope(env); \
Napi::Env env = info.Env(); \ Napi::Number cursor = info[0].As<Napi::Number>(); \
Napi::HandleScope scope(env); \ this->instance->setCursor( \
QString stylesheet = this->instance->styleSheet(); \ static_cast<Qt::CursorShape>(cursor.Int32Value())); \
return Napi::String::New(env, stylesheet.toStdString()); \ return env.Null(); \
} \ } \
Napi::Value hide(const Napi::CallbackInfo& info) { \ Napi::Value setWindowIcon(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \ Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \ Napi::HandleScope scope(env); \
this->instance->hide(); \ Napi::Object iconObject = info[0].As<Napi::Object>(); \
return env.Null(); \ QIconWrap* iconWrap = Napi::ObjectWrap<QIconWrap>::Unwrap(iconObject); \
} \ this->instance->setWindowIcon(*iconWrap->getInternalInstance()); \
Napi::Value move(const Napi::CallbackInfo& info) { \ return env.Null(); \
Napi::Env env = info.Env(); \ } \
Napi::HandleScope scope(env); \ Napi::Value setWindowState(const Napi::CallbackInfo& info) { \
int x = info[0].As<Napi::Number>().Int32Value(); \ Napi::Env env = info.Env(); \
int y = info[1].As<Napi::Number>().Int32Value(); \ Napi::HandleScope scope(env); \
this->instance->move(x, y); \ Napi::Number state = info[0].As<Napi::Number>(); \
return env.Null(); \ this->instance->setWindowState( \
} \ static_cast<Qt::WindowState>(state.Int32Value())); \
\ return env.Null(); \
Napi::Value setMouseTracking(const Napi::CallbackInfo& info) { \ } \
Napi::Env env = info.Env(); \ Napi::Value windowState(const Napi::CallbackInfo& info) { \
Napi::HandleScope scope(env); \ Napi::Env env = info.Env(); \
Napi::Boolean isMouseTracked = info[0].As<Napi::Boolean>(); \ Napi::HandleScope scope(env); \
this->instance->setMouseTracking(isMouseTracked.Value()); \ int state = static_cast<int>(this->instance->windowState()); \
return env.Null(); \ return Napi::Value::From(env, state); \
} \ } \
Napi::Value hasMouseTracking(const Napi::CallbackInfo& info) { \ Napi::Value setWindowTitle(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \ Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \ Napi::HandleScope scope(env); \
bool isMouseTracked = this->instance->hasMouseTracking(); \ Napi::String napiTitle = info[0].As<Napi::String>(); \
return Napi::Value::From(env, isMouseTracked); \ std::string title = napiTitle.Utf8Value(); \
} \ this->instance->setWindowTitle(title.c_str()); \
Napi::Value setEnabled(const Napi::CallbackInfo& info) { \ return env.Null(); \
Napi::Env env = info.Env(); \ } \
Napi::HandleScope scope(env); \ Napi::Value windowTitle(const Napi::CallbackInfo& info) { \
Napi::Boolean enabled = info[0].As<Napi::Boolean>(); \ Napi::Env env = info.Env(); \
this->instance->setEnabled(enabled.Value()); \ Napi::HandleScope scope(env); \
return env.Null(); \ QString title = this->instance->windowTitle(); \
} \ return Napi::String::New(env, title.toStdString()); \
Napi::Value isEnabled(const Napi::CallbackInfo& info) { \ } \
Napi::Env env = info.Env(); \ Napi::Value styleSheet(const Napi::CallbackInfo& info) { \
Napi::HandleScope scope(env); \ Napi::Env env = info.Env(); \
bool enabled = this->instance->isEnabled(); \ Napi::HandleScope scope(env); \
return Napi::Value::From(env, enabled); \ QString stylesheet = this->instance->styleSheet(); \
} \ return Napi::String::New(env, stylesheet.toStdString()); \
Napi::Value setFixedSize(const Napi::CallbackInfo& info) { \ } \
Napi::Env env = info.Env(); \ Napi::Value hide(const Napi::CallbackInfo& info) { \
Napi::HandleScope scope(env); \ Napi::Env env = info.Env(); \
int width = info[0].As<Napi::Number>().Int32Value(); \ Napi::HandleScope scope(env); \
int height = info[1].As<Napi::Number>().Int32Value(); \ this->instance->hide(); \
this->instance->setFixedSize(width, height); \ return env.Null(); \
return env.Null(); \ } \
} \ Napi::Value move(const Napi::CallbackInfo& info) { \
Napi::Value setGeometry(const Napi::CallbackInfo& info) { \ Napi::Env env = info.Env(); \
Napi::Env env = info.Env(); \ Napi::HandleScope scope(env); \
Napi::HandleScope scope(env); \ int x = info[0].As<Napi::Number>().Int32Value(); \
int x = info[0].As<Napi::Number>().Int32Value(); \ int y = info[1].As<Napi::Number>().Int32Value(); \
int y = info[1].As<Napi::Number>().Int32Value(); \ this->instance->move(x, y); \
int width = info[2].As<Napi::Number>().Int32Value(); \ return env.Null(); \
int height = info[3].As<Napi::Number>().Int32Value(); \ } \
this->instance->setGeometry(x, y, width, height); \ \
return env.Null(); \ Napi::Value setMouseTracking(const Napi::CallbackInfo& info) { \
} \ Napi::Env env = info.Env(); \
Napi::Value setMaximumSize(const Napi::CallbackInfo& info) { \ Napi::HandleScope scope(env); \
Napi::Env env = info.Env(); \ Napi::Boolean isMouseTracked = info[0].As<Napi::Boolean>(); \
Napi::HandleScope scope(env); \ this->instance->setMouseTracking(isMouseTracked.Value()); \
int width = info[0].As<Napi::Number>().Int32Value(); \ return env.Null(); \
int height = info[1].As<Napi::Number>().Int32Value(); \ } \
this->instance->setMaximumSize(width, height); \ Napi::Value hasMouseTracking(const Napi::CallbackInfo& info) { \
return env.Null(); \ Napi::Env env = info.Env(); \
} \ Napi::HandleScope scope(env); \
Napi::Value setMinimumSize(const Napi::CallbackInfo& info) { \ bool isMouseTracked = this->instance->hasMouseTracking(); \
Napi::Env env = info.Env(); \ return Napi::Value::From(env, isMouseTracked); \
Napi::HandleScope scope(env); \ } \
int width = info[0].As<Napi::Number>().Int32Value(); \ Napi::Value setEnabled(const Napi::CallbackInfo& info) { \
int height = info[1].As<Napi::Number>().Int32Value(); \ Napi::Env env = info.Env(); \
this->instance->setMinimumSize(width, height); \ Napi::HandleScope scope(env); \
return env.Null(); \ Napi::Boolean enabled = info[0].As<Napi::Boolean>(); \
} \ this->instance->setEnabled(enabled.Value()); \
Napi::Value repaint(const Napi::CallbackInfo& info) { \ return env.Null(); \
Napi::Env env = info.Env(); \ } \
Napi::HandleScope scope(env); \ Napi::Value isEnabled(const Napi::CallbackInfo& info) { \
this->instance->repaint(); \ Napi::Env env = info.Env(); \
return env.Null(); \ Napi::HandleScope scope(env); \
} \ bool enabled = this->instance->isEnabled(); \
Napi::Value update(const Napi::CallbackInfo& info) { \ return Napi::Value::From(env, enabled); \
Napi::Env env = info.Env(); \ } \
Napi::HandleScope scope(env); \ Napi::Value setFixedSize(const Napi::CallbackInfo& info) { \
this->instance->update(); \ Napi::Env env = info.Env(); \
return env.Null(); \ Napi::HandleScope scope(env); \
} \ int width = info[0].As<Napi::Number>().Int32Value(); \
Napi::Value updateGeometry(const Napi::CallbackInfo& info) { \ int height = info[1].As<Napi::Number>().Int32Value(); \
Napi::Env env = info.Env(); \ this->instance->setFixedSize(width, height); \
Napi::HandleScope scope(env); \ return env.Null(); \
this->instance->updateGeometry(); \ } \
return env.Null(); \ Napi::Value setGeometry(const Napi::CallbackInfo& info) { \
} \ Napi::Env env = info.Env(); \
Napi::Value pos(const Napi::CallbackInfo& info) { \ Napi::HandleScope scope(env); \
Napi::Env env = info.Env(); \ int x = info[0].As<Napi::Number>().Int32Value(); \
Napi::HandleScope scope(env); \ int y = info[1].As<Napi::Number>().Int32Value(); \
QPoint pos = this->instance->pos(); \ int width = info[2].As<Napi::Number>().Int32Value(); \
Napi::Object posObj = Napi::Object::New(env); \ int height = info[3].As<Napi::Number>().Int32Value(); \
posObj.Set("x", pos.x()); \ this->instance->setGeometry(x, y, width, height); \
posObj.Set("y", pos.y()); \ return env.Null(); \
return posObj; \ } \
} \ Napi::Value setMaximumSize(const Napi::CallbackInfo& info) { \
Napi::Value size(const Napi::CallbackInfo& info) { \ Napi::Env env = info.Env(); \
Napi::Env env = info.Env(); \ Napi::HandleScope scope(env); \
Napi::HandleScope scope(env); \ int width = info[0].As<Napi::Number>().Int32Value(); \
QSize size = this->instance->size(); \ int height = info[1].As<Napi::Number>().Int32Value(); \
auto sizeWrap = QSizeWrap::constructor.New({Napi::External<QSize>::New( \ this->instance->setMaximumSize(width, height); \
env, new QSize(size.width(), size.height()))}); \ return env.Null(); \
return sizeWrap; \ } \
} \ Napi::Value setMinimumSize(const Napi::CallbackInfo& info) { \
Napi::Value setAttribute(const Napi::CallbackInfo& info) { \ Napi::Env env = info.Env(); \
Napi::Env env = info.Env(); \ Napi::HandleScope scope(env); \
Napi::HandleScope scope(env); \ int width = info[0].As<Napi::Number>().Int32Value(); \
int attributeId = info[0].As<Napi::Number>().Int32Value(); \ int height = info[1].As<Napi::Number>().Int32Value(); \
bool switchOn = info[1].As<Napi::Boolean>().Value(); \ this->instance->setMinimumSize(width, height); \
this->instance->setAttribute( \ return env.Null(); \
static_cast<Qt::WidgetAttribute>(attributeId), switchOn); \ } \
return env.Null(); \ Napi::Value repaint(const Napi::CallbackInfo& info) { \
} \ Napi::Env env = info.Env(); \
Napi::Value testAttribute(const Napi::CallbackInfo& info) { \ Napi::HandleScope scope(env); \
Napi::Env env = info.Env(); \ this->instance->repaint(); \
Napi::HandleScope scope(env); \ return env.Null(); \
int attributeId = info[0].As<Napi::Number>().Int32Value(); \ } \
bool isOn = this->instance->testAttribute( \ Napi::Value update(const Napi::CallbackInfo& info) { \
static_cast<Qt::WidgetAttribute>(attributeId)); \ Napi::Env env = info.Env(); \
return Napi::Boolean::New(env, isOn); \ Napi::HandleScope scope(env); \
} \ this->instance->update(); \
Napi::Value setWindowOpacity(const Napi::CallbackInfo& info) { \ return env.Null(); \
Napi::Env env = info.Env(); \ } \
Napi::HandleScope scope(env); \ Napi::Value updateGeometry(const Napi::CallbackInfo& info) { \
float opacity = info[0].As<Napi::Number>().FloatValue(); \ Napi::Env env = info.Env(); \
this->instance->setWindowOpacity(opacity); \ Napi::HandleScope scope(env); \
return env.Null(); \ this->instance->updateGeometry(); \
} \ return env.Null(); \
Napi::Value windowOpacity(const Napi::CallbackInfo& info) { \ } \
Napi::Env env = info.Env(); \ Napi::Value pos(const Napi::CallbackInfo& info) { \
Napi::HandleScope scope(env); \ Napi::Env env = info.Env(); \
float opacity = this->instance->windowOpacity(); \ Napi::HandleScope scope(env); \
return Napi::Value::From(env, opacity); \ QPoint pos = this->instance->pos(); \
} \ Napi::Object posObj = Napi::Object::New(env); \
Napi::Value setWindowFlag(const Napi::CallbackInfo& info) { \ posObj.Set("x", pos.x()); \
Napi::Env env = info.Env(); \ posObj.Set("y", pos.y()); \
Napi::HandleScope scope(env); \ return posObj; \
int windowType = info[0].As<Napi::Number>().Int32Value(); \ } \
bool switchOn = info[1].As<Napi::Boolean>().Value(); \ Napi::Value size(const Napi::CallbackInfo& info) { \
this->instance->setWindowFlag(static_cast<Qt::WindowType>(windowType), \ Napi::Env env = info.Env(); \
switchOn); \ Napi::HandleScope scope(env); \
return env.Null(); \ QSize size = this->instance->size(); \
} \ auto sizeWrap = QSizeWrap::constructor.New({Napi::External<QSize>::New( \
Napi::Value adjustSize(const Napi::CallbackInfo& info) { \ env, new QSize(size.width(), size.height()))}); \
Napi::Env env = info.Env(); \ return sizeWrap; \
Napi::HandleScope scope(env); \ } \
this->instance->adjustSize(); \ Napi::Value setAttribute(const Napi::CallbackInfo& info) { \
return env.Null(); \ Napi::Env env = info.Env(); \
} \ Napi::HandleScope scope(env); \
Napi::Value activateWindow(const Napi::CallbackInfo& info) { \ int attributeId = info[0].As<Napi::Number>().Int32Value(); \
Napi::Env env = info.Env(); \ bool switchOn = info[1].As<Napi::Boolean>().Value(); \
Napi::HandleScope scope(env); \ this->instance->setAttribute( \
this->instance->activateWindow(); \ static_cast<Qt::WidgetAttribute>(attributeId), switchOn); \
return env.Null(); \ return env.Null(); \
} \ } \
Napi::Value raise(const Napi::CallbackInfo& info) { \ Napi::Value testAttribute(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \ Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \ Napi::HandleScope scope(env); \
this->instance->raise(); \ int attributeId = info[0].As<Napi::Number>().Int32Value(); \
return env.Null(); \ bool isOn = this->instance->testAttribute( \
} \ static_cast<Qt::WidgetAttribute>(attributeId)); \
Napi::Value lower(const Napi::CallbackInfo& info) { \ return Napi::Boolean::New(env, isOn); \
Napi::Env env = info.Env(); \ } \
Napi::HandleScope scope(env); \ Napi::Value setWindowOpacity(const Napi::CallbackInfo& info) { \
this->instance->lower(); \ Napi::Env env = info.Env(); \
return env.Null(); \ Napi::HandleScope scope(env); \
} \ float opacity = info[0].As<Napi::Number>().FloatValue(); \
Napi::Value showFullScreen(const Napi::CallbackInfo& info) { \ this->instance->setWindowOpacity(opacity); \
Napi::Env env = info.Env(); \ return env.Null(); \
Napi::HandleScope scope(env); \ } \
this->instance->showFullScreen(); \ Napi::Value windowOpacity(const Napi::CallbackInfo& info) { \
return env.Null(); \ Napi::Env env = info.Env(); \
} \ Napi::HandleScope scope(env); \
Napi::Value showMaximized(const Napi::CallbackInfo& info) { \ float opacity = this->instance->windowOpacity(); \
Napi::Env env = info.Env(); \ return Napi::Value::From(env, opacity); \
Napi::HandleScope scope(env); \ } \
this->instance->showMaximized(); \ Napi::Value setWindowFlag(const Napi::CallbackInfo& info) { \
return env.Null(); \ Napi::Env env = info.Env(); \
} \ Napi::HandleScope scope(env); \
Napi::Value showMinimized(const Napi::CallbackInfo& info) { \ int windowType = info[0].As<Napi::Number>().Int32Value(); \
Napi::Env env = info.Env(); \ bool switchOn = info[1].As<Napi::Boolean>().Value(); \
Napi::HandleScope scope(env); \ this->instance->setWindowFlag(static_cast<Qt::WindowType>(windowType), \
this->instance->showMinimized(); \ switchOn); \
return env.Null(); \ return env.Null(); \
} \ } \
Napi::Value showNormal(const Napi::CallbackInfo& info) { \ Napi::Value adjustSize(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \ Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \ Napi::HandleScope scope(env); \
this->instance->showNormal(); \ this->instance->adjustSize(); \
return env.Null(); \ return env.Null(); \
} \ } \
Napi::Value addAction(const Napi::CallbackInfo& info) { \ Napi::Value activateWindow(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \ Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \ Napi::HandleScope scope(env); \
Napi::Object actionObject = info[0].As<Napi::Object>(); \ this->instance->activateWindow(); \
QActionWrap* actionWrap = \ return env.Null(); \
Napi::ObjectWrap<QActionWrap>::Unwrap(actionObject); \ } \
this->instance->addAction(actionWrap->getInternalInstance()); \ Napi::Value raise(const Napi::CallbackInfo& info) { \
return env.Null(); \ Napi::Env env = info.Env(); \
} \ Napi::HandleScope scope(env); \
Napi::Value repolish(const Napi::CallbackInfo& info) { \ this->instance->raise(); \
Napi::Env env = info.Env(); \ return env.Null(); \
Napi::HandleScope scope(env); \ } \
this->instance->style()->unpolish(this->instance); \ Napi::Value lower(const Napi::CallbackInfo& info) { \
this->instance->style()->polish(this->instance); \ Napi::Env env = info.Env(); \
return env.Null(); \ Napi::HandleScope scope(env); \
this->instance->lower(); \
return env.Null(); \
} \
Napi::Value showFullScreen(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \
this->instance->showFullScreen(); \
return env.Null(); \
} \
Napi::Value showMaximized(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \
this->instance->showMaximized(); \
return env.Null(); \
} \
Napi::Value showMinimized(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \
this->instance->showMinimized(); \
return env.Null(); \
} \
Napi::Value showNormal(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \
this->instance->showNormal(); \
return env.Null(); \
} \
Napi::Value addAction(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \
Napi::Object actionObject = info[0].As<Napi::Object>(); \
QActionWrap* actionWrap = \
Napi::ObjectWrap<QActionWrap>::Unwrap(actionObject); \
this->instance->addAction(actionWrap->getInternalInstance()); \
return env.Null(); \
} \
Napi::Value repolish(const Napi::CallbackInfo& info) { \
Napi::Env env = info.Env(); \
Napi::HandleScope scope(env); \
this->instance->style()->unpolish(this->instance); \
this->instance->style()->polish(this->instance); \
return env.Null(); \
} }
#endif // QWIDGET_WRAPPED_METHODS_DECLARATION #endif // QWIDGET_WRAPPED_METHODS_DECLARATION
@ -346,6 +389,10 @@
InstanceMethod("resize", &WidgetWrapName::resize), \ InstanceMethod("resize", &WidgetWrapName::resize), \
InstanceMethod("isVisible", &WidgetWrapName::isVisible), \ InstanceMethod("isVisible", &WidgetWrapName::isVisible), \
InstanceMethod("close", &WidgetWrapName::close), \ InstanceMethod("close", &WidgetWrapName::close), \
InstanceMethod("mapFromGlobal", &WidgetWrapName::mapFromGlobal), \
InstanceMethod("mapFromParent", &WidgetWrapName::mapFromParent), \
InstanceMethod("mapToGlobal", &WidgetWrapName::mapToGlobal), \
InstanceMethod("mapToParent", &WidgetWrapName::mapToParent), \
InstanceMethod("setLayout", &WidgetWrapName::setLayout), \ InstanceMethod("setLayout", &WidgetWrapName::setLayout), \
InstanceMethod("setStyleSheet", &WidgetWrapName::setStyleSheet), \ InstanceMethod("setStyleSheet", &WidgetWrapName::setStyleSheet), \
InstanceMethod("setCursor", &WidgetWrapName::setCursor), \ InstanceMethod("setCursor", &WidgetWrapName::setCursor), \

44
src/cpp/lib/QtWidgets/QBoxLayout/qboxlayout_wrap.cpp
View File

@ -18,8 +18,12 @@ Napi::Object QBoxLayoutWrap::init(Napi::Env env, Napi::Object exports) {
InstanceMethod("insertWidget", &QBoxLayoutWrap::insertWidget), InstanceMethod("insertWidget", &QBoxLayoutWrap::insertWidget),
InstanceMethod("direction", &QBoxLayoutWrap::direction), InstanceMethod("direction", &QBoxLayoutWrap::direction),
InstanceMethod("insertLayout", &QBoxLayoutWrap::insertLayout), InstanceMethod("insertLayout", &QBoxLayoutWrap::insertLayout),
InstanceMethod("insertSpacing", &QBoxLayoutWrap::insertSpacing),
InstanceMethod("insertStretch", &QBoxLayoutWrap::insertStretch),
InstanceMethod("removeWidget", &QBoxLayoutWrap::removeWidget), InstanceMethod("removeWidget", &QBoxLayoutWrap::removeWidget),
InstanceMethod("setDirection", &QBoxLayoutWrap::setDirection), InstanceMethod("setDirection", &QBoxLayoutWrap::setDirection),
InstanceMethod("setStretch", &QBoxLayoutWrap::setStretch),
InstanceMethod("count", &QBoxLayoutWrap::count),
QLAYOUT_WRAPPED_METHODS_EXPORT_DEFINE(QBoxLayoutWrap)}); QLAYOUT_WRAPPED_METHODS_EXPORT_DEFINE(QBoxLayoutWrap)});
constructor = Napi::Persistent(func); constructor = Napi::Persistent(func);
exports.Set(CLASSNAME, func); exports.Set(CLASSNAME, func);
@ -131,6 +135,26 @@ Napi::Value QBoxLayoutWrap::insertLayout(const Napi::CallbackInfo& info) {
return env.Null(); return env.Null();
} }
Napi::Value QBoxLayoutWrap::insertSpacing(const Napi::CallbackInfo& info) {
Napi::Env env = info.Env();
Napi::HandleScope scope(env);
int index = info[0].As<Napi::Number>().Int32Value();
int size = info[1].As<Napi::Number>().Int32Value();
this->instance->insertSpacing(index, size);
return env.Null();
}
Napi::Value QBoxLayoutWrap::insertStretch(const Napi::CallbackInfo& info) {
Napi::Env env = info.Env();
Napi::HandleScope scope(env);
int index = info[0].As<Napi::Number>().Int32Value();
int stretch = info[1].As<Napi::Number>().Int32Value();
this->instance->insertStretch(index, stretch);
return env.Null();
}
Napi::Value QBoxLayoutWrap::removeWidget(const Napi::CallbackInfo& info) { Napi::Value QBoxLayoutWrap::removeWidget(const Napi::CallbackInfo& info) {
Napi::Env env = info.Env(); Napi::Env env = info.Env();
Napi::HandleScope scope(env); Napi::HandleScope scope(env);
@ -149,4 +173,22 @@ Napi::Value QBoxLayoutWrap::setDirection(const Napi::CallbackInfo& info) {
info[0].As<Napi::Number>().Int32Value()); info[0].As<Napi::Number>().Int32Value());
this->instance->setDirection(dir); this->instance->setDirection(dir);
return env.Null(); return env.Null();
} }
Napi::Value QBoxLayoutWrap::setStretch(const Napi::CallbackInfo& info) {
Napi::Env env = info.Env();
Napi::HandleScope scope(env);
int index = info[0].As<Napi::Number>().Int32Value();
int stretch = info[1].As<Napi::Number>().Int32Value();
this->instance->setStretch(index, stretch);
return env.Null();
}
Napi::Value QBoxLayoutWrap::count(const Napi::CallbackInfo& info) {
Napi::Env env = info.Env();
Napi::HandleScope scope(env);
int count = this->instance->count();
return Napi::Number::New(env, count);
}

16
src/cpp/lib/QtWidgets/QMenu/qmenu_wrap.cpp
View File

@ -73,22 +73,24 @@ Napi::Value QMenuWrap::exec(const Napi::CallbackInfo& info) {
Napi::Env env = info.Env(); Napi::Env env = info.Env();
Napi::HandleScope scope(env); Napi::HandleScope scope(env);
if (info.Length() == 2) { if (info.Length() > 0) {
Napi::Object pointObject = info[0].As<Napi::Object>(); Napi::Object pointObject = info[0].As<Napi::Object>();
QPointWrap* pointWrap = Napi::ObjectWrap<QPointWrap>::Unwrap(pointObject); QPointWrap* pointWrap = Napi::ObjectWrap<QPointWrap>::Unwrap(pointObject);
QPoint* qpoint = pointWrap->getInternalInstance();
Napi::Object actionObject = info[1].As<Napi::Object>(); QAction* action = nullptr;
QActionWrap* actionWrap = if (info.Length() == 2) {
Napi::ObjectWrap<QActionWrap>::Unwrap(actionObject); Napi::Object actionObject = info[1].As<Napi::Object>();
this->instance->exec(*qpoint, actionWrap->getInternalInstance()); QActionWrap* actionWrap =
Napi::ObjectWrap<QActionWrap>::Unwrap(actionObject);
action = actionWrap->getInternalInstance();
}
this->instance->exec(*pointWrap->getInternalInstance(), action);
} else if (info.Length() == 0) { } else if (info.Length() == 0) {
this->instance->exec(); this->instance->exec();
} else { } else {
Napi::TypeError::New(env, "Wrong number of arguments") Napi::TypeError::New(env, "Wrong number of arguments")
.ThrowAsJavaScriptException(); .ThrowAsJavaScriptException();
} }
return env.Null(); return env.Null();
} }

41
src/cpp/lib/QtWidgets/QTreeWidget/qtreewidget_wrap.cpp
View File

@ -26,6 +26,8 @@ Napi::Object QTreeWidgetWrap::init(Napi::Env env, Napi::Object exports) {
InstanceMethod("setItemWidget", &QTreeWidgetWrap::setItemWidget), InstanceMethod("setItemWidget", &QTreeWidgetWrap::setItemWidget),
InstanceMethod("currentItem", &QTreeWidgetWrap::currentItem), InstanceMethod("currentItem", &QTreeWidgetWrap::currentItem),
InstanceMethod("findItems", &QTreeWidgetWrap::findItems), InstanceMethod("findItems", &QTreeWidgetWrap::findItems),
InstanceMethod("takeTopLevelItem", &QTreeWidgetWrap::takeTopLevelItem),
InstanceMethod("clear", &QTreeWidgetWrap::clear),
QWIDGET_WRAPPED_METHODS_EXPORT_DEFINE(QTreeWidgetWrap)}); QWIDGET_WRAPPED_METHODS_EXPORT_DEFINE(QTreeWidgetWrap)});
constructor = Napi::Persistent(func); constructor = Napi::Persistent(func);
exports.Set(CLASSNAME, func); exports.Set(CLASSNAME, func);
@ -213,12 +215,15 @@ Napi::Value QTreeWidgetWrap::currentItem(const Napi::CallbackInfo& info) {
Napi::HandleScope scope(env); Napi::HandleScope scope(env);
QTreeWidgetItem* currentItem = this->instance->currentItem(); QTreeWidgetItem* currentItem = this->instance->currentItem();
if (currentItem != nullptr) {
Napi::Object value = QTreeWidgetItemWrap::constructor.New(
{Napi::External<QTreeWidgetItem>::New(
env, new QTreeWidgetItem(*currentItem))});
Napi::Object value = QTreeWidgetItemWrap::constructor.New( return value;
{Napi::External<QTreeWidgetItem>::New( } else {
env, new QTreeWidgetItem(*currentItem))}); return env.Null();
}
return value;
} }
Napi::Value QTreeWidgetWrap::findItems(const Napi::CallbackInfo& info) { Napi::Value QTreeWidgetWrap::findItems(const Napi::CallbackInfo& info) {
@ -242,3 +247,29 @@ Napi::Value QTreeWidgetWrap::findItems(const Napi::CallbackInfo& info) {
} }
return napiItems; return napiItems;
} }
Napi::Value QTreeWidgetWrap::takeTopLevelItem(const Napi::CallbackInfo& info) {
Napi::Env env = info.Env();
Napi::HandleScope scope(env);
int index = info[0].As<Napi::Number>().Int32Value();
QTreeWidgetItem* itemRemoved = this->instance->takeTopLevelItem(index);
if (itemRemoved != nullptr) {
Napi::Object value = QTreeWidgetItemWrap::constructor.New(
{Napi::External<QTreeWidgetItem>::New(
env, new QTreeWidgetItem(*itemRemoved))});
return value;
} else {
return env.Null();
}
}
Napi::Value QTreeWidgetWrap::clear(const Napi::CallbackInfo& info) {
Napi::Env env = info.Env();
Napi::HandleScope scope(env);
this->instance->clear();
return env.Null();
}

17
src/demo.ts
View File

@ -1,16 +1,33 @@
import { QMainWindow, QLabel, WidgetEventTypes, QMouseEvent } from './index'; import { QMainWindow, QLabel, WidgetEventTypes, QMouseEvent } from './index';
import { QPoint } from './lib/QtCore/QPoint';
import { ContextMenuPolicy } from './lib/QtEnums';
import { QMenu } from './lib/QtWidgets/QMenu';
import { QAction } from './lib/QtWidgets/QAction';
const win = new QMainWindow(); const win = new QMainWindow();
const label = new QLabel(); const label = new QLabel();
label.setText('Move your mouse here'); label.setText('Move your mouse here');
label.setMouseTracking(true); label.setMouseTracking(true);
label.setContextMenuPolicy(ContextMenuPolicy.CustomContextMenu);
label.addEventListener(WidgetEventTypes.MouseMove, (nativeEvt) => { label.addEventListener(WidgetEventTypes.MouseMove, (nativeEvt) => {
const mouseEvt = new QMouseEvent(nativeEvt as any); const mouseEvt = new QMouseEvent(nativeEvt as any);
console.log('mouseMoved at: ', { x: mouseEvt.x(), y: mouseEvt.y() }); console.log('mouseMoved at: ', { x: mouseEvt.x(), y: mouseEvt.y() });
}); });
label.addEventListener('customContextMenuRequested', (pos: { x: number; y: number }): void => {
console.log(pos);
const position = new QPoint(pos.x, pos.y);
const menu = new QMenu();
const action = new QAction();
action.setText(`Hello World`);
menu.addAction(action);
const ptGlobal = label.mapToGlobal(position);
menu.exec(ptGlobal);
});
win.setCentralWidget(label); win.setCentralWidget(label);
win.show(); win.show();
(global as any).win = win; (global as any).win = win;

3
src/index.ts
View File

@ -22,7 +22,7 @@ export { QMouseEvent } from './lib/QtGui/QEvent/QMouseEvent';
export { WidgetEventTypes } from './lib/core/EventWidget'; export { WidgetEventTypes } from './lib/core/EventWidget';
// Abstract: // Abstract:
export { NodeWidget, QWidget, QWidgetSignals } from './lib/QtWidgets/QWidget'; export { NodeWidget, QWidget, QWidgetSignals } from './lib/QtWidgets/QWidget';
export { NodeLayout, QLayoutSignals } from './lib/QtWidgets/QLayout'; export { NodeLayout, QLayoutSignals, SizeConstraint } from './lib/QtWidgets/QLayout';
export { QAbstractScrollArea } from './lib/QtWidgets/QAbstractScrollArea'; export { QAbstractScrollArea } from './lib/QtWidgets/QAbstractScrollArea';
export { QAbstractSlider, QAbstractSliderSignals } from './lib/QtWidgets/QAbstractSlider'; export { QAbstractSlider, QAbstractSliderSignals } from './lib/QtWidgets/QAbstractSlider';
export { QAbstractButton, QAbstractButtonSignals } from './lib/QtWidgets/QAbstractButton'; export { QAbstractButton, QAbstractButtonSignals } from './lib/QtWidgets/QAbstractButton';
@ -100,6 +100,7 @@ export { QShortcut, QShortcutSignals } from './lib/QtWidgets/QShortcut';
export { QGroupBox, QGroupBoxSignals } from './lib/QtWidgets/QGroupBox'; export { QGroupBox, QGroupBoxSignals } from './lib/QtWidgets/QGroupBox';
export { QStatusBar, QStatusBarSignals } from './lib/QtWidgets/QStatusBar'; export { QStatusBar, QStatusBarSignals } from './lib/QtWidgets/QStatusBar';
export { QStandardItemModel, QStandardItemModelSignals } from './lib/QtWidgets/QStandardItemModel'; export { QStandardItemModel, QStandardItemModelSignals } from './lib/QtWidgets/QStandardItemModel';
export { QStandardItem } from './lib/QtWidgets/QStandardItem';
// Core // Core
export { QDate } from './lib/QtCore/QDate'; export { QDate } from './lib/QtCore/QDate';
export { QDateTime } from './lib/QtCore/QDateTime'; export { QDateTime } from './lib/QtCore/QDateTime';

8
src/lib/QtGui/__tests__/QPixmap.test.ts
View File

@ -57,18 +57,18 @@ describe('QPixmap', () => {
}); });
it('save to a file', async () => { it('save to a file', async () => {
const outputFilePath = path.resolve(__dirname, 'assets', 'nodegui_save.png'); const outputFilePath = path.resolve(__dirname, 'assets', 'nodegui_save.png');
await new Promise(resolve => fs.unlink(outputFilePath, resolve)); await new Promise((resolve) => fs.unlink(outputFilePath, resolve));
const pixmap = new QPixmap(testImagePath); const pixmap = new QPixmap(testImagePath);
pixmap.save(outputFilePath); pixmap.save(outputFilePath);
const exists = await new Promise(resolve => fs.exists(outputFilePath, resolve)); const exists = await new Promise((resolve) => fs.exists(outputFilePath, resolve));
expect(exists).toBe(true); expect(exists).toBe(true);
}); });
it('save to a file of different format', async () => { it('save to a file of different format', async () => {
const outputFilePath = path.resolve(__dirname, 'assets', 'nodegui_save.jpg'); const outputFilePath = path.resolve(__dirname, 'assets', 'nodegui_save.jpg');
await new Promise(resolve => fs.unlink(outputFilePath, resolve)); await new Promise((resolve) => fs.unlink(outputFilePath, resolve));
const pixmap = new QPixmap(testImagePath); const pixmap = new QPixmap(testImagePath);
pixmap.save(outputFilePath, 'JPG'); pixmap.save(outputFilePath, 'JPG');
const exists = await new Promise(resolve => fs.exists(outputFilePath, resolve)); const exists = await new Promise((resolve) => fs.exists(outputFilePath, resolve));
expect(exists).toBe(true); expect(exists).toBe(true);
}); });
}); });

12
src/lib/QtWidgets/QBoxLayout.ts
View File

@ -70,6 +70,12 @@ export class QBoxLayout extends NodeLayout<QBoxLayoutSignals> {
this.native.insertLayout(index, layout.native, stretch); this.native.insertLayout(index, layout.native, stretch);
this.childLayouts.add(layout); this.childLayouts.add(layout);
} }
insertSpacing(index: number, size: number): void {
this.native.insertSpacing(index, size);
}
insertStretch(index: number, stretch = 0): void {
this.native.insertStretch(index, stretch);
}
removeWidget(widget: NodeWidget<any>): void { removeWidget(widget: NodeWidget<any>): void {
this.native.removeWidget(widget.native); this.native.removeWidget(widget.native);
this.nodeChildren.delete(widget); this.nodeChildren.delete(widget);
@ -77,6 +83,12 @@ export class QBoxLayout extends NodeLayout<QBoxLayoutSignals> {
setDirection(dir: Direction): void { setDirection(dir: Direction): void {
this.native.setDirection(dir); this.native.setDirection(dir);
} }
setStretch(index: number, stretch: number): void {
this.native.setStretch(index, stretch);
}
count(): number {
return this.native.count();
}
} }
export type QBoxLayoutSignals = QLayoutSignals; export type QBoxLayoutSignals = QLayoutSignals;

30
src/lib/QtWidgets/QLayout.ts
View File

@ -36,9 +36,30 @@ export abstract class NodeLayout<Signals extends QLayoutSignals> extends NodeObj
type = 'layout'; type = 'layout';
abstract addWidget(childWidget: NodeWidget<any>, ...args: any[]): void; abstract addWidget(childWidget: NodeWidget<any>, ...args: any[]): void;
abstract removeWidget(childWidget: NodeWidget<any>): void; abstract removeWidget(childWidget: NodeWidget<any>): void;
setSizeConstraint(constraint: SizeConstraint): void {
this.setProperty('sizeConstraint', constraint);
}
sizeConstraint(): SizeConstraint {
return this.property('sizeConstraint').toInt();
}
setSpacing(spacing: number): void {
this.setProperty('spacing', spacing);
}
spacing(): number {
return this.property('spacing').toInt();
}
activate(): boolean { activate(): boolean {
return this.native.activate(); return this.native.activate();
} }
setEnabled(enable: boolean): void {
this.native.setEnabled(enable);
}
isEnabled(): boolean {
return this.native.isEnabled();
}
setContentsMargins(left: number, top: number, right: number, bottom: number): void {
this.native.setContentsMargins(left, top, right, bottom);
}
invalidate(): void { invalidate(): void {
this.native.invalidate(); this.native.invalidate();
} }
@ -51,4 +72,13 @@ export abstract class NodeLayout<Signals extends QLayoutSignals> extends NodeObj
// native: any; // native: any;
// } // }
export enum SizeConstraint {
SetDefaultConstraint = 0,
SetNoConstraint = 1,
SetMinimumSize = 2,
SetFixedSize = 3,
SetMaximumSize = 4,
SetMinAndMaxSize = 5,
}
export type QLayoutSignals = QObjectSignals; export type QLayoutSignals = QObjectSignals;

4
src/lib/QtWidgets/QListWidget.ts
View File

@ -81,7 +81,7 @@ export class QListWidget extends NodeListView<QListWidgetSignals> {
} }
findItems(text: string, flags: MatchFlag): QListWidgetItem[] { findItems(text: string, flags: MatchFlag): QListWidgetItem[] {
const nativeItems = this.native.findItems(text, flags); const nativeItems = this.native.findItems(text, flags);
return nativeItems.map(function(item: QListWidgetItem) { return nativeItems.map(function (item: QListWidgetItem) {
return new QListWidgetItem(item); return new QListWidgetItem(item);
}); });
} }
@ -115,7 +115,7 @@ export class QListWidget extends NodeListView<QListWidgetSignals> {
} }
selectedItems(): QListWidgetItem[] { selectedItems(): QListWidgetItem[] {
const nativeItems = this.native.selectedItems(); const nativeItems = this.native.selectedItems();
return nativeItems.map(function(item: QListWidgetItem) { return nativeItems.map(function (item: QListWidgetItem) {
return new QListWidgetItem(item); return new QListWidgetItem(item);
}); });
} }

9
src/lib/QtWidgets/QMenu.ts
View File

@ -36,16 +36,17 @@ export class QMenu extends NodeWidget<QMenuSignals> {
setTitle(title: string): void { setTitle(title: string): void {
this.native.setTitle(title); this.native.setTitle(title);
} }
addSeparator(): QAction { addSeparator(): QAction {
return this.native.addSeparator(); return this.native.addSeparator();
} }
exec(point?: QPoint, action?: QAction): void { exec(point?: QPoint, action?: QAction | null): void {
if (point && action) { if (point && action) {
this.native.exec(point.native, action.native); this.native.exec(point.native, action.native);
return; } else if (point) {
this.native.exec(point.native);
} else {
this.native.exec();
} }
this.native.exec();
} }
popup(point: QPoint, action?: QAction): void { popup(point: QPoint, action?: QAction): void {
this.native.popup(point.native, action?.native); this.native.popup(point.native, action?.native);

2
src/lib/QtWidgets/QPainter.ts
View File

@ -94,7 +94,7 @@ export class QPainter extends Component {
} }
drawConvexPolygon(points: QPoint[]): void { drawConvexPolygon(points: QPoint[]): void {
const nativePoints = points.map(point => point.native); const nativePoints = points.map((point) => point.native);
this.native.drawConvexPolygon(nativePoints); this.native.drawConvexPolygon(nativePoints);
} }

31
src/lib/QtWidgets/QTreeWidget.ts
View File

@ -75,7 +75,7 @@ export class QTreeWidget extends QAbstractScrollArea<QTreeWidgetSignals> {
addTopLevelItems(items: QTreeWidgetItem[]): void { addTopLevelItems(items: QTreeWidgetItem[]): void {
const napiItems: NativeElement[] = []; const napiItems: NativeElement[] = [];
items.forEach(item => { items.forEach((item) => {
this.topLevelItems.add(item); this.topLevelItems.add(item);
napiItems.push(item.native); napiItems.push(item.native);
}); });
@ -89,7 +89,7 @@ export class QTreeWidget extends QAbstractScrollArea<QTreeWidgetSignals> {
insertTopLevelItems(index: number, items: QTreeWidgetItem[]): void { insertTopLevelItems(index: number, items: QTreeWidgetItem[]): void {
const napiItems: NativeElement[] = []; const napiItems: NativeElement[] = [];
items.forEach(item => { items.forEach((item) => {
this.topLevelItems.add(item); this.topLevelItems.add(item);
napiItems.push(item.native); napiItems.push(item.native);
}); });
@ -102,7 +102,7 @@ export class QTreeWidget extends QAbstractScrollArea<QTreeWidgetSignals> {
selectedItems(): QTreeWidgetItem[] { selectedItems(): QTreeWidgetItem[] {
const nativeItems = this.native.selectedItems(); const nativeItems = this.native.selectedItems();
return nativeItems.map(function(eachItem: QTreeWidgetItem) { return nativeItems.map(function (eachItem: QTreeWidgetItem) {
return new QTreeWidgetItem(eachItem); return new QTreeWidgetItem(eachItem);
}); });
} }
@ -145,8 +145,13 @@ export class QTreeWidget extends QAbstractScrollArea<QTreeWidgetSignals> {
/** /**
* Returns the current item in the tree widget. * Returns the current item in the tree widget.
*/ */
currentItem(): QTreeWidgetItem { currentItem(): QTreeWidgetItem | void {
return new QTreeWidgetItem(this.native.currentItem()); const item = this.native.currentItem();
if (item) {
return new QTreeWidgetItem(item);
} else {
return undefined;
}
} }
/** /**
@ -159,10 +164,24 @@ export class QTreeWidget extends QAbstractScrollArea<QTreeWidgetSignals> {
findItems(text: string, flags: MatchFlag, column: number): QTreeWidgetItem[] { findItems(text: string, flags: MatchFlag, column: number): QTreeWidgetItem[] {
const nativeItems = this.native.findItems(text, flags, column); const nativeItems = this.native.findItems(text, flags, column);
return nativeItems.map(function(eachItem: QTreeWidgetItem) { return nativeItems.map(function (eachItem: QTreeWidgetItem) {
return new QTreeWidgetItem(eachItem); return new QTreeWidgetItem(eachItem);
}); });
} }
takeTopLevelItem(index: number): QTreeWidgetItem | void {
const item = this.native.takeTopLevelItem(index);
if (item) {
return new QTreeWidgetItem(item);
} else {
return undefined;
}
}
clear(): void {
this.topLevelItems.clear();
this.native.clear();
}
} }
export interface QTreeWidgetSignals extends QAbstractScrollAreaSignals { export interface QTreeWidgetSignals extends QAbstractScrollAreaSignals {

13
src/lib/QtWidgets/QWidget.ts
View File

@ -9,6 +9,7 @@ import { CursorShape, WindowState } from '../QtEnums';
import { StyleSheet, prepareInlineStyleSheet } from '../core/Style/StyleSheet'; import { StyleSheet, prepareInlineStyleSheet } from '../core/Style/StyleSheet';
import { checkIfNativeElement } from '../utils/helpers'; import { checkIfNativeElement } from '../utils/helpers';
import { YogaWidget } from '../core/YogaWidget'; import { YogaWidget } from '../core/YogaWidget';
import { QPoint } from '../QtCore/QPoint';
import { QSize } from '../QtCore/QSize'; import { QSize } from '../QtCore/QSize';
import { QRect } from '../QtCore/QRect'; import { QRect } from '../QtCore/QRect';
import { QObjectSignals } from '../QtCore/QObject'; import { QObjectSignals } from '../QtCore/QObject';
@ -73,6 +74,18 @@ export abstract class NodeWidget<Signals extends QWidgetSignals> extends YogaWid
close(): boolean { close(): boolean {
return this.native.close(); return this.native.close();
} }
mapFromGlobal(pos: QPoint): QPoint {
return new QPoint(this.native.mapFromGlobal(pos.native));
}
mapFromParent(pos: QPoint): QPoint {
return new QPoint(this.native.mapFromParent(pos.native));
}
mapToGlobal(pos: QPoint): QPoint {
return new QPoint(this.native.mapToGlobal(pos.native));
}
mapToParent(pos: QPoint): QPoint {
return new QPoint(this.native.mapToParent(pos.native));
}
setStyleSheet(styleSheet: string): void { setStyleSheet(styleSheet: string): void {
const preparedSheet = StyleSheet.create(styleSheet); const preparedSheet = StyleSheet.create(styleSheet);
this.native.setStyleSheet(preparedSheet); this.native.setStyleSheet(preparedSheet);