Add QPicture and other improvements (#399)

2020-02-18 03:45:57 +08:00 · 2020-02-18 03:45:57 +08:00 · ab6c28166e
commit ab6c28166e
parent d6d19ad3cf
26 changed files with 596 additions and 377 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -42,6 +42,7 @@ add_library(${CORE_WIDGETS_ADDON} SHARED
    "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtGui/QEvent/QKeyEvent/qkeyevent_wrap.cpp"
    "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtGui/QEvent/QMouseEvent/qmouseevent_wrap.cpp"
    "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtGui/QFontDatabase/qfontdatabase_wrap.cpp"
+    "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtGui/QPicture/qpicture_wrap.cpp"
    "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtGui/QPixmap/qpixmap_wrap.cpp"
    "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtGui/QIcon/qicon_wrap.cpp"
    "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtGui/QFont/qfont_wrap.cpp"
--- a/src/cpp/include/nodegui/QtGui/QPicture/qpicture_wrap.h
+++ b/src/cpp/include/nodegui/QtGui/QPicture/qpicture_wrap.h
@ -0,0 +1,29 @@
+#pragma once
+
+#include <napi.h>
+
+#include <QPicture>
+
+#include "Extras/Utils/nutils.h"
+#include "core/Component/component_macro.h"
+
+class DLL_EXPORT QPictureWrap : public Napi::ObjectWrap<QPictureWrap> {
+  COMPONENT_WRAPPED_METHODS_DECLARATION
+
+ private:
+  std::unique_ptr<QPicture> instance;
+
+ public:
+  static Napi::FunctionReference constructor;
+  static Napi::Object init(Napi::Env env, Napi::Object exports);
+  QPictureWrap(const Napi::CallbackInfo& info);
+  ~QPictureWrap();
+  QPicture* getInternalInstance();
+  // Wrapped methods
+  Napi::Value setBoundingRect(const Napi::CallbackInfo& info);
+  Napi::Value boundingRect(const Napi::CallbackInfo& info);
+  Napi::Value isNull(const Napi::CallbackInfo& info);
+  Napi::Value load(const Napi::CallbackInfo& info);
+  Napi::Value save(const Napi::CallbackInfo& info);
+  Napi::Value size(const Napi::CallbackInfo& info);
+};
--- a/src/cpp/include/nodegui/QtWidgets/QLabel/nlabel.hpp
+++ b/src/cpp/include/nodegui/QtWidgets/QLabel/nlabel.hpp
@ -1,4 +1,5 @@
 #pragma once
+
 #include <QLabel>

 #include "Extras/Utils/nutils.h"
@ -13,13 +14,13 @@ class DLL_EXPORT NLabel : public QLabel, public NodeWidget {

  void connectSignalsToEventEmitter() {
    QWIDGET_SIGNALS
-    QObject::connect(this, &QLabel::linkActivated, [=](const QString &link) {
+    QObject::connect(this, &QLabel::linkActivated, [=](const QString& link) {
      Napi::Env env = this->emitOnNode.Env();
      Napi::HandleScope scope(env);
      this->emitOnNode.Call({Napi::String::New(env, "linkActivated"),
                             Napi::String::New(env, link.toStdString())});
    });
-    QObject::connect(this, &QLabel::linkHovered, [=](const QString &link) {
+    QObject::connect(this, &QLabel::linkHovered, [=](const QString& link) {
      Napi::Env env = this->emitOnNode.Env();
      Napi::HandleScope scope(env);
      this->emitOnNode.Call({Napi::String::New(env, "linkHovered"),
--- a/src/cpp/include/nodegui/QtWidgets/QLabel/qlabel_wrap.h
+++ b/src/cpp/include/nodegui/QtWidgets/QLabel/qlabel_wrap.h
@ -21,21 +21,13 @@ class DLL_EXPORT QLabelWrap : public Napi::ObjectWrap<QLabelWrap> {
  // class constructor
  static Napi::FunctionReference constructor;
  // wrapped methods
-  Napi::Value setAlignment(const Napi::CallbackInfo& info);
-  Napi::Value alignment(const Napi::CallbackInfo& info);
-  Napi::Value setIndent(const Napi::CallbackInfo& info);
-  Napi::Value indent(const Napi::CallbackInfo& info);
-  Napi::Value setMargin(const Napi::CallbackInfo& info);
-  Napi::Value margin(const Napi::CallbackInfo& info);
-  Napi::Value setTextFormat(const Napi::CallbackInfo& info);
-  Napi::Value textFormat(const Napi::CallbackInfo& info);
-  Napi::Value setWordWrap(const Napi::CallbackInfo& info);
-  Napi::Value wordWrap(const Napi::CallbackInfo& info);
-  Napi::Value setText(const Napi::CallbackInfo& info);
-  Napi::Value text(const Napi::CallbackInfo& info);
-  Napi::Value setPixmap(const Napi::CallbackInfo& info);
-  Napi::Value setMovie(const Napi::CallbackInfo& info);
-  Napi::Value setOpenExternalLinks(const Napi::CallbackInfo& info);
-  Napi::Value openExternalLinks(const Napi::CallbackInfo& info);
+  Napi::Value setSelection(const Napi::CallbackInfo& info);
+  Napi::Value selectionStart(const Napi::CallbackInfo& info);
+  Napi::Value setBuddy(const Napi::CallbackInfo& info);
  Napi::Value clear(const Napi::CallbackInfo& info);
+  Napi::Value setMovie(const Napi::CallbackInfo& info);
+  Napi::Value setNumDouble(const Napi::CallbackInfo& info);
+  Napi::Value setNumInt(const Napi::CallbackInfo& info);
+  Napi::Value setPicture(const Napi::CallbackInfo& info);
+  Napi::Value setPixmap(const Napi::CallbackInfo& info);
 };
--- a/src/cpp/include/nodegui/QtWidgets/QProgressBar/nprogressbar.hpp
+++ b/src/cpp/include/nodegui/QtWidgets/QProgressBar/nprogressbar.hpp
@ -1,4 +1,5 @@
 #pragma once
+
 #include <QProgressBar>

 #include "Extras/Utils/nutils.h"
@ -7,9 +8,10 @@

 class DLL_EXPORT NProgressBar : public QProgressBar, public NodeWidget {
  Q_OBJECT
- public:
  NODEWIDGET_IMPLEMENTATIONS(QProgressBar)
+ public:
  using QProgressBar::QProgressBar;  // inherit all constructors of QProgressBar
+
  void connectSignalsToEventEmitter() {
    QWIDGET_SIGNALS
    // Qt Connects: Implement all signal connects here
@ -17,7 +19,7 @@ class DLL_EXPORT NProgressBar : public QProgressBar, public NodeWidget {
      Napi::Env env = this->emitOnNode.Env();
      Napi::HandleScope scope(env);
      this->emitOnNode.Call({Napi::String::New(env, "valueChanged"),
-                             Napi::Value::From(env, value)});
+                             Napi::Number::New(env, value)});
    });
  }
 };
--- a/src/cpp/include/nodegui/QtWidgets/QProgressBar/qprogressbar_wrap.h
+++ b/src/cpp/include/nodegui/QtWidgets/QProgressBar/qprogressbar_wrap.h
@ -21,9 +21,7 @@ class DLL_EXPORT QProgressBarWrap : public Napi::ObjectWrap<QProgressBarWrap> {
  // class constructor
  static Napi::FunctionReference constructor;
  // wrapped methods
-  Napi::Value setValue(const Napi::CallbackInfo& info);
-  Napi::Value setMaximum(const Napi::CallbackInfo& info);
-  Napi::Value setMinimum(const Napi::CallbackInfo& info);
-  Napi::Value setOrientation(const Napi::CallbackInfo& info);
-  Napi::Value value(const Napi::CallbackInfo& info);
+  Napi::Value resetFormat(const Napi::CallbackInfo& info);
+  Napi::Value reset(const Napi::CallbackInfo& info);
+  Napi::Value setRange(const Napi::CallbackInfo& info);
 };
--- a/src/cpp/include/nodegui/QtWidgets/QPushButton/npushbutton.hpp
+++ b/src/cpp/include/nodegui/QtWidgets/QPushButton/npushbutton.hpp
@ -1,4 +1,5 @@
 #pragma once
+
 #include <QPushButton>

 #include "Extras/Utils/nutils.h"
--- a/src/cpp/include/nodegui/QtWidgets/QPushButton/qpushbutton_wrap.h
+++ b/src/cpp/include/nodegui/QtWidgets/QPushButton/qpushbutton_wrap.h
@ -8,6 +8,7 @@
 #include "QtWidgets/QAbstractButton/qabstractbutton_macro.h"
 #include "QtWidgets/QWidget/qwidget_macro.h"
 #include "npushbutton.hpp"
+
 class DLL_EXPORT QPushButtonWrap : public Napi::ObjectWrap<QPushButtonWrap> {
  QABSTRACTBUTTON_WRAPPED_METHODS_DECLARATION
 private:
@ -16,11 +17,12 @@ class DLL_EXPORT QPushButtonWrap : public Napi::ObjectWrap<QPushButtonWrap> {

 public:
  static Napi::Object init(Napi::Env env, Napi::Object exports);
-  QPushButtonWrap(const Napi::CallbackInfo &info);
+  QPushButtonWrap(const Napi::CallbackInfo& info);
  ~QPushButtonWrap();
-  NPushButton *getInternalInstance();
+  NPushButton* getInternalInstance();
  // class constructor
  static Napi::FunctionReference constructor;
  // wrapped methods
-  Napi::Value setFlat(const Napi::CallbackInfo &info);
+  Napi::Value setMenu(const Napi::CallbackInfo& info);
+  Napi::Value showMenu(const Napi::CallbackInfo& info);
 };
--- a/src/cpp/include/nodegui/QtWidgets/QScrollArea/nscrollarea.hpp
+++ b/src/cpp/include/nodegui/QtWidgets/QScrollArea/nscrollarea.hpp
@ -1,4 +1,5 @@
 #pragma once
+
 #include <QScrollArea>

 #include "Extras/Utils/nutils.h"
@ -10,5 +11,6 @@ class DLL_EXPORT NScrollArea : public QScrollArea, public NodeWidget {
  NODEWIDGET_IMPLEMENTATIONS(QScrollArea)
 public:
  using QScrollArea::QScrollArea;  // inherit all constructors of QScrollArea
+
  void connectSignalsToEventEmitter() { QABSTRACTSCROLLAREA_SIGNALS }
 };
--- a/src/cpp/include/nodegui/QtWidgets/QScrollArea/qscrollarea_wrap.h
+++ b/src/cpp/include/nodegui/QtWidgets/QScrollArea/qscrollarea_wrap.h
@ -16,14 +16,14 @@ class DLL_EXPORT QScrollAreaWrap : public Napi::ObjectWrap<QScrollAreaWrap> {

 public:
  static Napi::Object init(Napi::Env env, Napi::Object exports);
-  QScrollAreaWrap(const Napi::CallbackInfo &info);
+  QScrollAreaWrap(const Napi::CallbackInfo& info);
  ~QScrollAreaWrap();
-  NScrollArea *getInternalInstance();
+  NScrollArea* getInternalInstance();
  // class constructor
  static Napi::FunctionReference constructor;
  // wrapped methods
-  Napi::Value setWidget(const Napi::CallbackInfo &info);
-  Napi::Value takeWidget(const Napi::CallbackInfo &info);
-  Napi::Value setWidgetResizable(const Napi::CallbackInfo &info);
-  Napi::Value widgetResizable(const Napi::CallbackInfo &info);
+  Napi::Value ensureVisible(const Napi::CallbackInfo& info);
+  Napi::Value ensureWidgetVisible(const Napi::CallbackInfo& info);
+  Napi::Value setWidget(const Napi::CallbackInfo& info);
+  Napi::Value takeWidget(const Napi::CallbackInfo& info);
 };
--- a/src/cpp/include/nodegui/QtWidgets/QToolButton/ntoolbutton.hpp
+++ b/src/cpp/include/nodegui/QtWidgets/QToolButton/ntoolbutton.hpp
@ -1,4 +1,5 @@
 #pragma once
+
 #include <QAction>
 #include <QToolButton>

@ -17,7 +18,7 @@ class DLL_EXPORT NToolButton : public QToolButton, public NodeWidget {
  void connectSignalsToEventEmitter() {
    // Qt Connects: Implement all signal connects here
    QABSTRACT_BUTTON_SIGNALS
-    QObject::connect(this, &QToolButton::triggered, [=](QAction *action) {
+    QObject::connect(this, &QToolButton::triggered, [=](QAction* action) {
      Napi::Env env = this->emitOnNode.Env();
      Napi::HandleScope scope(env);

--- a/src/cpp/include/nodegui/QtWidgets/QToolButton/qtoolbutton_wrap.h
+++ b/src/cpp/include/nodegui/QtWidgets/QToolButton/qtoolbutton_wrap.h
@ -17,21 +17,13 @@ class DLL_EXPORT QToolButtonWrap : public Napi::ObjectWrap<QToolButtonWrap> {

 public:
  static Napi::Object init(Napi::Env env, Napi::Object exports);
-  QToolButtonWrap(const Napi::CallbackInfo &info);
+  QToolButtonWrap(const Napi::CallbackInfo& info);
  ~QToolButtonWrap();
-  NToolButton *getInternalInstance();
+  NToolButton* getInternalInstance();
  // class constructor
  static Napi::FunctionReference constructor;
  // wrapped methods
-  Napi::Value setArrowType(const Napi::CallbackInfo &info);
-  Napi::Value arrowType(const Napi::CallbackInfo &info);
-  Napi::Value setAutoRaise(const Napi::CallbackInfo &info);
-  Napi::Value autoRaise(const Napi::CallbackInfo &info);
-  Napi::Value setPopupMode(const Napi::CallbackInfo &info);
-  Napi::Value popupMode(const Napi::CallbackInfo &info);
-  Napi::Value setToolButtonStyle(const Napi::CallbackInfo &info);
-  Napi::Value toolButtonStyle(const Napi::CallbackInfo &info);
-  Napi::Value setMenu(const Napi::CallbackInfo &info);
-  Napi::Value setDefaultAction(const Napi::CallbackInfo &info);
-  Napi::Value showMenu(const Napi::CallbackInfo &info);
+  Napi::Value setMenu(const Napi::CallbackInfo& info);
+  Napi::Value setDefaultAction(const Napi::CallbackInfo& info);
+  Napi::Value showMenu(const Napi::CallbackInfo& info);
 };
--- a/src/cpp/lib/QtGui/QPicture/qpicture_wrap.cpp
+++ b/src/cpp/lib/QtGui/QPicture/qpicture_wrap.cpp
@ -0,0 +1,105 @@
+#include "QtGui/QPicture/qpicture_wrap.h"
+
+#include "Extras/Utils/nutils.h"
+#include "QtCore/QRect/qrect_wrap.h"
+#include "QtCore/QVariant/qvariant_wrap.h"
+
+Napi::FunctionReference QPictureWrap::constructor;
+
+Napi::Object QPictureWrap::init(Napi::Env env, Napi::Object exports) {
+  Napi::HandleScope scope(env);
+  char CLASSNAME[] = "QPicture";
+  Napi::Function func = DefineClass(
+      env, CLASSNAME,
+      {InstanceMethod("setBoundingRect", &QPictureWrap::setBoundingRect),
+       InstanceMethod("boundingRect", &QPictureWrap::boundingRect),
+       InstanceMethod("isNull", &QPictureWrap::isNull),
+       InstanceMethod("load", &QPictureWrap::load),
+       InstanceMethod("save", &QPictureWrap::save),
+       InstanceMethod("size", &QPictureWrap::size),
+       COMPONENT_WRAPPED_METHODS_EXPORT_DEFINE(QPictureWrap)});
+  constructor = Napi::Persistent(func);
+  exports.Set(CLASSNAME, func);
+  return exports;
+}
+
+QPictureWrap::QPictureWrap(const Napi::CallbackInfo& info)
+    : Napi::ObjectWrap<QPictureWrap>(info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+
+  if (info.Length() > 0 && info[0].IsExternal()) {
+    // --- if external ---
+    this->instance = std::unique_ptr<QPicture>(
+        info[0].As<Napi::External<QPicture>>().Data());
+  } else {
+    // --- regular cases ---
+    if (info.Length() == 1) {
+      int formatVersion = info[0].As<Napi::Number>().Int32Value();
+      this->instance = std::make_unique<QPicture>(formatVersion);
+    } else if (info.Length() == 0) {
+      this->instance = std::make_unique<QPicture>();
+    } else {
+      Napi::TypeError::New(env, "Wrong number of arguments")
+          .ThrowAsJavaScriptException();
+    }
+  }
+  this->rawData = extrautils::configureComponent(this->getInternalInstance());
+}
+
+QPicture* QPictureWrap::getInternalInstance() { return this->instance.get(); }
+
+QPictureWrap::~QPictureWrap() { this->instance.reset(); }
+
+Napi::Value QPictureWrap::setBoundingRect(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+
+  Napi::Object boundingRectObject = info[0].As<Napi::Object>();
+  QRectWrap* boundingRectWrap =
+      Napi::ObjectWrap<QRectWrap>::Unwrap(boundingRectObject);
+  this->instance->setBoundingRect(*boundingRectWrap->getInternalInstance());
+  return env.Null();
+}
+
+Napi::Value QPictureWrap::boundingRect(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+
+  QRect rect = this->instance->boundingRect();
+  auto instance = QRectWrap::constructor.New(
+      {Napi::External<QRect>::New(env, new QRect(rect))});
+  return instance;
+}
+
+Napi::Value QPictureWrap::isNull(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+
+  return Napi::Boolean::New(env, this->instance->isNull());
+}
+
+Napi::Value QPictureWrap::load(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+
+  std::string fileName = info[0].As<Napi::String>().Utf8Value();
+  bool success = this->instance->load(QString::fromUtf8(fileName.c_str()));
+  return Napi::Boolean::New(env, success);
+}
+
+Napi::Value QPictureWrap::save(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+
+  std::string fileName = info[0].As<Napi::String>().Utf8Value();
+  bool success = this->instance->save(QString::fromUtf8(fileName.c_str()));
+  return Napi::Boolean::New(env, success);
+}
+
+Napi::Value QPictureWrap::size(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+
+  return Napi::Number::New(env, this->instance->size());
+}
--- a/src/cpp/lib/QtWidgets/QLabel/qlabel_wrap.cpp
+++ b/src/cpp/lib/QtWidgets/QLabel/qlabel_wrap.cpp
@ -4,8 +4,10 @@

 #include "Extras/Utils/nutils.h"
 #include "QtGui/QMovie/qmovie_wrap.h"
+#include "QtGui/QPicture/qpicture_wrap.h"
 #include "QtGui/QPixmap/qpixmap_wrap.h"
 #include "QtWidgets/QWidget/qwidget_wrap.h"
+
 Napi::FunctionReference QLabelWrap::constructor;

 Napi::Object QLabelWrap::init(Napi::Env env, Napi::Object exports) {
@ -13,24 +15,15 @@ Napi::Object QLabelWrap::init(Napi::Env env, Napi::Object exports) {
  char CLASSNAME[] = "QLabel";
  Napi::Function func = DefineClass(
      env, CLASSNAME,
-      {InstanceMethod("setAlignment", &QLabelWrap::setAlignment),
-       InstanceMethod("alignment", &QLabelWrap::alignment),
-       InstanceMethod("setIndent", &QLabelWrap::setIndent),
-       InstanceMethod("indent", &QLabelWrap::indent),
-       InstanceMethod("setMargin", &QLabelWrap::setMargin),
-       InstanceMethod("margin", &QLabelWrap::margin),
-       InstanceMethod("setTextFormat", &QLabelWrap::setTextFormat),
-       InstanceMethod("textFormat", &QLabelWrap::textFormat),
-       InstanceMethod("setWordWrap", &QLabelWrap::setWordWrap),
-       InstanceMethod("wordWrap", &QLabelWrap::wordWrap),
-       InstanceMethod("setText", &QLabelWrap::setText),
-       InstanceMethod("text", &QLabelWrap::text),
-       InstanceMethod("setPixmap", &QLabelWrap::setPixmap),
-       InstanceMethod("setMovie", &QLabelWrap::setMovie),
-       InstanceMethod("setOpenExternalLinks",
-                      &QLabelWrap::setOpenExternalLinks),
-       InstanceMethod("openExternalLinks", &QLabelWrap::openExternalLinks),
+      {InstanceMethod("setSelection", &QLabelWrap::setSelection),
+       InstanceMethod("selectionStart", &QLabelWrap::selectionStart),
+       InstanceMethod("setBuddy", &QLabelWrap::setBuddy),
       InstanceMethod("clear", &QLabelWrap::clear),
+       InstanceMethod("setMovie", &QLabelWrap::setMovie),
+       InstanceMethod("setNumDouble", &QLabelWrap::setNumDouble),
+       InstanceMethod("setNumInt", &QLabelWrap::setNumInt),
+       InstanceMethod("setPicture", &QLabelWrap::setPicture),
+       InstanceMethod("setPixmap", &QLabelWrap::setPixmap),
       QWIDGET_WRAPPED_METHODS_EXPORT_DEFINE(QLabelWrap)});
  constructor = Napi::Persistent(func);
  exports.Set(CLASSNAME, func);
@ -63,115 +56,38 @@ QLabelWrap::QLabelWrap(const Napi::CallbackInfo& info)
      extrautils::configureQWidget(this->getInternalInstance(), flexNode, true);
 }

-Napi::Value QLabelWrap::setAlignment(const Napi::CallbackInfo& info) {
+Napi::Value QLabelWrap::setSelection(const Napi::CallbackInfo& info) {
  Napi::Env env = info.Env();
  Napi::HandleScope scope(env);

-  int alignment = info[0].As<Napi::Number>().Int32Value();
-  this->instance->setAlignment(static_cast<Qt::Alignment>(alignment));
+  int start = info[0].As<Napi::Number>().Int32Value();
+  int length = info[1].As<Napi::Number>().Int32Value();
+  this->instance->setSelection(start, length);
  return env.Null();
 }

-Napi::Value QLabelWrap::alignment(const Napi::CallbackInfo& info) {
+Napi::Value QLabelWrap::selectionStart(const Napi::CallbackInfo& info) {
  Napi::Env env = info.Env();
  Napi::HandleScope scope(env);

-  int alignment = static_cast<int>(this->instance->alignment());
-  return Napi::Value::From(env, alignment);
+  return Napi::Number::New(env, this->instance->selectionStart());
 }

-Napi::Value QLabelWrap::setIndent(const Napi::CallbackInfo& info) {
+Napi::Value QLabelWrap::setBuddy(const Napi::CallbackInfo& info) {
  Napi::Env env = info.Env();
  Napi::HandleScope scope(env);

-  int indent = info[0].As<Napi::Number>().Int32Value();
-  this->instance->setIndent(indent);
+  Napi::Object buddyObject = info[0].As<Napi::Object>();
+  QWidgetWrap* buddyWrap = Napi::ObjectWrap<QWidgetWrap>::Unwrap(buddyObject);
+  this->instance->setBuddy(buddyWrap->getInternalInstance());
  return env.Null();
 }

-Napi::Value QLabelWrap::indent(const Napi::CallbackInfo& info) {
+Napi::Value QLabelWrap::clear(const Napi::CallbackInfo& info) {
  Napi::Env env = info.Env();
  Napi::HandleScope scope(env);

-  return Napi::Value::From(env, this->instance->indent());
-}
-
-Napi::Value QLabelWrap::setMargin(const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  Napi::HandleScope scope(env);
-
-  int margin = info[0].As<Napi::Number>().Int32Value();
-  this->instance->setMargin(margin);
-  return env.Null();
-}
-
-Napi::Value QLabelWrap::margin(const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  Napi::HandleScope scope(env);
-
-  return Napi::Value::From(env, this->instance->margin());
-}
-
-Napi::Value QLabelWrap::setTextFormat(const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  Napi::HandleScope scope(env);
-
-  int format = info[0].As<Napi::Number>().Int32Value();
-  this->instance->setTextFormat(static_cast<Qt::TextFormat>(format));
-  return env.Null();
-}
-
-Napi::Value QLabelWrap::textFormat(const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  Napi::HandleScope scope(env);
-
-  int format = static_cast<int>(this->instance->textFormat());
-  return Napi::Value::From(env, format);
-}
-
-Napi::Value QLabelWrap::setWordWrap(const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  Napi::HandleScope scope(env);
-
-  Napi::Boolean On = info[0].As<Napi::Boolean>();
-  this->instance->setWordWrap(On);
-
-  return env.Null();
-}
-
-Napi::Value QLabelWrap::wordWrap(const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  Napi::HandleScope scope(env);
-  bool isWordWrap = this->instance->wordWrap();
-  return Napi::Value::From(env, isWordWrap);
-}
-
-Napi::Value QLabelWrap::setText(const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  Napi::HandleScope scope(env);
-
-  Napi::String text = info[0].As<Napi::String>();
-  std::string label = text.Utf8Value();
-  this->instance->setText(QString::fromUtf8(label.c_str()));
-
-  return env.Null();
-}
-
-Napi::Value QLabelWrap::text(const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  Napi::HandleScope scope(env);
-
-  std::string labelText = this->instance->text().toStdString();
-  return Napi::String::New(env, labelText);
-}
-
-Napi::Value QLabelWrap::setPixmap(const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  Napi::HandleScope scope(env);
-
-  Napi::Object pixmapObject = info[0].As<Napi::Object>();
-  QPixmapWrap* pixmapWrap = Napi::ObjectWrap<QPixmapWrap>::Unwrap(pixmapObject);
-  this->instance->setPixmap(*pixmapWrap->getInternalInstance());
+  this->instance->clear();
  return env.Null();
 }

@ -185,25 +101,41 @@ Napi::Value QLabelWrap::setMovie(const Napi::CallbackInfo& info) {
  return env.Null();
 }

-Napi::Value QLabelWrap::setOpenExternalLinks(const Napi::CallbackInfo& info) {
+Napi::Value QLabelWrap::setNumDouble(const Napi::CallbackInfo& info) {
  Napi::Env env = info.Env();
  Napi::HandleScope scope(env);
-  Napi::Boolean open = info[0].As<Napi::Boolean>();
-  this->instance->setOpenExternalLinks(open.Value());
+
+  double num = info[0].As<Napi::Number>().DoubleValue();
+  this->instance->setNum(num);
  return env.Null();
 }

-Napi::Value QLabelWrap::openExternalLinks(const Napi::CallbackInfo& info) {
+Napi::Value QLabelWrap::setNumInt(const Napi::CallbackInfo& info) {
  Napi::Env env = info.Env();
  Napi::HandleScope scope(env);

-  return Napi::Value::From(env, this->instance->openExternalLinks());
+  int num = info[0].As<Napi::Number>().Int32Value();
+  this->instance->setNum(num);
+  return env.Null();
 }

-Napi::Value QLabelWrap::clear(const Napi::CallbackInfo& info) {
+Napi::Value QLabelWrap::setPicture(const Napi::CallbackInfo& info) {
  Napi::Env env = info.Env();
  Napi::HandleScope scope(env);

-  this->instance->clear();
+  Napi::Object pictureObject = info[0].As<Napi::Object>();
+  QPictureWrap* pictureWrap =
+      Napi::ObjectWrap<QPictureWrap>::Unwrap(pictureObject);
+  this->instance->setPicture(*pictureWrap->getInternalInstance());
  return env.Null();
-}
+}
+
+Napi::Value QLabelWrap::setPixmap(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+
+  Napi::Object pixmapObject = info[0].As<Napi::Object>();
+  QPixmapWrap* pixmapWrap = Napi::ObjectWrap<QPixmapWrap>::Unwrap(pixmapObject);
+  this->instance->setPixmap(*pixmapWrap->getInternalInstance());
+  return env.Null();
+}
--- a/src/cpp/lib/QtWidgets/QProgressBar/qprogressbar_wrap.cpp
+++ b/src/cpp/lib/QtWidgets/QProgressBar/qprogressbar_wrap.cpp
@ -1,4 +1,3 @@
-
 #include "QtWidgets/QProgressBar/qprogressbar_wrap.h"

 #include <QWidget>
@ -13,11 +12,9 @@ Napi::Object QProgressBarWrap::init(Napi::Env env, Napi::Object exports) {
  char CLASSNAME[] = "QProgressBar";
  Napi::Function func = DefineClass(
      env, CLASSNAME,
-      {InstanceMethod("setValue", &QProgressBarWrap::setValue),
-       InstanceMethod("setMaximum", &QProgressBarWrap::setMaximum),
-       InstanceMethod("setMinimum", &QProgressBarWrap::setMinimum),
-       InstanceMethod("setOrientation", &QProgressBarWrap::setOrientation),
-       InstanceMethod("value", &QProgressBarWrap::value),
+      {InstanceMethod("resetFormat", &QProgressBarWrap::resetFormat),
+       InstanceMethod("reset", &QProgressBarWrap::reset),
+       InstanceMethod("setRange", &QProgressBarWrap::setRange),
       QWIDGET_WRAPPED_METHODS_EXPORT_DEFINE(QProgressBarWrap)});
  constructor = Napi::Persistent(func);
  exports.Set(CLASSNAME, func);
@ -26,6 +23,10 @@ Napi::Object QProgressBarWrap::init(Napi::Env env, Napi::Object exports) {

 NProgressBar* QProgressBarWrap::getInternalInstance() { return this->instance; }

+QProgressBarWrap::~QProgressBarWrap() {
+  extrautils::safeDelete(this->instance);
+}
+
 QProgressBarWrap::QProgressBarWrap(const Napi::CallbackInfo& info)
    : Napi::ObjectWrap<QProgressBarWrap>(info) {
  Napi::Env env = info.Env();
@ -47,46 +48,28 @@ QProgressBarWrap::QProgressBarWrap(const Napi::CallbackInfo& info)
      true);
 }

-QProgressBarWrap::~QProgressBarWrap() {
-  extrautils::safeDelete(this->instance);
-}
-
-Napi::Value QProgressBarWrap::setValue(const Napi::CallbackInfo& info) {
+Napi::Value QProgressBarWrap::resetFormat(const Napi::CallbackInfo& info) {
  Napi::Env env = info.Env();
  Napi::HandleScope scope(env);
-  Napi::Number value = info[0].As<Napi::Number>();
-  this->instance->setValue(value.Int32Value());
+
+  this->instance->resetFormat();
  return env.Null();
 }

-Napi::Value QProgressBarWrap::setMaximum(const Napi::CallbackInfo& info) {
+Napi::Value QProgressBarWrap::reset(const Napi::CallbackInfo& info) {
  Napi::Env env = info.Env();
  Napi::HandleScope scope(env);
-  Napi::Number value = info[0].As<Napi::Number>();
-  this->instance->setMaximum(value.Int32Value());
+
+  this->instance->reset();
  return env.Null();
 }

-Napi::Value QProgressBarWrap::setMinimum(const Napi::CallbackInfo& info) {
+Napi::Value QProgressBarWrap::setRange(const Napi::CallbackInfo& info) {
  Napi::Env env = info.Env();
  Napi::HandleScope scope(env);
-  Napi::Number value = info[0].As<Napi::Number>();
-  this->instance->setMinimum(value.Int32Value());
+
+  int minimum = info[0].As<Napi::Number>().Int32Value();
+  int maximum = info[1].As<Napi::Number>().Int32Value();
+  this->instance->setRange(minimum, maximum);
  return env.Null();
 }
-
-Napi::Value QProgressBarWrap::setOrientation(const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  Napi::HandleScope scope(env);
-  Napi::Number value = info[0].As<Napi::Number>();
-  this->instance->setOrientation(
-      static_cast<Qt::Orientation>(value.Int32Value()));
-  return env.Null();
-}
-
-Napi::Value QProgressBarWrap::value(const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  Napi::HandleScope scope(env);
-  int value = this->instance->value();
-  return Napi::Number::New(env, value);
-}
--- a/src/cpp/lib/QtWidgets/QPushButton/qpushbutton_wrap.cpp
+++ b/src/cpp/lib/QtWidgets/QPushButton/qpushbutton_wrap.cpp
@ -1,6 +1,7 @@
 #include "QtWidgets/QPushButton/qpushbutton_wrap.h"

 #include "Extras/Utils/nutils.h"
+#include "QtWidgets/QMenu/qmenu_wrap.h"
 #include "QtWidgets/QWidget/qwidget_wrap.h"

 Napi::FunctionReference QPushButtonWrap::constructor;
@ -10,7 +11,8 @@ Napi::Object QPushButtonWrap::init(Napi::Env env, Napi::Object exports) {
  char CLASSNAME[] = "QPushButton";
  Napi::Function func = DefineClass(
      env, CLASSNAME,
-      {InstanceMethod("setFlat", &QPushButtonWrap::setFlat),
+      {InstanceMethod("setMenu", &QPushButtonWrap::setMenu),
+       InstanceMethod("showMenu", &QPushButtonWrap::showMenu),
       QABSTRACTBUTTON_WRAPPED_METHODS_EXPORT_DEFINE(QPushButtonWrap)});
  constructor = Napi::Persistent(func);
  exports.Set(CLASSNAME, func);
@ -19,6 +21,12 @@ Napi::Object QPushButtonWrap::init(Napi::Env env, Napi::Object exports) {

 NPushButton* QPushButtonWrap::getInternalInstance() { return this->instance; }

+QPushButtonWrap::~QPushButtonWrap() {
+  if (!this->disableDeletion) {
+    extrautils::safeDelete(this->instance);
+  }
+}
+
 QPushButtonWrap::QPushButtonWrap(const Napi::CallbackInfo& info)
    : Napi::ObjectWrap<QPushButtonWrap>(info) {
  Napi::Env env = info.Env();
@ -48,17 +56,20 @@ QPushButtonWrap::QPushButtonWrap(const Napi::CallbackInfo& info)
      true);
 }

-QPushButtonWrap::~QPushButtonWrap() {
-  if (!this->disableDeletion) {
-    extrautils::safeDelete(this->instance);
-  }
-}
-
-Napi::Value QPushButtonWrap::setFlat(const Napi::CallbackInfo& info) {
+Napi::Value QPushButtonWrap::setMenu(const Napi::CallbackInfo& info) {
  Napi::Env env = info.Env();
  Napi::HandleScope scope(env);

-  Napi::Boolean isFlat = info[0].As<Napi::Boolean>();
-  this->instance->setFlat(isFlat.Value());
+  Napi::Object menuObject = info[0].As<Napi::Object>();
+  QMenuWrap* menuWrap = Napi::ObjectWrap<QMenuWrap>::Unwrap(menuObject);
+  this->instance->setMenu(menuWrap->getInternalInstance());
+  return env.Null();
+}
+
+Napi::Value QPushButtonWrap::showMenu(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+
+  this->instance->showMenu();
  return env.Null();
 }
--- a/src/cpp/lib/QtWidgets/QScrollArea/qscrollarea_wrap.cpp
+++ b/src/cpp/lib/QtWidgets/QScrollArea/qscrollarea_wrap.cpp
@ -10,12 +10,11 @@ Napi::Object QScrollAreaWrap::init(Napi::Env env, Napi::Object exports) {
  char CLASSNAME[] = "QScrollArea";
  Napi::Function func = DefineClass(
      env, CLASSNAME,
-      {InstanceMethod("setWidget", &QScrollAreaWrap::setWidget),
+      {InstanceMethod("ensureVisible", &QScrollAreaWrap::ensureVisible),
+       InstanceMethod("ensureWidgetVisible",
+                      &QScrollAreaWrap::ensureWidgetVisible),
+       InstanceMethod("setWidget", &QScrollAreaWrap::setWidget),
       InstanceMethod("takeWidget", &QScrollAreaWrap::takeWidget),
-       InstanceMethod("setWidgetResizable",
-                      &QScrollAreaWrap::setWidgetResizable),
-       InstanceMethod("widgetResizable", &QScrollAreaWrap::widgetResizable),
-
       QABSTRACTSCROLLAREA_WRAPPED_METHODS_EXPORT_DEFINE(QScrollAreaWrap)});
  constructor = Napi::Persistent(func);
  exports.Set(CLASSNAME, func);
@ -24,6 +23,8 @@ Napi::Object QScrollAreaWrap::init(Napi::Env env, Napi::Object exports) {

 NScrollArea* QScrollAreaWrap::getInternalInstance() { return this->instance; }

+QScrollAreaWrap::~QScrollAreaWrap() { extrautils::safeDelete(this->instance); }
+
 QScrollAreaWrap::QScrollAreaWrap(const Napi::CallbackInfo& info)
    : Napi::ObjectWrap<QScrollAreaWrap>(info) {
  Napi::Env env = info.Env();
@ -50,15 +51,40 @@ QScrollAreaWrap::QScrollAreaWrap(const Napi::CallbackInfo& info)
      true);
 }

-QScrollAreaWrap::~QScrollAreaWrap() { extrautils::safeDelete(this->instance); }
+Napi::Value QScrollAreaWrap::ensureVisible(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+
+  int x = info[0].As<Napi::Number>().Int32Value();
+  int y = info[1].As<Napi::Number>().Int32Value();
+  int xmargin = info[2].As<Napi::Number>().Int32Value();
+  int ymargin = info[3].As<Napi::Number>().Int32Value();
+  this->instance->ensureVisible(x, y, xmargin, ymargin);
+  return env.Null();
+}
+
+Napi::Value QScrollAreaWrap::ensureWidgetVisible(
+    const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+
+  Napi::Object childWidgetObject = info[0].As<Napi::Object>();
+  QWidgetWrap* childWidgetWrap =
+      Napi::ObjectWrap<QWidgetWrap>::Unwrap(childWidgetObject);
+  int xmargin = info[1].As<Napi::Number>().Int32Value();
+  int ymargin = info[2].As<Napi::Number>().Int32Value();
+  this->instance->ensureWidgetVisible(childWidgetWrap->getInternalInstance(),
+                                      xmargin, ymargin);
+  return env.Null();
+}

 Napi::Value QScrollAreaWrap::setWidget(const Napi::CallbackInfo& info) {
  Napi::Env env = info.Env();
  Napi::HandleScope scope(env);
-  Napi::Object contentWidget = info[0].As<Napi::Object>();
-  QWidgetWrap* contentWidgetWrap =
-      Napi::ObjectWrap<QWidgetWrap>::Unwrap(contentWidget);

+  Napi::Object contentWidgetObject = info[0].As<Napi::Object>();
+  QWidgetWrap* contentWidgetWrap =
+      Napi::ObjectWrap<QWidgetWrap>::Unwrap(contentWidgetObject);
  this->instance->setWidget(contentWidgetWrap->getInternalInstance());
  return env.Null();
 }
@ -66,24 +92,8 @@ Napi::Value QScrollAreaWrap::setWidget(const Napi::CallbackInfo& info) {
 Napi::Value QScrollAreaWrap::takeWidget(const Napi::CallbackInfo& info) {
  Napi::Env env = info.Env();
  Napi::HandleScope scope(env);
+
  this->instance->takeWidget();
  // We will not return the value here since we are doing it in js side anyway
  return env.Null();
 }
-
-Napi::Value QScrollAreaWrap::setWidgetResizable(
-    const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  Napi::HandleScope scope(env);
-  Napi::Boolean resizable = info[0].As<Napi::Boolean>();
-  this->instance->setWidgetResizable(resizable.Value());
-  return env.Null();
-}
-
-Napi::Value QScrollAreaWrap::widgetResizable(const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  Napi::HandleScope scope(env);
-  Napi::Boolean resizable = info[0].As<Napi::Boolean>();
-  bool value = this->instance->widgetResizable();
-  return Napi::Value::From(env, value);
-}
--- a/src/cpp/lib/QtWidgets/QToolButton/qtoolbutton_wrap.cpp
+++ b/src/cpp/lib/QtWidgets/QToolButton/qtoolbutton_wrap.cpp
@ -12,16 +12,7 @@ Napi::Object QToolButtonWrap::init(Napi::Env env, Napi::Object exports) {
  char CLASSNAME[] = "QToolButton";
  Napi::Function func = DefineClass(
      env, CLASSNAME,
-      {InstanceMethod("setArrowType", &QToolButtonWrap::setArrowType),
-       InstanceMethod("arrowType", &QToolButtonWrap::arrowType),
-       InstanceMethod("setAutoRaise", &QToolButtonWrap::setAutoRaise),
-       InstanceMethod("autoRaise", &QToolButtonWrap::autoRaise),
-       InstanceMethod("setPopupMode", &QToolButtonWrap::setPopupMode),
-       InstanceMethod("popupMode", &QToolButtonWrap::popupMode),
-       InstanceMethod("setToolButtonStyle",
-                      &QToolButtonWrap::setToolButtonStyle),
-       InstanceMethod("toolButtonStyle", &QToolButtonWrap::toolButtonStyle),
-       InstanceMethod("setMenu", &QToolButtonWrap::setMenu),
+      {InstanceMethod("setMenu", &QToolButtonWrap::setMenu),
       InstanceMethod("setDefaultAction", &QToolButtonWrap::setDefaultAction),
       InstanceMethod("showMenu", &QToolButtonWrap::showMenu),
       QABSTRACTBUTTON_WRAPPED_METHODS_EXPORT_DEFINE(QToolButtonWrap)});
@ -30,9 +21,15 @@ Napi::Object QToolButtonWrap::init(Napi::Env env, Napi::Object exports) {
  return exports;
 }

-NToolButton *QToolButtonWrap::getInternalInstance() { return this->instance; }
+NToolButton* QToolButtonWrap::getInternalInstance() { return this->instance; }

-QToolButtonWrap::QToolButtonWrap(const Napi::CallbackInfo &info)
+QToolButtonWrap::~QToolButtonWrap() {
+  if (!this->disableDeletion) {
+    extrautils::safeDelete(this->instance);
+  }
+}
+
+QToolButtonWrap::QToolButtonWrap(const Napi::CallbackInfo& info)
    : Napi::ObjectWrap<QToolButtonWrap>(info) {
  Napi::Env env = info.Env();
  Napi::HandleScope scope(env);
@ -46,7 +43,7 @@ QToolButtonWrap::QToolButtonWrap(const Napi::CallbackInfo &info)
  } else {
    if (info.Length() == 1) {
      Napi::Object parentObject = info[0].As<Napi::Object>();
-      QWidgetWrap *parentWidgetWrap =
+      QWidgetWrap* parentWidgetWrap =
          Napi::ObjectWrap<QWidgetWrap>::Unwrap(parentObject);
      this->instance = new NToolButton(parentWidgetWrap->getInternalInstance());
    } else if (info.Length() == 0) {
@ -61,97 +58,30 @@ QToolButtonWrap::QToolButtonWrap(const Napi::CallbackInfo &info)
      true);
 }

-QToolButtonWrap::~QToolButtonWrap() {
-  if (!this->disableDeletion) {
-    extrautils::safeDelete(this->instance);
-  }
-}
-
-Napi::Value QToolButtonWrap::setArrowType(const Napi::CallbackInfo &info) {
-  Napi::Env env = info.Env();
-  Napi::HandleScope scope(env);
-  int type = info[0].As<Napi::Number>().Int32Value();
-  this->instance->setArrowType(static_cast<Qt::ArrowType>(type));
-  return env.Null();
-}
-
-Napi::Value QToolButtonWrap::arrowType(const Napi::CallbackInfo &info) {
-  Napi::Env env = info.Env();
-  Napi::HandleScope scope(env);
-  int type = static_cast<int>(this->instance->arrowType());
-  return Napi::Value::From(env, type);
-}
-
-Napi::Value QToolButtonWrap::setAutoRaise(const Napi::CallbackInfo &info) {
-  Napi::Env env = info.Env();
-  Napi::HandleScope scope(env);
-  bool enable = info[0].As<Napi::Boolean>().Value();
-  this->instance->setAutoRaise(enable);
-  return env.Null();
-}
-
-Napi::Value QToolButtonWrap::autoRaise(const Napi::CallbackInfo &info) {
-  Napi::Env env = info.Env();
-  Napi::HandleScope scope(env);
-  bool enable = this->instance->autoRaise();
-  return Napi::Value::From(env, enable);
-}
-
-Napi::Value QToolButtonWrap::setPopupMode(const Napi::CallbackInfo &info) {
-  Napi::Env env = info.Env();
-  Napi::HandleScope scope(env);
-  int mode = info[0].As<Napi::Number>().Int32Value();
-  this->instance->setPopupMode(
-      static_cast<QToolButton::ToolButtonPopupMode>(mode));
-  return env.Null();
-}
-
-Napi::Value QToolButtonWrap::popupMode(const Napi::CallbackInfo &info) {
-  Napi::Env env = info.Env();
-  Napi::HandleScope scope(env);
-  int mode = static_cast<int>(this->instance->popupMode());
-  return Napi::Value::From(env, mode);
-}
-
-Napi::Value QToolButtonWrap::setToolButtonStyle(
-    const Napi::CallbackInfo &info) {
-  Napi::Env env = info.Env();
-  Napi::HandleScope scope(env);
-  int style = info[0].As<Napi::Number>().Int32Value();
-  this->instance->setToolButtonStyle(static_cast<Qt::ToolButtonStyle>(style));
-  return env.Null();
-}
-
-Napi::Value QToolButtonWrap::toolButtonStyle(const Napi::CallbackInfo &info) {
-  Napi::Env env = info.Env();
-  Napi::HandleScope scope(env);
-  int style = static_cast<int>(this->instance->toolButtonStyle());
-  return Napi::Value::From(env, style);
-}
-
-Napi::Value QToolButtonWrap::setMenu(const Napi::CallbackInfo &info) {
+Napi::Value QToolButtonWrap::setMenu(const Napi::CallbackInfo& info) {
  Napi::Env env = info.Env();
  Napi::HandleScope scope(env);

  Napi::Object menuObject = info[0].As<Napi::Object>();
-  QMenuWrap *menuWrap = Napi::ObjectWrap<QMenuWrap>::Unwrap(menuObject);
+  QMenuWrap* menuWrap = Napi::ObjectWrap<QMenuWrap>::Unwrap(menuObject);
  this->instance->setMenu(menuWrap->getInternalInstance());
  return env.Null();
 }

-Napi::Value QToolButtonWrap::setDefaultAction(const Napi::CallbackInfo &info) {
+Napi::Value QToolButtonWrap::setDefaultAction(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);
+  QActionWrap* actionWrap = Napi::ObjectWrap<QActionWrap>::Unwrap(actionObject);
  this->instance->setDefaultAction(actionWrap->getInternalInstance());
  return env.Null();
 }

-Napi::Value QToolButtonWrap::showMenu(const Napi::CallbackInfo &info) {
+Napi::Value QToolButtonWrap::showMenu(const Napi::CallbackInfo& info) {
  Napi::Env env = info.Env();
  Napi::HandleScope scope(env);
+
  this->instance->showMenu();
  return env.Null();
 }
--- a/src/cpp/main.cpp
+++ b/src/cpp/main.cpp
@ -23,6 +23,7 @@
 #include "QtGui/QIcon/qicon_wrap.h"
 #include "QtGui/QKeySequence/qkeysequence_wrap.h"
 #include "QtGui/QMovie/qmovie_wrap.h"
+#include "QtGui/QPicture/qpicture_wrap.h"
 #include "QtGui/QPixmap/qpixmap_wrap.h"
 #include "QtGui/QStyle/qstyle_wrap.h"
 #include "QtWidgets/QAction/qaction_wrap.h"
@ -94,6 +95,7 @@ Napi::Object Main(Napi::Env env, Napi::Object exports) {
  QClipboardWrap::init(env, exports);
  QDialogWrap::init(env, exports);
  QWidgetWrap::init(env, exports);
+  QPictureWrap::init(env, exports);
  QPixmapWrap::init(env, exports);
  QKeySequenceWrap::init(env, exports);
  QFontDatabaseWrap::init(env, exports);
--- a/src/index.ts
+++ b/src/index.ts
@ -5,6 +5,7 @@ export * from './lib/QtEnums';
 // Gui:
 export { QApplication } from './lib/QtGui/QApplication';
 export { QKeySequence } from './lib/QtGui/QKeySequence';
+export { QPicture } from './lib/QtGui/QPicture';
 export { QPixmap, ImageFormats } from './lib/QtGui/QPixmap';
 export { QIcon, QIconMode, QIconState } from './lib/QtGui/QIcon';
 export { QFont, QFontCapitalization, QFontStretch, QFontWeight } from './lib/QtGui/QFont';
@ -42,7 +43,7 @@ export { QDial, QDialSignals } from './lib/QtWidgets/QDial';
 export { QFileDialog, QFileDialogSignals } from './lib/QtWidgets/QFileDialog';
 export { QLineEdit, QLineEditSignals, EchoMode } from './lib/QtWidgets/QLineEdit';
 export { QMainWindow, QMainWindowSignals } from './lib/QtWidgets/QMainWindow';
-export { QProgressBar, QProgressBarSignals } from './lib/QtWidgets/QProgressBar';
+export { QProgressBar, QProgressBarSignals, QProgressBarDirection } from './lib/QtWidgets/QProgressBar';
 export { QComboBox, QComboBoxSignals, InsertPolicy } from './lib/QtWidgets/QComboBox';
 export { QPushButton, QPushButtonSignals } from './lib/QtWidgets/QPushButton';
 export { QToolButton, QToolButtonSignals, ToolButtonPopupMode } from './lib/QtWidgets/QToolButton';
--- a/src/lib/QtGui/QPicture.ts
+++ b/src/lib/QtGui/QPicture.ts
@ -0,0 +1,54 @@
+import addon from '../utils/addon';
+import { checkIfNativeElement } from '../utils/helpers';
+import { Component, NativeElement } from '../core/Component';
+import { QRect } from '../QtCore/QRect';
+
+/**
+ 
+> The QPicture class is a paint device that records and replays QPainter commands.
+
+* **This class is a JS wrapper around Qt's [QPicture class](https://doc.qt.io/qt-5/qpicture.html)**
+
+### Example
+
+```javascript
+const { QPicture } = require("@nodegui/nodegui");
+
+const picture = new QPicture();
+```
+ */
+export class QPicture extends Component {
+    native: NativeElement;
+    constructor();
+    constructor(native: NativeElement);
+    constructor(formatVersion: number);
+    constructor(arg?: number | NativeElement) {
+        super();
+        if (typeof arg === 'number') {
+            const formatVersion = arg;
+            this.native = new addon.QPicture(formatVersion);
+        } else if (checkIfNativeElement(arg)) {
+            this.native = arg as NativeElement;
+        } else {
+            this.native = new addon.QPicture();
+        }
+    }
+    setBoundingRect(r: QRect): void {
+        this.native.setBoundingRect(r.native);
+    }
+    boundingRect(): QRect {
+        return new QRect(this.native.boundingRect());
+    }
+    isNull(): boolean {
+        return this.native.isNull();
+    }
+    load(fileName: string): boolean {
+        return this.native.load(fileName);
+    }
+    save(fileName: string): boolean {
+        return this.native.save(fileName);
+    }
+    size(): number {
+        return this.native.size();
+    }
+}
--- a/src/lib/QtWidgets/QLabel.ts
+++ b/src/lib/QtWidgets/QLabel.ts
@ -5,6 +5,8 @@ import { QPixmap } from '../QtGui/QPixmap';
 import { QMovie } from '../QtGui/QMovie';
 import { AlignmentFlag } from '../QtEnums/AlignmentFlag';
 import { TextFormat } from '../QtEnums/TextFormat';
+import { TextInteractionFlag } from '../QtEnums';
+import { QPicture } from '../QtGui/QPicture';

 /**
 
@ -26,8 +28,10 @@ label.setText("Hello");
 */
 export class QLabel extends NodeWidget<QLabelSignals> {
    native: NativeElement;
+    private _picture?: QPicture;
    private _pixmap?: QPixmap;
    private _movie?: QMovie;
+    private _buddy?: NodeWidget<any> | null;
    constructor();
    constructor(parent: NodeWidget<any>);
    constructor(parent?: NodeWidget<any>) {
@ -42,47 +46,80 @@ export class QLabel extends NodeWidget<QLabelSignals> {
        this.setNodeParent(parent);
    }
    setAlignment(alignment: AlignmentFlag): void {
-        this.native.setAlignment(alignment);
+        this.setProperty('alignment', alignment);
    }
    alignment(): AlignmentFlag {
-        return this.native.alignment();
+        return this.property('alignment').toInt();
+    }
+    hasSelectedText(): boolean {
+        return this.property('hasSelectedText').toBool();
    }
    setIndent(indent: number): void {
-        this.native.setIndent(indent);
+        this.setProperty('indent', indent);
    }
    indent(): number {
-        return this.native.indent();
+        return this.property('indent').toInt();
    }
    setMargin(margin: number): void {
-        this.native.setMargin(margin);
+        this.setProperty('margin', margin);
    }
    margin(): number {
-        return this.native.margin();
+        return this.property('margin').toInt();
    }
-    setTextFormat(format: TextFormat): void {
-        this.native.setTextFormat(format);
+    setOpenExternalLinks(open: boolean): void {
+        this.setProperty('openExternalLinks', open);
    }
-    textFormat(): TextFormat {
-        return this.native.textFormat();
+    openExternalLinks(): boolean {
+        return this.property('openExternalLinks').toBool();
    }
-    setWordWrap(on: boolean): void {
-        this.native.setWordWrap(on);
+    setScaledContents(scaled: boolean): void {
+        this.setProperty('scaledContents', scaled);
    }
-    wordWrap(): boolean {
-        return this.native.wordWrap();
+    hasScaledContents(): boolean {
+        return this.property('scaledContents').toBool();
+    }
+    selectedText(): string {
+        return this.property('selectedText').toString();
    }
    setText(text: string | number): void {
-        this.native.setText(`${text}`);
+        this.setProperty('text', `${text}`);
    }
    text(): string {
-        return this.native.text();
+        return this.property('text').toString();
    }
-    setPixmap(pixMap: QPixmap): void {
-        this.native.setPixmap(pixMap.native);
-        this._pixmap = pixMap;
+    setTextFormat(format: TextFormat): void {
+        this.setProperty('textFormat', format);
    }
-    pixmap(): QPixmap | undefined {
-        return this._pixmap;
+    textFormat(): TextFormat {
+        return this.property('textFormat').toInt();
+    }
+    setTextInteractionFlags(flags: TextInteractionFlag): void {
+        this.setProperty('textInteractionFlags', flags);
+    }
+    textInteractionFlags(): TextInteractionFlag {
+        return this.property('textInteractionFlags').toInt();
+    }
+    setWordWrap(on: boolean): void {
+        this.setProperty('wordWrap', on);
+    }
+    wordWrap(): boolean {
+        return this.property('wordWrap').toBool();
+    }
+    setSelection(start: number, length: number): void {
+        this.native.setSelection(start, length);
+    }
+    selectionStart(): number {
+        return this.native.selectionStart();
+    }
+    setBuddy(buddy: NodeWidget<any>): void {
+        this.native.setBuddy(buddy.native);
+        this._buddy = buddy;
+    }
+    buddy(): NodeWidget<any> | null {
+        if (this._buddy) {
+            return this._buddy;
+        }
+        return null;
    }
    setMovie(movie: QMovie): void {
        this.native.setMovie(movie.native);
@ -91,15 +128,32 @@ export class QLabel extends NodeWidget<QLabelSignals> {
    movie(): QMovie | undefined {
        return this._movie;
    }
-    setOpenExternalLinks(open: boolean): void {
-        this.native.setOpenExternalLinks(open);
+    setPicture(picture: QPicture): void {
+        this.native.setPicture(picture.native);
+        this._picture = picture;
    }
-    openExternalLinks(): boolean {
-        return this.native.openExternalLinks();
+    picture(): QPicture | undefined {
+        return this._picture;
+    }
+    setPixmap(pixMap: QPixmap): void {
+        this.native.setPixmap(pixMap.native);
+        this._pixmap = pixMap;
+    }
+    pixmap(): QPixmap | undefined {
+        return this._pixmap;
+    }
+    setNumDouble(num: number): void {
+        this.native.setNumDouble(num);
+    }
+    setNumInt(num: number): void {
+        this.native.setNumInt(num);
    }
    clear(): void {
        this.native.clear();
    }
 }

-export type QLabelSignals = QWidgetSignals;
+export interface QLabelSignals extends QWidgetSignals {
+    linkActivated: (link: string) => void;
+    linkHovered: (link: string) => void;
+}
--- a/src/lib/QtWidgets/QProgressBar.ts
+++ b/src/lib/QtWidgets/QProgressBar.ts
@ -1,7 +1,7 @@
 import addon from '../utils/addon';
 import { NodeWidget, QWidgetSignals } from './QWidget';
 import { NativeElement } from '../core/Component';
-import { Orientation } from '../QtEnums';
+import { Orientation, AlignmentFlag } from '../QtEnums';

 /**
 
@ -34,26 +34,77 @@ export class QProgressBar extends NodeWidget<QProgressBarSignals> {
        this.native = native;
        this.setNodeParent(parent);
    }
-    setValue(value: number): void {
-        // react:✓
-        this.native.setValue(value);
+    setAlignment(alignment: AlignmentFlag): void {
+        this.setProperty('alignment', alignment);
    }
-    value(): number {
-        // react:✓
-        return this.native.value();
+    alignment(): AlignmentFlag {
+        return this.property('alignment').toInt();
    }
-    setMinimum(min: number): void {
-        // react:✓ TODO://getter
-        this.native.setMinimum(min);
+    setFormat(format: string): void {
+        this.setProperty('format', format);
    }
-    setMaximum(max: number): void {
-        // react:✓ TODO://getter
-        this.native.setMaximum(max);
+    format(): string {
+        return this.property('format').toString();
+    }
+    setInvertedAppearance(invert: boolean): void {
+        this.setProperty('invertedAppearance', invert);
+    }
+    invertedAppearance(): boolean {
+        return this.property('invertedAppearance').toBool();
+    }
+    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();
    }
    setOrientation(orientation: Orientation): void {
-        // react:✓ TODO://getter
-        this.native.setOrientation(orientation);
+        this.setProperty('orientation', orientation);
    }
+    orientation(): Orientation {
+        return this.property('orientation').toInt();
+    }
+    text(): string {
+        return this.property('text').toString();
+    }
+    setTextDirection(textDirection: QProgressBarDirection): void {
+        this.setProperty('textDirection', textDirection);
+    }
+    textDirection(): QProgressBarDirection {
+        return this.property('textDirection').toInt();
+    }
+    setTextVisible(visible: boolean): void {
+        this.setProperty('textVisible', visible);
+    }
+    isTextVisible(): boolean {
+        return this.property('textVisible').toBool();
+    }
+    setValue(value: number): void {
+        this.setProperty('value', value);
+    }
+    value(): number {
+        return this.property('value').toInt();
+    }
+    resetFormat(): void {
+        this.native.resetFormat();
+    }
+    reset(): void {
+        this.native.reset();
+    }
+    setRange(minimum: number, maximum: number): void {
+        this.native.setRange(minimum, maximum);
+    }
+}
+
+export enum QProgressBarDirection {
+    TopToBottom,
+    BottomToTop,
 }

 export interface QProgressBarSignals extends QWidgetSignals {
--- a/src/lib/QtWidgets/QPushButton.ts
+++ b/src/lib/QtWidgets/QPushButton.ts
@ -3,6 +3,7 @@ import { NodeWidget } from './QWidget';
 import { NativeElement, NativeRawPointer, Component } from '../core/Component';
 import { QAbstractButton, QAbstractButtonSignals } from './QAbstractButton';
 import { checkIfNativeElement, checkIfNapiExternal } from '../utils/helpers';
+import { QMenu } from './QMenu';

 /**
 
@ -23,6 +24,7 @@ button.setText("Hello");
 */
 export class QPushButton extends QAbstractButton<QPushButtonSignals> {
    native: NativeElement;
+    private _menu?: QMenu | null;
    constructor();
    constructor(parent: NodeWidget<any>);
    constructor(native: NativeElement);
@ -45,8 +47,36 @@ export class QPushButton extends QAbstractButton<QPushButtonSignals> {
        this.native = native;
        parent && this.setNodeParent(parent);
    }
+    setAutoDefault(auto: boolean): void {
+        this.setProperty('autoDefault', auto);
+    }
+    autoDefault(): boolean {
+        return this.property('autoDefault').toBool();
+    }
+    setDefault(isDefault: boolean): void {
+        this.setProperty('default', isDefault);
+    }
+    isDefault(): boolean {
+        return this.property('default').toBool();
+    }
    setFlat(isFlat: boolean): void {
-        this.native.setFlat(isFlat);
+        this.setProperty('flat', isFlat);
+    }
+    isFlat(): boolean {
+        return this.property('flat').toBool();
+    }
+    setMenu(menu: QMenu): void {
+        this._menu = menu;
+        this.native.setMenu(menu.native);
+    }
+    menu(): QMenu | null {
+        if (this._menu) {
+            return this._menu;
+        }
+        return null;
+    }
+    showMenu(): void {
+        this.native.showMenu();
    }
 }

--- a/src/lib/QtWidgets/QScrollArea.ts
+++ b/src/lib/QtWidgets/QScrollArea.ts
@ -2,6 +2,7 @@ import addon from '../utils/addon';
 import { NodeWidget } from './QWidget';
 import { NativeElement } from '../core/Component';
 import { QAbstractScrollArea, QAbstractScrollAreaSignals } from './QAbstractScrollArea';
+import { AlignmentFlag } from '../QtEnums';

 /**
 
@ -43,12 +44,38 @@ export class QScrollArea extends QAbstractScrollArea<QScrollAreaSignals> {
        this.setNodeParent(parent);
        this.setWidgetResizable(true);
    }
+    setAlignment(alignment: AlignmentFlag): void {
+        this.setProperty('alignment', alignment);
+    }
+    alignment(): AlignmentFlag {
+        return this.property('alignment').toInt();
+    }
+    setWidgetResizable(resizable: boolean): void {
+        this.setProperty('widgetResizable', resizable);
+        if (this.contentWidget) {
+            this.contentWidget.setFlexNodeSizeControlled(resizable);
+        }
+    }
+    widgetResizable(): boolean {
+        return this.property('widgetResizable').toBool();
+    }
+    ensureVisible(x: number, y: number, xmargin = 50, ymargin = 50): void {
+        this.native.ensureVisible(x, y, xmargin, ymargin);
+    }
+    ensureWidgetVisible(childWidget: NodeWidget<any>, xmargin = 50, ymargin = 50): void {
+        this.native.ensureWidgetVisible(childWidget.native, xmargin, ymargin);
+    }
    setWidget(widget: NodeWidget<any>): void {
-        // react:✓, //TODO:getter
        this.contentWidget = widget;
        this.native.setWidget(widget.native);
        this.contentWidget.setFlexNodeSizeControlled(this.widgetResizable());
    }
+    widget(): NodeWidget<any> | null {
+        if (this.contentWidget) {
+            return this.contentWidget;
+        }
+        return null;
+    }
    takeWidget(): NodeWidget<any> | null {
        // react:✓
        const contentWidget = this.contentWidget;
@ -59,15 +86,6 @@ export class QScrollArea extends QAbstractScrollArea<QScrollAreaSignals> {
        }
        return null;
    }
-    setWidgetResizable(resizable: boolean): void {
-        this.native.setWidgetResizable(resizable);
-        if (this.contentWidget) {
-            this.contentWidget.setFlexNodeSizeControlled(resizable);
-        }
-    }
-    widgetResizable(): boolean {
-        return this.native.widgetResizable();
-    }
 }

 export type QScrollAreaSignals = QAbstractScrollAreaSignals;
--- a/src/lib/QtWidgets/QToolButton.ts
+++ b/src/lib/QtWidgets/QToolButton.ts
@ -27,6 +27,8 @@ tool.setText('Help');
 */
 export class QToolButton extends QAbstractButton<QToolButtonSignals> {
    native: NativeElement;
+    private _defaultAction?: QAction | null;
+    private _menu?: QMenu | null;
    constructor();
    constructor(parent: NodeWidget<any>);
    constructor(rawPointer: NativeRawPointer<any>, disableNativeDeletion?: boolean);
@ -40,6 +42,7 @@ export class QToolButton extends QAbstractButton<QToolButtonSignals> {
        } else if (arg) {
            const parentWidget = arg as NodeWidget<any>;
            native = new addon.QToolButton(parentWidget.native);
+            parent = parentWidget;
        } else {
            native = new addon.QToolButton();
        }
@ -48,35 +51,49 @@ export class QToolButton extends QAbstractButton<QToolButtonSignals> {
        parent && this.setNodeParent(parent);
    }
    setArrowType(type: ArrowType): void {
-        this.native.setArrowType(type);
+        this.setProperty('arrowType', type);
    }
    arrowType(): ArrowType {
        return this.property('arrowType').toInt();
    }
    setAutoRaise(enable: boolean): void {
-        this.native.setAutoRaise(enable);
+        this.setProperty('autoRaise', enable);
    }
    autoRaise(): boolean {
        return this.property('autoRaise').toBool();
    }
    setPopupMode(mode: ToolButtonPopupMode): void {
-        this.native.setPopupMode(mode);
+        this.setProperty('popupMode', mode);
    }
    popupMode(): ToolButtonPopupMode {
        return this.property('popupMode').toInt();
    }
    setToolButtonStyle(style: ToolButtonStyle): void {
-        this.native.setToolButtonStyle(style);
+        this.setProperty('toolButtonStyle', style);
    }
    toolButtonStyle(): ToolButtonStyle {
-        return this.native.toolButtonStyle();
+        return this.property('toolButtonStyle').toInt();
    }
    setMenu(menu: QMenu): void {
+        this._menu = menu;
        this.native.setMenu(menu.native);
    }
+    menu(): QMenu | null {
+        if (this._menu) {
+            return this._menu;
+        }
+        return null;
+    }
    setDefaultAction(action: QAction): void {
+        this._defaultAction = action;
        this.native.setDefaultAction(action.native);
    }
+    defaultAction(): QAction | null {
+        if (this._defaultAction) {
+            return this._defaultAction;
+        }
+        return null;
+    }
    showMenu(): void {
        this.native.showMenu();
    }