Bump the version

Add Input Method classes and support

.github/workflows/latest.yml

@@ -7,17 +7,20 @@ jobs:
         strategy:
             fail-fast: false
             matrix:
-                os: [ubuntu-18.04]
+                os: [ubuntu-20.04]
         runs-on: ${{ matrix.os }}
         steps:
             - uses: actions/checkout@v2
             - uses: actions/setup-node@v2
               with:
                 node-version: '16.x'
+            - name: Install ubuntu deps
+              if: contains(matrix.os, 'ubuntu-20.04')
+              run: sudo apt install mesa-common-dev libglu1-mesa-dev libegl1 libopengl-dev
             - name: Install deps
-              run: yarn install --ignore-scripts
+              run: npm install
             - name: Build nodegui
-              run: npx tsc
+              run: npm run build
             - name: Archive using npm pack
               run: npm --no-git-tag-version version 0.0.0-latest-master && npm pack
             - uses: actions/upload-artifact@v1
@@ -30,11 +33,11 @@ jobs:
                   code: v0.0.0-latest-master
                   name: Latest Master Release
                   body: >
-                      Latest auto release corresponding to commit ${{github.sha}} 🔥. 
+                      Latest auto release corresponding to commit ${{github.sha}} 🔥.
-                      To install do: 
+                      To install do:
-                      `yarn install https://github.com/nodegui/nodegui/releases/download/v0.0.0-latest-master/nodegui-master.tgz`
+                      `npm install https://github.com/nodegui/nodegui/releases/download/v0.0.0-latest-master/nodegui-master.tgz`
-                      or 
+                      or
-                      `yarn install http://master-release.nodegui.org`
+                      `npm install http://master-release.nodegui.org`
                   assets: >
                       nodegui-nodegui-0.0.0-latest-master.tgz:nodegui-master.tgz:application/tar+gzip
                   recreate: true

.github/workflows/release.yml

@@ -10,7 +10,7 @@ jobs:
     strategy:
       matrix:
         include:
-          - os: ubuntu-18.04
+          - os: ubuntu-20.04
             platform: linux
             arch: x64
           - os: windows-latest
@@ -30,8 +30,8 @@ jobs:
           node-version: '16.x'
 
       - name: Install ubuntu deps
-        if: contains(matrix.os, 'ubuntu-18.04')
+        if: contains(matrix.os, 'ubuntu-20.04')
-        run: sudo apt install mesa-common-dev libglu1-mesa-dev
+        run: sudo apt install mesa-common-dev libglu1-mesa-dev libegl1 libopengl-dev
 
       - name: Install deps
         run: npm install

.github/workflows/test.yml

@@ -6,7 +6,7 @@ jobs:
         strategy:
             fail-fast: false
             matrix:
-                os: [ubuntu-18.04, windows-latest, macos-latest]
+                os: [ubuntu-20.04, windows-latest, macos-latest]
         runs-on: ${{ matrix.os }}
         steps:
             - uses: actions/checkout@v2
@@ -14,8 +14,8 @@ jobs:
               with:
                 node-version: '16.x'
             - name: Install ubuntu deps
-              if: contains(matrix.os, 'ubuntu')
+              if: contains(matrix.os, 'ubuntu-20.04')
-              run: sudo apt install mesa-common-dev libglu1-mesa-dev
+              run: sudo apt install mesa-common-dev libglu1-mesa-dev libegl1 libopengl-dev
             - name: Install deps
               run: npm install
             - name: Build nodegui

CMakeLists.txt

@@ -11,6 +11,7 @@ set(CORE_WIDGETS_ADDON "nodegui_core")
 
 project(${CORE_WIDGETS_ADDON})
 
+set(CMAKE_BUILD_WITH_INSTALL_RPATH ON)
 
 # Note: CMake+moc also use this list when finding files which `moc` applied.
 
@@ -61,6 +62,8 @@ add_library(${CORE_WIDGETS_ADDON} SHARED
     "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtGui/QEvent/QDragMoveEvent/qdragmoveevent_wrap.cpp"
     "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtGui/QEvent/QDragLeaveEvent/qdragleaveevent_wrap.cpp"
     "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtGui/QEvent/QResizeEvent/qresizeevent_wrap.cpp"
+    "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtGui/QEvent/QInputMethodEvent/qinputmethodevent_wrap.cpp"
+    "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtGui/QEvent/QInputMethodQueryEvent/qinputmethodqueryevent_wrap.cpp"
     "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtGui/QFontDatabase/qfontdatabase_wrap.cpp"
     "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtGui/QFontMetrics/qfontmetrics_wrap.cpp"
     "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtGui/QFontMetricsF/qfontmetricsf_wrap.cpp"
@@ -265,16 +268,16 @@ if (UNIX AND NOT APPLE)
 endif()
 
 if (APPLE)
+    set(CMAKE_MACOSX_RPATH ON)
     file(RELATIVE_PATH QT_LIBRARY_REL_PATH "${CMAKE_BINARY_DIR}/Release" "${QT_CMAKE_HOME_DIR}/../..")
     set_target_properties(${CORE_WIDGETS_ADDON} PROPERTIES INSTALL_RPATH "@loader_path/${QT_LIBRARY_REL_PATH}")
-    set_target_properties(${CORE_WIDGETS_ADDON} PROPERTIES SKIP_BUILD_RPATH FALSE)
-    set_target_properties(${CORE_WIDGETS_ADDON} PROPERTIES BUILD_WITH_INSTALL_RPATH TRUE)
 endif()
 
 target_link_libraries(${CORE_WIDGETS_ADDON} PRIVATE
     "${CMAKE_JS_LIB}"
-    Qt5::Widgets
+    Qt6::Widgets
-    Qt5::Core
+    Qt6::Core
-    Qt5::Gui
+    Qt6::Gui
-    Qt5::Svg
+    Qt6::Svg
+    Qt6::SvgWidgets
 )

README.md

@@ -7,7 +7,7 @@
 
 Build **performant**, **native** and **cross-platform** desktop applications with **Node.js** and **CSS like styling**.🚀
 
-NodeGUI is powered by **Qt5** 💚 which makes it CPU and memory efficient as compared to other chromium based solutions like Electron.
+NodeGUI is powered by **Qt6** 💚 which makes it CPU and memory efficient as compared to other chromium based solutions like Electron.
 
 <img src="https://upload.wikimedia.org/wikipedia/commons/thumb/a/a7/React-icon.svg/1024px-React-icon.svg.png" alt="" width="25"> If you are looking for **React** based version, check out: **[React NodeGUI](https://github.com/nodegui/react-nodegui)**.
 

config/qt.cmake

@@ -8,7 +8,7 @@ set(CMAKE_AUTOUIC ON)
 
 set(QTCONFIG_FILE ${CMAKE_CURRENT_LIST_DIR}/qtConfig.js)
 
-macro(AddQtSupport addonName)    
+macro(AddQtSupport addonName)
     execute_process(COMMAND node -p "require('${QTCONFIG_FILE}').qtCmakeDir"
         WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
         OUTPUT_VARIABLE QT_CMAKE_HOME_DIR
@@ -16,10 +16,10 @@ macro(AddQtSupport addonName)
 
     string(REPLACE "\n" "" QT_CMAKE_HOME_DIR "${QT_CMAKE_HOME_DIR}")
     string(REPLACE "\"" "" QT_CMAKE_HOME_DIR "${QT_CMAKE_HOME_DIR}")
-    
-    message(STATUS "Using QT installation for ${addonName} QT_CMAKE_HOME_DIR:${QT_CMAKE_HOME_DIR}")
 
-    set(Qt5_DIR ${QT_CMAKE_HOME_DIR}) 
+    message(STATUS "Using Qt installation for ${addonName} QT_CMAKE_HOME_DIR:${QT_CMAKE_HOME_DIR}")
-    find_package(Qt5 COMPONENTS Widgets Gui Core Svg REQUIRED)
+
-      
+    list(APPEND CMAKE_PREFIX_PATH "${QT_CMAKE_HOME_DIR}/../../..")
+    find_package(Qt6 REQUIRED COMPONENTS Widgets Gui Core Svg SvgWidgets)
+
 endmacro(AddQtSupport addonName)

config/qtConfig.js

@@ -3,7 +3,7 @@ const path = require('path');
 const fs = require('fs');
 
 const SETUP_DIR = path.resolve(__dirname, '..', 'miniqt');
-const QT_VERSION = '5.15.2';
+const QT_VERSION = '6.4.1';
 const MIRROR = Boolean(process.env.QT_LINK_MIRROR) ? process.env.QT_LINK_MIRROR : 'https://download.qt.io';
 
 const checkIfExists = (fullPath) => {
@@ -13,41 +13,27 @@ const checkIfExists = (fullPath) => {
 function getMiniQtConfig() {
     switch (os.platform()) {
         case 'darwin': {
-            if (os.arch() === 'arm64') {
+            const qtHome = path.resolve(SETUP_DIR, QT_VERSION, 'macos');
-                const qtHome = path.resolve(SETUP_DIR, 'Qt-5.15.3');
+            return {
-                return {
+                qtHome,
-                    qtHome,
+                artifacts: [
-                    artifacts: [
+                    {
-                        {
+                        name: 'Qt Base',
-                            name: 'Mini Qt Bundle',
+                        link: `${MIRROR}/online/qtsdkrepository/mac_x64/desktop/qt6_641/qt.qt6.641.clang_64/6.4.1-0-202211101256qtbase-MacOS-MacOS_12-Clang-MacOS-MacOS_12-X86_64-ARM64.7z`,
-                            link: `https://github.com/nodegui/nodegui/releases/download/miniQtm1-5153/Qt-5.15.3.zip`,
+                        skipSetup: checkIfExists(path.resolve(qtHome, 'plugins', 'platforms', 'libqcocoa.dylib')),
-                            skipSetup: checkIfExists(path.resolve(qtHome, 'plugins', 'platforms', 'libqcocoa.dylib')),
+                    },
-                        },
+                    {
-                    ],
+                        name: 'Qt Svg',
-                };
+                        link: `${MIRROR}/online/qtsdkrepository/mac_x64/desktop/qt6_641/qt.qt6.641.clang_64/6.4.1-0-202211101256qtsvg-MacOS-MacOS_12-Clang-MacOS-MacOS_12-X86_64-ARM64.7z`,
-            } else {
+                        skipSetup: checkIfExists(path.resolve(qtHome, 'lib', 'QtSvg.framework', 'QtSvg')),
-                const qtHome = path.resolve(SETUP_DIR, QT_VERSION, 'clang_64');
+                    },
-                return {
+                    {
-                    qtHome,
+                        name: 'Qt Tools',
-                    artifacts: [
+                        link: `${MIRROR}/online/qtsdkrepository/mac_x64/desktop/qt6_641/qt.qt6.641.clang_64/6.4.1-0-202211101256qttools-MacOS-MacOS_12-Clang-MacOS-MacOS_12-X86_64-ARM64.7z`,
-                        {
+                        skipSetup: checkIfExists(path.resolve(qtHome, 'bin', 'macdeployqt')),
-                            name: 'Qt Base',
+                    },
-                            link: `${MIRROR}/online/qtsdkrepository/mac_x64/desktop/qt5_5152/qt.qt5.5152.clang_64/5.15.2-0-202011130601qtbase-MacOS-MacOS_10_13-Clang-MacOS-MacOS_10_13-X86_64.7z`,
+                ],
-                            skipSetup: checkIfExists(path.resolve(qtHome, 'plugins', 'platforms', 'libqcocoa.dylib')),
+            };
-                        },
-                        {
-                            name: 'Qt Svg',
-                            link: `${MIRROR}/online/qtsdkrepository/mac_x64/desktop/qt5_5152/qt.qt5.5152.clang_64/5.15.2-0-202011130601qtsvg-MacOS-MacOS_10_13-Clang-MacOS-MacOS_10_13-X86_64.7z`,
-                            skipSetup: checkIfExists(path.resolve(qtHome, 'lib', 'QtSvg.framework', 'QtSvg')),
-                        },
-                        {
-                            name: 'Qt Tools',
-                            link: `${MIRROR}/online/qtsdkrepository/mac_x64/desktop/qt5_5152/qt.qt5.5152.clang_64/5.15.2-0-202011130601qttools-MacOS-MacOS_10_13-Clang-MacOS-MacOS_10_13-X86_64.7z`,
-                            skipSetup: checkIfExists(path.resolve(qtHome, 'bin', 'macdeployqt')),
-                        },
-                    ],
-                };
-            }
         }
         case 'win32': {
             const qtHome = path.resolve(SETUP_DIR, QT_VERSION, 'msvc2019_64');
@@ -56,17 +42,17 @@ function getMiniQtConfig() {
                 artifacts: [
                     {
                         name: 'Qt Base',
-                        link: `${MIRROR}/online/qtsdkrepository/windows_x86/desktop/qt5_5152/qt.qt5.5152.win64_msvc2019_64/5.15.2-0-202011130602qtbase-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86_64.7z`,
+                        link: `${MIRROR}/online/qtsdkrepository/windows_x86/desktop/qt6_641/qt.qt6.641.win64_msvc2019_64/6.4.1-0-202211101254qtbase-Windows-Windows_10_21H2-MSVC2019-Windows-Windows_10_21H2-X86_64.7z`,
-                        skipSetup: checkIfExists(path.resolve(qtHome, 'bin', 'Qt5Core.dll')),
+                        skipSetup: checkIfExists(path.resolve(qtHome, 'bin', 'Qt6Core.dll')),
                     },
                     {
                         name: 'Qt SVG',
-                        link: `${MIRROR}/online/qtsdkrepository/windows_x86/desktop/qt5_5152/qt.qt5.5152.win64_msvc2019_64/5.15.2-0-202011130602qtsvg-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86_64.7z`,
+                        link: `${MIRROR}/online/qtsdkrepository/windows_x86/desktop/qt6_641/qt.qt6.641.win64_msvc2019_64/6.4.1-0-202211101254qtsvg-Windows-Windows_10_21H2-MSVC2019-Windows-Windows_10_21H2-X86_64.7z`,
-                        skipSetup: checkIfExists(path.resolve(qtHome, 'bin', 'Qt5Svg.dll')),
+                        skipSetup: checkIfExists(path.resolve(qtHome, 'bin', 'Qt6Svg.dll')),
                     },
                     {
                         name: 'Qt Tools',
-                        link: `${MIRROR}/online/qtsdkrepository/windows_x86/desktop/qt5_5152/qt.qt5.5152.win64_msvc2019_64/5.15.2-0-202011130602qttools-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86_64.7z`,
+                        link: `${MIRROR}/online/qtsdkrepository/windows_x86/desktop/qt6_641/qt.qt6.641.win64_msvc2019_64/6.4.1-0-202211101254qttools-Windows-Windows_10_21H2-MSVC2019-Windows-Windows_10_21H2-X86_64.7z`,
                         skipSetup: checkIfExists(path.resolve(qtHome, 'bin', 'windeployqt.exe')),
                     },
                 ],
@@ -79,17 +65,17 @@ function getMiniQtConfig() {
                 artifacts: [
                     {
                         name: 'Qt Base',
-                        link: `${MIRROR}/online/qtsdkrepository/linux_x64/desktop/qt5_5152/qt.qt5.5152.gcc_64/5.15.2-0-202011130601qtbase-Linux-RHEL_7_6-GCC-Linux-RHEL_7_6-X86_64.7z`,
+                        link: `${MIRROR}/online/qtsdkrepository/linux_x64/desktop/qt6_641/qt.qt6.641.gcc_64/6.4.1-0-202211101305qtbase-Linux-RHEL_8_4-GCC-Linux-RHEL_8_4-X86_64.7z`,
                         skipSetup: checkIfExists(path.resolve(qtHome, 'bin', 'moc')),
                     },
                     {
                         name: 'Qt SVG',
-                        link: `${MIRROR}/online/qtsdkrepository/linux_x64/desktop/qt5_5152/qt.qt5.5152.gcc_64/5.15.2-0-202011130601qtsvg-Linux-RHEL_7_6-GCC-Linux-RHEL_7_6-X86_64.7z`,
+                        link: `${MIRROR}/online/qtsdkrepository/linux_x64/desktop/qt6_641/qt.qt6.641.gcc_64/6.4.1-0-202211101305qtsvg-Linux-RHEL_8_4-GCC-Linux-RHEL_8_4-X86_64.7z`,
-                        skipSetup: checkIfExists(path.resolve(qtHome, 'lib', 'libQt5Svg.so')),
+                        skipSetup: checkIfExists(path.resolve(qtHome, 'lib', 'libQt6Svg.so')),
                     },
                     {
                         name: 'Qt ICU',
-                        link: `${MIRROR}/online/qtsdkrepository/linux_x64/desktop/qt5_5152/qt.qt5.5152.gcc_64/5.15.2-0-202011130601icu-linux-Rhel7.2-x64.7z`,
+                        link: `${MIRROR}/online/qtsdkrepository/linux_x64/desktop/qt6_641/qt.qt6.641.gcc_64/6.4.1-0-202211101305icu-linux-Rhel7.2-x64.7z`,
                         skipSetup: checkIfExists(path.resolve(qtHome, 'lib', 'libicuuc.so')),
                     },
                 ],
@@ -106,7 +92,7 @@ const miniQt = {
 
 const useCustomQt = Boolean(process.env.QT_INSTALL_DIR);
 const qtHome = useCustomQt ? process.env.QT_INSTALL_DIR : miniQt.qtHome;
-const qtCmakeDir = path.resolve(qtHome, 'lib', 'cmake', 'Qt5');
+const qtCmakeDir = path.resolve(qtHome, 'lib', 'cmake', 'Qt6');
 
 module.exports = {
     qtHome,

package.json

@@ -1,6 +1,6 @@
 {
     "name": "@nodegui/nodegui",
-    "version": "0.54.0",
+    "version": "0.59.0",
     "description": "A cross-platform library to build native desktop apps.",
     "main": "dist/index.js",
     "typings": "dist/index.d.ts",
@@ -14,18 +14,19 @@
         "url": "https://github.com/sponsors/a7ul"
     },
     "scripts": {
-        "dev": "cross-env npm run build && node ./scripts/qode.js dist/demo.js",
+        "dev": "npm run build && node ./scripts/qode.js dist/demo.js",
-        "build": "cross-env tsc && npm run build:addon",
+        "demo": "node ./scripts/qode.js dist/demo.js",
-        "install": "cross-env npm run setupqt && (node ./scripts/skip.js || npm run setupbinary || npm run build:addon)",
+        "build": "tsc && npm run build:addon",
-        "setupqt": "cross-env node ./scripts/setupMiniQt.js",
+        "install": "npm run setupqt && (node ./scripts/skip.js || npm run setupbinary || npm run build:addon)",
-        "setupbinary": "cross-env node ./scripts/setupBinary.js",
+        "setupqt": "node ./scripts/setupMiniQt.js",
+        "setupbinary": "node ./scripts/setupBinary.js",
         "build:addon": "cross-env CMAKE_BUILD_PARALLEL_LEVEL=8 cmake-js compile",
         "test": "node ./scripts/qode.js ./node_modules/jest/bin/jest -i",
-        "lint:cpp": "cross-env clang-format -i --glob=src/cpp/**/*.[h,c]*",
+        "lint:cpp": "clang-format -i --glob=src/cpp/**/*.[h,c]*",
-        "lint:ts": "cross-env tsc --noEmit && cross-env eslint './src/**/*.{ts,tsx,js,jsx}' --fix",
+        "lint:ts": "tsc --noEmit && eslint ./src --fix",
-        "docs": "cross-env typedoc && node ./website/docs/scripts/fixdocs.js",
+        "docs": "typedoc && node ./website/docs/scripts/fixdocs.js",
-        "qode": "cross-env node ./scripts/qode.js",
+        "qode": "node ./scripts/qode.js",
-        "prepublishOnly": "cross-env npm run build"
+        "prepublishOnly": "npm run build"
     },
     "engines": {
         "node": ">=14.x.x"
@@ -33,7 +34,7 @@
     "engineStrict": false,
     "dependencies": {
         "@nodegui/artifact-installer": "^1.1.0",
-        "@nodegui/qode": "^16.4.1",
+        "@nodegui/qode": "^18.12.1",
         "cmake-js": "^6.2.1",
         "cross-env": "^7.0.3",
         "cuid": "^2.1.8",
@@ -46,20 +47,20 @@
     },
     "devDependencies": {
         "@types/bindings": "^1.5.1",
-        "@types/jest": "^26.0.24",
+        "@types/jest": "29.2.4",
         "@types/node": "^16.4.13",
         "@typescript-eslint/eslint-plugin": "^4.29.0",
         "@typescript-eslint/parser": "^4.29.0",
         "clang-format": "^1.5.0",
-        "typedoc": "^0.17.8",
-        "typedoc-plugin-markdown": "^2.4.2",
         "eslint": "^7.32.0",
         "eslint-config-prettier": "^8.3.0",
         "eslint-plugin-prettier": "^3.4.0",
         "husky": "^7.0.1",
-        "jest": "^27.0.6",
+        "jest": "29.3.1",
         "prettier": "^2.3.2",
-        "ts-jest": "^27.0.4",
+        "ts-jest": "29.0.3",
+        "typedoc": "^0.17.8",
+        "typedoc-plugin-markdown": "^2.4.2",
         "typescript": "^4.3.5"
     },
     "binary": {

scripts/qode.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 
+var os = require('os');
 var path = require('path');
 var qodeConfig = require('@nodegui/qode');
 var managePath = require('manage-path');
@@ -11,6 +12,12 @@ var proc = require('child_process');
 var alterPath = managePath(process.env);
 alterPath.unshift(path.join(qtConfig.qtHome, 'bin'));
 
+// Add Qt's lib to LD_LIBRARY_PATH so linux can find the libs when bundled with webpack
+if(os.platform == 'linux') {
+    var oldLD_PATH = process.env.LD_LIBRARY_PATH ?? "";
+    process.env.LD_LIBRARY_PATH = oldLD_PATH + ":" + path.join(qtConfig.qtHome, 'lib');
+}
+
 var child = proc.spawn(qodeConfig.qodePath, process.argv.slice(2), {
     stdio: 'inherit',
     windowsHide: false,

src/cpp/include/nodegui/QtCore/QSize/qsize_wrap.h

@@ -19,9 +19,18 @@ class DLL_EXPORT QSizeWrap : public Napi::ObjectWrap<QSizeWrap> {
   ~QSizeWrap();
   QSize* getInternalInstance();
   // Wrapped methods
+  Napi::Value boundedTo(const Napi::CallbackInfo& info);
+  Napi::Value expandedTo(const Napi::CallbackInfo& info);
+  Napi::Value height(const Napi::CallbackInfo& info);
+  Napi::Value isEmpty(const Napi::CallbackInfo& info);
+  Napi::Value isNull(const Napi::CallbackInfo& info);
+  Napi::Value isValid(const Napi::CallbackInfo& info);
+  Napi::Value scale(const Napi::CallbackInfo& info);
+  Napi::Value scaled(const Napi::CallbackInfo& info);
   Napi::Value setHeight(const Napi::CallbackInfo& info);
   Napi::Value setWidth(const Napi::CallbackInfo& info);
-  Napi::Value height(const Napi::CallbackInfo& info);
+  Napi::Value transpose(const Napi::CallbackInfo& info);
+  Napi::Value transposed(const Napi::CallbackInfo& info);
   Napi::Value width(const Napi::CallbackInfo& info);
 };
 

src/cpp/include/nodegui/QtCore/QSizeF/qsizef_wrap.h

@@ -19,9 +19,19 @@ class DLL_EXPORT QSizeFWrap : public Napi::ObjectWrap<QSizeFWrap> {
   ~QSizeFWrap();
   QSizeF* getInternalInstance();
   // Wrapped methods
+  Napi::Value boundedTo(const Napi::CallbackInfo& info);
+  Napi::Value expandedTo(const Napi::CallbackInfo& info);
+  Napi::Value height(const Napi::CallbackInfo& info);
+  Napi::Value isEmpty(const Napi::CallbackInfo& info);
+  Napi::Value isNull(const Napi::CallbackInfo& info);
+  Napi::Value isValid(const Napi::CallbackInfo& info);
+  Napi::Value scale(const Napi::CallbackInfo& info);
+  Napi::Value scaled(const Napi::CallbackInfo& info);
   Napi::Value setHeight(const Napi::CallbackInfo& info);
   Napi::Value setWidth(const Napi::CallbackInfo& info);
-  Napi::Value height(const Napi::CallbackInfo& info);
+  Napi::Value toSize(const Napi::CallbackInfo& info);
+  Napi::Value transpose(const Napi::CallbackInfo& info);
+  Napi::Value transposed(const Napi::CallbackInfo& info);
   Napi::Value width(const Napi::CallbackInfo& info);
 };
 

src/cpp/include/nodegui/QtGui/QApplication/napplication.hpp

@@ -18,6 +18,14 @@ class DLL_EXPORT NApplication : public QApplication, public EventWidget {
     // Qt Connects: Implement all signal connects here
     QOBJECT_SIGNALS
 
+    QObject::connect(
+        this, &QGuiApplication::applicationDisplayNameChanged, [=]() {
+          Napi::Env env = this->emitOnNode.Env();
+          Napi::HandleScope scope(env);
+          this->emitOnNode.Call(
+              {Napi::String::New(env, "applicationDisplayNameChanged")});
+        });
+
     QObject::connect(
         this, &QGuiApplication::focusWindowChanged, [=](QWindow* focusWindow) {
           Napi::Env env = this->emitOnNode.Env();
@@ -25,6 +33,12 @@ class DLL_EXPORT NApplication : public QApplication, public EventWidget {
           this->emitOnNode.Call({Napi::String::New(env, "focusWindowChanged")});
         });
 
+    QObject::connect(this, &QGuiApplication::lastWindowClosed, [=]() {
+      Napi::Env env = this->emitOnNode.Env();
+      Napi::HandleScope scope(env);
+      this->emitOnNode.Call({Napi::String::New(env, "lastWindowClosed")});
+    });
+
     QObject::connect(
         this, &QGuiApplication::primaryScreenChanged, [=](QScreen* screen) {
           Napi::Env env = this->emitOnNode.Env();

src/cpp/include/nodegui/QtGui/QEvent/QInputMethodEvent/qinputmethodevent_wrap.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <napi.h>
+
+#include <QInputMethodEvent>
+
+#include "Extras/Export/export.h"
+#include "QtGui/QEvent/QEvent/qevent_macro.h"
+#include "core/Component/component_macro.h"
+
+class DLL_EXPORT QInputMethodEventWrap
+    : public Napi::ObjectWrap<QInputMethodEventWrap> {
+  COMPONENT_WRAPPED_METHODS_DECLARATION
+  QEVENT_WRAPPED_METHODS_DECLARATION
+
+ private:
+  QInputMethodEvent* instance;
+
+ public:
+  static Napi::Object init(Napi::Env env, Napi::Object exports);
+  QInputMethodEventWrap(const Napi::CallbackInfo& info);
+  ~QInputMethodEventWrap();
+  QInputMethodEvent* getInternalInstance();
+  // class constructor
+  static Napi::FunctionReference constructor;
+  // wrapped methods
+  Napi::Value commitString(const Napi::CallbackInfo& info);
+  Napi::Value preeditString(const Napi::CallbackInfo& info);
+  Napi::Value replacementLength(const Napi::CallbackInfo& info);
+  Napi::Value replacementStart(const Napi::CallbackInfo& info);
+  Napi::Value setCommitString(const Napi::CallbackInfo& info);
+};

src/cpp/include/nodegui/QtGui/QEvent/QInputMethodQueryEvent/qinputmethodqueryevent_wrap.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <napi.h>
+
+#include <QInputMethodQueryEvent>
+
+#include "Extras/Export/export.h"
+#include "QtGui/QEvent/QEvent/qevent_macro.h"
+#include "core/Component/component_macro.h"
+
+class DLL_EXPORT QInputMethodQueryEventWrap
+    : public Napi::ObjectWrap<QInputMethodQueryEventWrap> {
+  COMPONENT_WRAPPED_METHODS_DECLARATION
+  QEVENT_WRAPPED_METHODS_DECLARATION
+
+ private:
+  QInputMethodQueryEvent* instance;
+
+ public:
+  static Napi::Object init(Napi::Env env, Napi::Object exports);
+  QInputMethodQueryEventWrap(const Napi::CallbackInfo& info);
+  ~QInputMethodQueryEventWrap();
+  QInputMethodQueryEvent* getInternalInstance();
+  // class constructor
+  static Napi::FunctionReference constructor;
+  // wrapped methods
+  Napi::Value queries(const Napi::CallbackInfo& info);
+  Napi::Value setValue(const Napi::CallbackInfo& info);
+  Napi::Value value(const Napi::CallbackInfo& info);
+};

src/cpp/include/nodegui/QtGui/QIcon/qicon_wrap.h

@@ -20,10 +20,18 @@ class DLL_EXPORT QIconWrap : public Napi::ObjectWrap<QIconWrap> {
   ~QIconWrap();
   QIcon* getInternalInstance();
   // Wrapped methods
+  Napi::Value actualSize(const Napi::CallbackInfo& info);
+  Napi::Value addFile(const Napi::CallbackInfo& info);
+  Napi::Value addPixmap(const Napi::CallbackInfo& info);
+  Napi::Value availableSizes(const Napi::CallbackInfo& info);
   Napi::Value pixmap(const Napi::CallbackInfo& info);
   Napi::Value isMask(const Napi::CallbackInfo& info);
+  Napi::Value isNull(const Napi::CallbackInfo& info);
+  Napi::Value name(const Napi::CallbackInfo& info);
+  Napi::Value paint(const Napi::CallbackInfo& info);
   Napi::Value setIsMask(const Napi::CallbackInfo& info);
   Napi::Value cacheKey(const Napi::CallbackInfo& info);
+  Napi::Value swap(const Napi::CallbackInfo& info);
 };
 
 namespace StaticQIconWrapMethods {

src/cpp/include/nodegui/QtWidgets/QAbstractButton/qabstractbutton_macro.h

@@ -16,8 +16,7 @@
   QWIDGET_WRAPPED_METHODS_DECLARATION                        \
   Napi::Value animateClick(const Napi::CallbackInfo& info) { \
     Napi::Env env = info.Env();                              \
-    int msec = info[0].As<Napi::Number>().Int32Value();      \
+    this->instance->animateClick();                          \
-    this->instance->animateClick(msec);                      \
     return env.Null();                                       \
   }                                                          \
   Napi::Value click(const Napi::CallbackInfo& info) {        \

src/cpp/include/nodegui/QtWidgets/QAbstractItemView/qabstractitemview_macro.h

@@ -211,6 +211,16 @@
       this->instance->setItemDelegateForRow(row, delegate);                    \
     }                                                                          \
     return env.Null();                                                         \
+  }                                                                            \
+  Napi::Value sizeHintForIndex(const Napi::CallbackInfo& info) {               \
+    Napi::Env env = info.Env();                                                \
+    QModelIndexWrap* indexWrap =                                               \
+        Napi::ObjectWrap<QModelIndexWrap>::Unwrap(info[0].As<Napi::Object>()); \
+    QModelIndex* index = indexWrap->getInternalInstance();                     \
+    QSize result = this->instance->sizeHintForIndex(*index);                   \
+    auto resultInstance = QSizeWrap::constructor.New(                          \
+        {Napi::External<QSize>::New(env, new QSize(result))});                 \
+    return resultInstance;                                                     \
   }
 
 #define QABSTRACTITEMVIEW_WRAPPED_METHODS_DECLARATION                          \
@@ -235,6 +245,16 @@
             info[1].As<Napi::Number>().Int32Value());                          \
     this->instance->scrollTo(*index, hint);                                    \
     return env.Null();                                                         \
+  }                                                                            \
+  Napi::Value visualRect(const Napi::CallbackInfo& info) {                     \
+    Napi::Env env = info.Env();                                                \
+    QModelIndexWrap* indexWrap =                                               \
+        Napi::ObjectWrap<QModelIndexWrap>::Unwrap(info[0].As<Napi::Object>()); \
+    QModelIndex* index = indexWrap->getInternalInstance();                     \
+    QRect ret = this->instance->visualRect(*index);                            \
+    auto instance = QRectWrap::constructor.New(                                \
+        {Napi::External<QRect>::New(env, new QRect(ret))});                    \
+    return instance;                                                           \
   }
 
 #endif  // QABSTRACTITEMVIEW_WRAPPED_METHODS_DECLARATION
@@ -275,7 +295,9 @@
       InstanceMethod("setItemDelegateForColumn",                           \
                      &WidgetWrapName::setItemDelegateForColumn),           \
       InstanceMethod("setItemDelegateForRow",                              \
-                     &WidgetWrapName::setItemDelegateForRow),
+                     &WidgetWrapName::setItemDelegateForRow),              \
+      InstanceMethod("visualRect", &WidgetWrapName::visualRect),           \
+      InstanceMethod("sizeHintForIndex", &WidgetWrapName::sizeHintForIndex),
 
 #endif  // QABSTRACTITEMVIEW_WRAPPED_METHODS_EXPORT_DEFINE
 

src/cpp/include/nodegui/QtWidgets/QAbstractScrollArea/qabstractscrollarea_macro.h

@@ -60,6 +60,20 @@
     QWidget* viewPort = this->instance->viewport();                    \
     auto instance = WrapperCache::instance.getWrapper(env, viewPort);  \
     return instance;                                                   \
+  }                                                                    \
+                                                                       \
+  Napi::Value horizontalScrollBar(const Napi::CallbackInfo& info) {    \
+    Napi::Env env = info.Env();                                        \
+    QScrollBar* scrollBar = this->instance->horizontalScrollBar();     \
+    auto instance = WrapperCache::instance.getWrapper(env, scrollBar); \
+    return instance;                                                   \
+  }                                                                    \
+                                                                       \
+  Napi::Value verticalScrollBar(const Napi::CallbackInfo& info) {      \
+    Napi::Env env = info.Env();                                        \
+    QScrollBar* scrollBar = this->instance->verticalScrollBar();       \
+    auto instance = WrapperCache::instance.getWrapper(env, scrollBar); \
+    return instance;                                                   \
   }
 
 #endif  // QABSTRACTSCROLLAREA_WRAPPED_METHODS_DECLARATION
@@ -75,7 +89,10 @@
       InstanceMethod("setVerticalScrollBar",                                   \
                      &WidgetWrapName::setVerticalScrollBar),                   \
       InstanceMethod("setViewport", &WidgetWrapName::setViewport),             \
-      InstanceMethod("viewport", &WidgetWrapName::viewport),
+      InstanceMethod("viewport", &WidgetWrapName::viewport),                   \
+      InstanceMethod("horizontalScrollBar",                                    \
+                     &WidgetWrapName::horizontalScrollBar),                    \
+      InstanceMethod("verticalScrollBar", &WidgetWrapName::verticalScrollBar),
 
 #endif  // QABSTRACTSCROLLAREA_WRAPPED_METHODS_EXPORT_DEFINE
 

src/cpp/include/nodegui/QtWidgets/QButtonGroup/nbuttongroup.hpp

@@ -15,12 +15,30 @@ class DLL_EXPORT NButtonGroup : public QButtonGroup, public EventWidget {
   virtual void connectSignalsToEventEmitter() {
     QOBJECT_SIGNALS
     // Qt Connects: Implement all signal connects here
-    connect(this, QOverload<int>::of(&QButtonGroup::buttonClicked),
+    connect(this, &QButtonGroup::idClicked, [=](int id) {
-            [=](int id) {
+      Napi::Env env = this->emitOnNode.Env();
-              Napi::Env env = this->emitOnNode.Env();
+      Napi::HandleScope scope(env);
-              Napi::HandleScope scope(env);
+      this->emitOnNode.Call(
-              this->emitOnNode.Call({Napi::String::New(env, "buttonClicked"),
+          {Napi::String::New(env, "idClicked"), Napi::Number::New(env, id)});
-                                     Napi::Number::New(env, id)});
+    });
-            });
+    connect(this, &QButtonGroup::idPressed, [=](int id) {
+      Napi::Env env = this->emitOnNode.Env();
+      Napi::HandleScope scope(env);
+      this->emitOnNode.Call(
+          {Napi::String::New(env, "idPressed"), Napi::Number::New(env, id)});
+    });
+    connect(this, &QButtonGroup::idReleased, [=](int id) {
+      Napi::Env env = this->emitOnNode.Env();
+      Napi::HandleScope scope(env);
+      this->emitOnNode.Call(
+          {Napi::String::New(env, "idReleased"), Napi::Number::New(env, id)});
+    });
+    connect(this, &QButtonGroup::idToggled, [=](int id, bool checked) {
+      Napi::Env env = this->emitOnNode.Env();
+      Napi::HandleScope scope(env);
+      this->emitOnNode.Call({Napi::String::New(env, "idToggled"),
+                             Napi::Number::New(env, id),
+                             Napi::Boolean::New(env, checked)});
+    });
   }
 };

src/cpp/include/nodegui/QtWidgets/QColorDialog/qcolordialog_wrap.h

@@ -9,7 +9,7 @@
 #include "QtWidgets/QDialog/qdialog_macro.h"
 
 class DLL_EXPORT QColorDialogWrap : public Napi::ObjectWrap<QColorDialogWrap> {
-  QDIALOG_WRAPPED_METHODS_DECLARATION
+  QDIALOG_WRAPPED_METHODS_DECLARATION_NO_ACCEPT_OR_DONE
  private:
   QPointer<QColorDialog> instance;
 
@@ -24,6 +24,8 @@ class DLL_EXPORT QColorDialogWrap : public Napi::ObjectWrap<QColorDialogWrap> {
   Napi::Value selectedColor(const Napi::CallbackInfo& info);
   Napi::Value setOption(const Napi::CallbackInfo& info);
   Napi::Value testOption(const Napi::CallbackInfo& info);
+  Napi::Value accept(const Napi::CallbackInfo& info);
+  Napi::Value done(const Napi::CallbackInfo& info);
 };
 
 namespace StaticQColorDialogWrapMethods {

src/cpp/include/nodegui/QtWidgets/QDialog/qdialog_macro.h

@@ -10,39 +10,55 @@
 
     This macro adds common QDialog exported methods
     The exported methods are taken into this macro to avoid writing them in each
-   and every widget we export.
+    and every widget we export.
  */
 
+#ifndef QDIALOG_WRAPPED_METHODS_DECLARATION_NO_ACCEPT_OR_DONE
+#define QDIALOG_WRAPPED_METHODS_DECLARATION_NO_ACCEPT_OR_DONE \
+                                                              \
+  QWIDGET_WRAPPED_METHODS_DECLARATION                         \
+                                                              \
+  Napi::Value setResult(const Napi::CallbackInfo& info) {     \
+    Napi::Env env = info.Env();                               \
+    Napi::Number result = info[0].As<Napi::Number>();         \
+    this->instance->setResult(result.Int32Value());           \
+    return env.Null();                                        \
+  }                                                           \
+  Napi::Value result(const Napi::CallbackInfo& info) {        \
+    Napi::Env env = info.Env();                               \
+    int value = this->instance->result();                     \
+    return Napi::Value::From(env, value);                     \
+  }                                                           \
+  Napi::Value exec(const Napi::CallbackInfo& info) {          \
+    Napi::Env env = info.Env();                               \
+    int value = static_cast<int>(this->instance->exec());     \
+    return Napi::Number::From(env, value);                    \
+  }                                                           \
+  Napi::Value open(const Napi::CallbackInfo& info) {          \
+    Napi::Env env = info.Env();                               \
+    this->instance->open();                                   \
+    return env.Null();                                        \
+  }                                                           \
+  Napi::Value reject(const Napi::CallbackInfo& info) {        \
+    Napi::Env env = info.Env();                               \
+    this->instance->reject();                                 \
+    return env.Null();                                        \
+  }
+#endif
+
 #ifndef QDIALOG_WRAPPED_METHODS_DECLARATION
-#define QDIALOG_WRAPPED_METHODS_DECLARATION               \
+#define QDIALOG_WRAPPED_METHODS_DECLARATION             \
-                                                          \
+  QDIALOG_WRAPPED_METHODS_DECLARATION_NO_ACCEPT_OR_DONE \
-  QWIDGET_WRAPPED_METHODS_DECLARATION                     \
+  Napi::Value accept(const Napi::CallbackInfo& info) {  \
-                                                          \
+    Napi::Env env = info.Env();                         \
-  Napi::Value setResult(const Napi::CallbackInfo& info) { \
+    this->instance->accept();                           \
-    Napi::Env env = info.Env();                           \
+    return env.Null();                                  \
-    Napi::Number result = info[0].As<Napi::Number>();     \
+  }                                                     \
-    this->instance->setResult(result.Int32Value());       \
+  Napi::Value done(const Napi::CallbackInfo& info) {    \
-    return env.Null();                                    \
+    Napi::Env env = info.Env();                         \
-  }                                                       \
+    int r = info[0].As<Napi::Number>().Int32Value();    \
-  Napi::Value result(const Napi::CallbackInfo& info) {    \
+    this->instance->done(r);                            \
-    Napi::Env env = info.Env();                           \
+    return env.Null();                                  \
-    int value = this->instance->result();                 \
-    return Napi::Value::From(env, value);                 \
-  }                                                       \
-  Napi::Value exec(const Napi::CallbackInfo& info) {      \
-    Napi::Env env = info.Env();                           \
-    int value = static_cast<int>(this->instance->exec()); \
-    return Napi::Number::From(env, value);                \
-  }                                                       \
-  Napi::Value open(const Napi::CallbackInfo& info) {      \
-    Napi::Env env = info.Env();                           \
-    this->instance->open();                               \
-    return env.Null();                                    \
-  }                                                       \
-  Napi::Value reject(const Napi::CallbackInfo& info) {    \
-    Napi::Env env = info.Env();                           \
-    this->instance->reject();                             \
-    return env.Null();                                    \
   }
 #endif
 
@@ -54,7 +70,9 @@
       InstanceMethod("setResult", &DialogWrapName::setResult), \
       InstanceMethod("exec", &DialogWrapName::exec),           \
       InstanceMethod("open", &DialogWrapName::open),           \
-      InstanceMethod("reject", &DialogWrapName::reject),
+      InstanceMethod("reject", &DialogWrapName::reject),       \
+      InstanceMethod("accept", &DialogWrapName::accept),       \
+      InstanceMethod("done", &DialogWrapName::done),
 
 #endif  // QDIALOG_WRAPPED_METHODS_EXPORT_DEFINE
 

src/cpp/include/nodegui/QtWidgets/QErrorMessage/qerrormessage_wrap.h

@@ -10,7 +10,7 @@
 
 class DLL_EXPORT QErrorMessageWrap
     : public Napi::ObjectWrap<QErrorMessageWrap> {
-  QDIALOG_WRAPPED_METHODS_DECLARATION
+  QDIALOG_WRAPPED_METHODS_DECLARATION_NO_ACCEPT_OR_DONE
  private:
   QPointer<QErrorMessage> instance;
 
@@ -23,4 +23,6 @@ class DLL_EXPORT QErrorMessageWrap
   static Napi::FunctionReference constructor;
   // wrapped methods
   Napi::Value showMessage(const Napi::CallbackInfo& info);
+  Napi::Value accept(const Napi::CallbackInfo& info);
+  Napi::Value done(const Napi::CallbackInfo& info);
 };

src/cpp/include/nodegui/QtWidgets/QFileDialog/qfiledialog_wrap.h

@@ -9,7 +9,7 @@
 #include "QtWidgets/QFileDialog/nfiledialog.hpp"
 
 class DLL_EXPORT QFileDialogWrap : public Napi::ObjectWrap<QFileDialogWrap> {
-  QDIALOG_WRAPPED_METHODS_DECLARATION
+  QDIALOG_WRAPPED_METHODS_DECLARATION_NO_ACCEPT_OR_DONE
  private:
   QPointer<QFileDialog> instance;
 
@@ -28,4 +28,6 @@ class DLL_EXPORT QFileDialogWrap : public Napi::ObjectWrap<QFileDialogWrap> {
   Napi::Value setOption(const Napi::CallbackInfo& info);
   Napi::Value setNameFilter(const Napi::CallbackInfo& info);
   Napi::Value selectedFiles(const Napi::CallbackInfo& info);
+  Napi::Value accept(const Napi::CallbackInfo& info);
+  Napi::Value done(const Napi::CallbackInfo& info);
 };

src/cpp/include/nodegui/QtWidgets/QFontDialog/qfontdialog_wrap.h

@@ -9,7 +9,7 @@
 #include "QtWidgets/QFontDialog/nfontdialog.hpp"
 
 class DLL_EXPORT QFontDialogWrap : public Napi::ObjectWrap<QFontDialogWrap> {
-  QDIALOG_WRAPPED_METHODS_DECLARATION
+  QDIALOG_WRAPPED_METHODS_DECLARATION_NO_ACCEPT_OR_DONE
  private:
   QPointer<QFontDialog> instance;
 
@@ -24,4 +24,6 @@ class DLL_EXPORT QFontDialogWrap : public Napi::ObjectWrap<QFontDialogWrap> {
   Napi::Value selectedFont(const Napi::CallbackInfo& info);
   Napi::Value setOption(const Napi::CallbackInfo& info);
   Napi::Value testOption(const Napi::CallbackInfo& info);
+  Napi::Value accept(const Napi::CallbackInfo& info);
+  Napi::Value done(const Napi::CallbackInfo& info);
 };

src/cpp/include/nodegui/QtWidgets/QHeaderView/nheaderview.hpp

@@ -21,4 +21,7 @@ class DLL_EXPORT NHeaderView : public QHeaderView, public NodeWidget {
   void _protected_scrollTo(const QModelIndex &index, ScrollHint hint) {
     scrollTo(index, hint);
   }
+  QRect _protected_visualRect(const QModelIndex &index) const {
+    return visualRect(index);
+  }
 };

src/cpp/include/nodegui/QtWidgets/QHeaderView/qheaderview_wrap.h

@@ -43,6 +43,22 @@ class DLL_EXPORT QHeaderViewWrap : public Napi::ObjectWrap<QHeaderViewWrap> {
     return env.Null();
   }
 
+  Napi::Value visualRect(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    NHeaderView* wrapper = dynamic_cast<NHeaderView*>(this->instance.data());
+    if (wrapper) {
+      QModelIndexWrap* indexWrap =
+          Napi::ObjectWrap<QModelIndexWrap>::Unwrap(info[0].As<Napi::Object>());
+      QModelIndex* index = indexWrap->getInternalInstance();
+      QRect ret = wrapper->_protected_visualRect(*index);
+      auto instance = QRectWrap::constructor.New(
+          {Napi::External<QRect>::New(env, new QRect(ret))});
+      return instance;
+    }
+    return env.Null();
+  }
+
  private:
   QPointer<QHeaderView> instance;
 

src/cpp/include/nodegui/QtWidgets/QMessageBox/qmessagebox_wrap.h

@@ -23,8 +23,6 @@ class DLL_EXPORT QMessageBoxWrap : public Napi::ObjectWrap<QMessageBoxWrap> {
   // wrapped methods
   Napi::Value setDefaultButton(const Napi::CallbackInfo& info);
   Napi::Value addButton(const Napi::CallbackInfo& info);
-  Napi::Value accept(const Napi::CallbackInfo& info);
-  Napi::Value done(const Napi::CallbackInfo& info);
 };
 namespace StaticQMessageBoxWrapMethods {
 DLL_EXPORT Napi::Value about(const Napi::CallbackInfo& info);

src/cpp/include/nodegui/QtWidgets/QPainter/qpainter_wrap.h

@@ -20,38 +20,52 @@ class DLL_EXPORT QPainterWrap : public Napi::ObjectWrap<QPainterWrap> {
   // class constructor
   static Napi::FunctionReference constructor;
   // wrapped methods
-  Napi::Value drawArc(const Napi::CallbackInfo& info);
-  Napi::Value drawText(const Napi::CallbackInfo& info);
-  Napi::Value drawImage(const Napi::CallbackInfo& info);
-  Napi::Value drawPath(const Napi::CallbackInfo& info);
-  Napi::Value strokePath(const Napi::CallbackInfo& info);
   Napi::Value begin(const Napi::CallbackInfo& info);
   Napi::Value beginNativePainting(const Napi::CallbackInfo& info);
+  Napi::Value boundingRect(const Napi::CallbackInfo& info);
+  Napi::Value boundingRectF(const Napi::CallbackInfo& info);
+  Napi::Value compositionMode(const Napi::CallbackInfo& info);
+  Napi::Value drawArc(const Napi::CallbackInfo& info);
+  Napi::Value drawArcF(const Napi::CallbackInfo& info);
+  Napi::Value drawChord(const Napi::CallbackInfo& info);
+  Napi::Value drawChordF(const Napi::CallbackInfo& info);
+  Napi::Value drawConvexPolygon(const Napi::CallbackInfo& info);
+  Napi::Value drawConvexPolygonF(const Napi::CallbackInfo& info);
+  Napi::Value drawEllipse(const Napi::CallbackInfo& info);
+  Napi::Value drawEllipseF(const Napi::CallbackInfo& info);
+  Napi::Value drawImage(const Napi::CallbackInfo& info);
+  Napi::Value drawImageF(const Napi::CallbackInfo& info);
+  Napi::Value drawLine(const Napi::CallbackInfo& info);
+  Napi::Value drawLineF(const Napi::CallbackInfo& info);
+  Napi::Value drawPath(const Napi::CallbackInfo& info);
+  Napi::Value drawPie(const Napi::CallbackInfo& info);
+  Napi::Value drawPieF(const Napi::CallbackInfo& info);
+  Napi::Value drawPoint(const Napi::CallbackInfo& info);
+  Napi::Value drawPointF(const Napi::CallbackInfo& info);
+  Napi::Value drawRect(const Napi::CallbackInfo& info);
+  Napi::Value drawRectF(const Napi::CallbackInfo& info);
+  Napi::Value drawText(const Napi::CallbackInfo& info);
+  Napi::Value drawTextF(const Napi::CallbackInfo& info);
   Napi::Value end(const Napi::CallbackInfo& info);
   Napi::Value endNativePainting(const Napi::CallbackInfo& info);
+  Napi::Value eraseRect(const Napi::CallbackInfo& info);
+  Napi::Value eraseRectF(const Napi::CallbackInfo& info);
+  Napi::Value fillRect(const Napi::CallbackInfo& info);
+  Napi::Value fillRectF(const Napi::CallbackInfo& info);
+  Napi::Value opacity(const Napi::CallbackInfo& info);
+  Napi::Value restore(const Napi::CallbackInfo& info);
   Napi::Value rotate(const Napi::CallbackInfo& info);
+  Napi::Value save(const Napi::CallbackInfo& info);
+  Napi::Value scale(const Napi::CallbackInfo& info);
+  Napi::Value setBrush(const Napi::CallbackInfo& info);
+  Napi::Value setBrushOrigin(const Napi::CallbackInfo& info);
+  Napi::Value setBrushOriginF(const Napi::CallbackInfo& info);
+  Napi::Value setCompositionMode(const Napi::CallbackInfo& info);
   Napi::Value setFont(const Napi::CallbackInfo& info);
+  Napi::Value setOpacity(const Napi::CallbackInfo& info);
   Napi::Value setPen(const Napi::CallbackInfo& info);
   Napi::Value setRenderHint(const Napi::CallbackInfo& info);
   Napi::Value setTransform(const Napi::CallbackInfo& info);
-  Napi::Value setBrush(const Napi::CallbackInfo& info);
+  Napi::Value strokePath(const Napi::CallbackInfo& info);
-  Napi::Value drawLine(const Napi::CallbackInfo& info);
-  Napi::Value drawEllipse(const Napi::CallbackInfo& info);
-  Napi::Value drawPie(const Napi::CallbackInfo& info);
-  Napi::Value scale(const Napi::CallbackInfo& info);
   Napi::Value translate(const Napi::CallbackInfo& info);
-  Napi::Value drawConvexPolygon(const Napi::CallbackInfo& info);
-  Napi::Value save(const Napi::CallbackInfo& info);
-  Napi::Value restore(const Napi::CallbackInfo& info);
-  Napi::Value fillRect(const Napi::CallbackInfo& info);
-  Napi::Value compositionMode(const Napi::CallbackInfo& info);
-  Napi::Value setCompositionMode(const Napi::CallbackInfo& info);
-  Napi::Value opacity(const Napi::CallbackInfo& info);
-  Napi::Value setOpacity(const Napi::CallbackInfo& info);
-  Napi::Value drawPoint(const Napi::CallbackInfo& info);
-  Napi::Value drawRect(const Napi::CallbackInfo& info);
-  Napi::Value eraseRect(const Napi::CallbackInfo& info);
-  Napi::Value boundingRect(const Napi::CallbackInfo& info);
-  Napi::Value drawChord(const Napi::CallbackInfo& info);
-  Napi::Value setBrushOrigin(const Napi::CallbackInfo& info);
 };

src/cpp/include/nodegui/QtWidgets/QTableWidget/qtablewidget_wrap.h

@@ -80,4 +80,8 @@ class DLL_EXPORT QTableWidgetWrap : public Napi::ObjectWrap<QTableWidgetWrap> {
   Napi::Value setRowCount(const Napi::CallbackInfo& info);
   Napi::Value setSortingEnabled(const Napi::CallbackInfo& info);
   Napi::Value isSortingEnabled(const Napi::CallbackInfo& info);
+  Napi::Value clearSelection(const Napi::CallbackInfo& info);
+  Napi::Value selectAll(const Napi::CallbackInfo& info);
+  Napi::Value scrollToBottom(const Napi::CallbackInfo& info);
+  Napi::Value scrollToTop(const Napi::CallbackInfo& info);
 };

src/cpp/include/nodegui/QtWidgets/QTextBrowser/ntextbrowser.hpp

@@ -38,14 +38,13 @@ class DLL_EXPORT NTextBrowser : public QTextBrowser, public NodeWidget {
           this->emitOnNode.Call({Napi::String::New(env, "forwardAvailable"),
                                  Napi::Boolean::New(env, available)});
         });
-    QObject::connect(
+    QObject::connect(this, &QTextBrowser::highlighted, [=](const QUrl& link) {
-        this, QOverload<const QString&>::of(&QTextBrowser::highlighted),
+      Napi::Env env = this->emitOnNode.Env();
-        [=](const QString& link) {
+      Napi::HandleScope scope(env);
-          Napi::Env env = this->emitOnNode.Env();
+      this->emitOnNode.Call(
-          Napi::HandleScope scope(env);
+          {Napi::String::New(env, "highlighted"),
-          this->emitOnNode.Call({Napi::String::New(env, "highlighted"),
+           Napi::String::New(env, link.toString().toStdString())});
-                                 Napi::String::New(env, link.toStdString())});
+    });
-        });
     QObject::connect(this, &QTextBrowser::historyChanged, [=]() {
       Napi::Env env = this->emitOnNode.Env();
       Napi::HandleScope scope(env);

src/cpp/include/nodegui/QtWidgets/QWidget/nwidget.hpp

@@ -16,11 +16,15 @@ class DLL_EXPORT NWidget : public QWidget, public NodeWidget {
   // https://doc.qt.io/qt-5/stylesheet-reference.html
   void paintEvent(QPaintEvent* e) override {
     QStyleOption opt;
-    opt.init(this);
+    opt.initFrom(this);
     QPainter p(this);
     style()->drawPrimitive(QStyle::PE_Widget, &opt, &p, this);
     QWidget::paintEvent(e);
   }
 
   virtual void connectSignalsToEventEmitter() { QWIDGET_SIGNALS }
+
+  void _protected_updateMicroFocus(Qt::InputMethodQuery query) {
+    updateMicroFocus(query);
+  }
 };

src/cpp/include/nodegui/QtWidgets/QWidget/qwidget_macro.h

@@ -710,6 +710,71 @@
     QWidget* w = wWidgetWrap->getInternalInstance();                           \
     this->instance->stackUnder(w);                                             \
     return env.Null();                                                         \
+  }                                                                            \
+  Napi::Value colorCount(const Napi::CallbackInfo& info) {                     \
+    Napi::Env env = info.Env();                                                \
+    int result = this->instance->colorCount();                                 \
+    return Napi::Number::New(env, result);                                     \
+  }                                                                            \
+  Napi::Value depth(const Napi::CallbackInfo& info) {                          \
+    Napi::Env env = info.Env();                                                \
+    int result = this->instance->depth();                                      \
+    return Napi::Number::New(env, result);                                     \
+  }                                                                            \
+  Napi::Value devicePixelRatio(const Napi::CallbackInfo& info) {               \
+    Napi::Env env = info.Env();                                                \
+    qreal result = this->instance->devicePixelRatio();                         \
+    return Napi::Number::New(env, result);                                     \
+  }                                                                            \
+  Napi::Value devicePixelRatioF(const Napi::CallbackInfo& info) {              \
+    Napi::Env env = info.Env();                                                \
+    qreal result = this->instance->devicePixelRatioF();                        \
+    return Napi::Number::New(env, result);                                     \
+  }                                                                            \
+  Napi::Value heightMM(const Napi::CallbackInfo& info) {                       \
+    Napi::Env env = info.Env();                                                \
+    int result = this->instance->heightMM();                                   \
+    return Napi::Number::New(env, result);                                     \
+  }                                                                            \
+  Napi::Value logicalDpiX(const Napi::CallbackInfo& info) {                    \
+    Napi::Env env = info.Env();                                                \
+    int result = this->instance->logicalDpiX();                                \
+    return Napi::Number::New(env, result);                                     \
+  }                                                                            \
+  Napi::Value logicalDpiY(const Napi::CallbackInfo& info) {                    \
+    Napi::Env env = info.Env();                                                \
+    int result = this->instance->logicalDpiY();                                \
+    return Napi::Number::New(env, result);                                     \
+  }                                                                            \
+  Napi::Value paintingActive(const Napi::CallbackInfo& info) {                 \
+    Napi::Env env = info.Env();                                                \
+    bool result = this->instance->paintingActive();                            \
+    return Napi::Boolean::New(env, result);                                    \
+  }                                                                            \
+  Napi::Value physicalDpiX(const Napi::CallbackInfo& info) {                   \
+    Napi::Env env = info.Env();                                                \
+    int result = this->instance->physicalDpiX();                               \
+    return Napi::Number::New(env, result);                                     \
+  }                                                                            \
+  Napi::Value physicalDpiY(const Napi::CallbackInfo& info) {                   \
+    Napi::Env env = info.Env();                                                \
+    int result = this->instance->physicalDpiY();                               \
+    return Napi::Number::New(env, result);                                     \
+  }                                                                            \
+  Napi::Value widthMM(const Napi::CallbackInfo& info) {                        \
+    Napi::Env env = info.Env();                                                \
+    int result = this->instance->widthMM();                                    \
+    return Napi::Number::New(env, result);                                     \
+  }                                                                            \
+  Napi::Value updateMicroFocus(const Napi::CallbackInfo& info) {               \
+    Napi::Env env = info.Env();                                                \
+    NWidget* nwidget = dynamic_cast<NWidget*>(this->instance.data());          \
+    if (nwidget) {                                                             \
+      Qt::InputMethodQuery query = static_cast<Qt::InputMethodQuery>(          \
+          info[0].As<Napi::Number>().Int32Value());                            \
+      nwidget->_protected_updateMicroFocus(query);                             \
+    }                                                                          \
+    return env.Null();                                                         \
   }
 
 #endif  // QWIDGET_WRAPPED_METHODS_DECLARATION
@@ -818,7 +883,19 @@
       InstanceMethod("isAncestorOf", &WidgetWrapName::isAncestorOf),           \
       InstanceMethod("isEnabledTo", &WidgetWrapName::isEnabledTo),             \
       InstanceMethod("isVisibleTo", &WidgetWrapName::isVisibleTo),             \
-      InstanceMethod("stackUnder", &WidgetWrapName::stackUnder),
+      InstanceMethod("stackUnder", &WidgetWrapName::stackUnder),               \
+      InstanceMethod("colorCount", &WidgetWrapName::colorCount),               \
+      InstanceMethod("depth", &WidgetWrapName::depth),                         \
+      InstanceMethod("devicePixelRatio", &WidgetWrapName::devicePixelRatio),   \
+      InstanceMethod("devicePixelRatioF", &WidgetWrapName::devicePixelRatioF), \
+      InstanceMethod("heightMM", &WidgetWrapName::heightMM),                   \
+      InstanceMethod("logicalDpiX", &WidgetWrapName::logicalDpiX),             \
+      InstanceMethod("logicalDpiY", &WidgetWrapName::logicalDpiY),             \
+      InstanceMethod("paintingActive", &WidgetWrapName::paintingActive),       \
+      InstanceMethod("physicalDpiX", &WidgetWrapName::physicalDpiX),           \
+      InstanceMethod("physicalDpiY", &WidgetWrapName::physicalDpiY),           \
+      InstanceMethod("widthMM", &WidgetWrapName::widthMM),                     \
+      InstanceMethod("updateMicroFocus", &WidgetWrapName::updateMicroFocus),
 
 #endif  // QWIDGET_WRAPPED_METHODS_EXPORT_DEFINE
 

src/cpp/lib/Extras/Utils/nutils.cpp

@@ -71,10 +71,10 @@ QVariant* extrautils::convertToQVariant(Napi::Env& env, Napi::Value& value) {
   } else if (value.IsObject()) {
     Napi::Object object = value.As<Napi::Object>();
     std::string className = getNapiObjectClassName(object);
-    int typeId = QMetaType::type(className.c_str());
+    QMetaType type = QMetaType::fromName(className.c_str());
     ComponentWrap* componentWrap =
         Napi::ObjectWrap<ComponentWrap>::Unwrap(object);
-    return new QVariant(typeId, componentWrap->rawData);
+    return new QVariant(type, componentWrap->rawData);
 
   } else if (value.IsFunction()) {
     return new QVariant();

src/cpp/lib/QtCore/QSize/qsize_wrap.cpp

@@ -10,9 +10,18 @@ Napi::Object QSizeWrap::init(Napi::Env env, Napi::Object exports) {
   char CLASSNAME[] = "QSize";
   Napi::Function func = DefineClass(
       env, CLASSNAME,
-      {InstanceMethod("setHeight", &QSizeWrap::setHeight),
+      {InstanceMethod("boundedTo", &QSizeWrap::boundedTo),
-       InstanceMethod("setWidth", &QSizeWrap::setWidth),
+       InstanceMethod("expandedTo", &QSizeWrap::expandedTo),
+       InstanceMethod("isEmpty", &QSizeWrap::isEmpty),
+       InstanceMethod("isNull", &QSizeWrap::isNull),
+       InstanceMethod("isValid", &QSizeWrap::isValid),
        InstanceMethod("height", &QSizeWrap::height),
+       InstanceMethod("scale", &QSizeWrap::scale),
+       InstanceMethod("scaled", &QSizeWrap::scaled),
+       InstanceMethod("setHeight", &QSizeWrap::setHeight),
+       InstanceMethod("setWidth", &QSizeWrap::setWidth),
+       InstanceMethod("transpose", &QSizeWrap::transpose),
+       InstanceMethod("transposed", &QSizeWrap::transposed),
        InstanceMethod("width", &QSizeWrap::width),
        StaticMethod("fromQVariant", &StaticQSizeWrapMethods::fromQVariant),
        COMPONENT_WRAPPED_METHODS_EXPORT_DEFINE(QSizeWrap)});
@@ -64,7 +73,6 @@ Napi::Value QSizeWrap::width(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   return Napi::Value::From(env, this->instance->width());
 }
-
 Napi::Value StaticQSizeWrapMethods::fromQVariant(
     const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
@@ -77,3 +85,70 @@ Napi::Value StaticQSizeWrapMethods::fromQVariant(
       env, new QSize(size.width(), size.height()))});
   return instance;
 }
+Napi::Value QSizeWrap::boundedTo(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  QSizeWrap* otherSizeWrap =
+      Napi::ObjectWrap<QSizeWrap>::Unwrap(info[0].As<Napi::Object>());
+  QSize* otherSize = otherSizeWrap->getInternalInstance();
+  QSize result = this->instance->boundedTo(*otherSize);
+  auto resultInstance = QSizeWrap::constructor.New(
+      {Napi::External<QSize>::New(env, new QSize(result))});
+  return resultInstance;
+}
+Napi::Value QSizeWrap::expandedTo(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  QSizeWrap* otherSizeWrap =
+      Napi::ObjectWrap<QSizeWrap>::Unwrap(info[0].As<Napi::Object>());
+  QSize* otherSize = otherSizeWrap->getInternalInstance();
+  QSize result = this->instance->expandedTo(*otherSize);
+  auto resultInstance = QSizeWrap::constructor.New(
+      {Napi::External<QSize>::New(env, new QSize(result))});
+  return resultInstance;
+}
+Napi::Value QSizeWrap::isEmpty(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  bool result = this->instance->isEmpty();
+  return Napi::Boolean::New(env, result);
+}
+Napi::Value QSizeWrap::isNull(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  bool result = this->instance->isNull();
+  return Napi::Boolean::New(env, result);
+}
+Napi::Value QSizeWrap::isValid(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  bool result = this->instance->isValid();
+  return Napi::Boolean::New(env, result);
+}
+Napi::Value QSizeWrap::scale(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  int width = info[0].As<Napi::Number>().Int32Value();
+  int height = info[1].As<Napi::Number>().Int32Value();
+  Qt::AspectRatioMode mode =
+      static_cast<Qt::AspectRatioMode>(info[2].As<Napi::Number>().Int32Value());
+  this->instance->scale(width, height, mode);
+  return env.Null();
+}
+Napi::Value QSizeWrap::scaled(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  int width = info[0].As<Napi::Number>().Int32Value();
+  int height = info[1].As<Napi::Number>().Int32Value();
+  Qt::AspectRatioMode mode =
+      static_cast<Qt::AspectRatioMode>(info[2].As<Napi::Number>().Int32Value());
+  QSize result = this->instance->scaled(width, height, mode);
+  auto resultInstance = QSizeWrap::constructor.New(
+      {Napi::External<QSize>::New(env, new QSize(result))});
+  return resultInstance;
+}
+Napi::Value QSizeWrap::transpose(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  this->instance->transpose();
+  return env.Null();
+}
+Napi::Value QSizeWrap::transposed(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  QSize result = this->instance->transposed();
+  auto resultInstance = QSizeWrap::constructor.New(
+      {Napi::External<QSize>::New(env, new QSize(result))});
+  return resultInstance;
+}

src/cpp/lib/QtCore/QSizeF/qsizef_wrap.cpp

@@ -1,6 +1,7 @@
 #include "QtCore/QSizeF/qsizef_wrap.h"
 
 #include "Extras/Utils/nutils.h"
+#include "QtCore/QSize/qsize_wrap.h"
 #include "QtCore/QVariant/qvariant_wrap.h"
 
 Napi::FunctionReference QSizeFWrap::constructor;
@@ -10,9 +11,19 @@ Napi::Object QSizeFWrap::init(Napi::Env env, Napi::Object exports) {
   char CLASSNAME[] = "QSizeF";
   Napi::Function func = DefineClass(
       env, CLASSNAME,
-      {InstanceMethod("setHeight", &QSizeFWrap::setHeight),
+      {InstanceMethod("boundedTo", &QSizeFWrap::boundedTo),
-       InstanceMethod("setWidth", &QSizeFWrap::setWidth),
+       InstanceMethod("expandedTo", &QSizeFWrap::expandedTo),
        InstanceMethod("height", &QSizeFWrap::height),
+       InstanceMethod("isEmpty", &QSizeFWrap::isEmpty),
+       InstanceMethod("isNull", &QSizeFWrap::isNull),
+       InstanceMethod("isValid", &QSizeFWrap::isValid),
+       InstanceMethod("scale", &QSizeFWrap::scale),
+       InstanceMethod("scaled", &QSizeFWrap::scaled),
+       InstanceMethod("setHeight", &QSizeFWrap::setHeight),
+       InstanceMethod("setWidth", &QSizeFWrap::setWidth),
+       InstanceMethod("toSize", &QSizeFWrap::toSize),
+       InstanceMethod("transpose", &QSizeFWrap::transpose),
+       InstanceMethod("transposed", &QSizeFWrap::transposed),
        InstanceMethod("width", &QSizeFWrap::width),
        StaticMethod("fromQVariant", &StaticQSizeFWrapMethods::fromQVariant),
        COMPONENT_WRAPPED_METHODS_EXPORT_DEFINE(QSizeFWrap)});
@@ -77,3 +88,84 @@ Napi::Value StaticQSizeFWrapMethods::fromQVariant(
       env, new QSizeF(size.width(), size.height()))});
   return instance;
 }
+Napi::Value QSizeFWrap::boundedTo(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  QSizeFWrap* otherSizeWrap =
+      Napi::ObjectWrap<QSizeFWrap>::Unwrap(info[0].As<Napi::Object>());
+  QSizeF* otherSize = otherSizeWrap->getInternalInstance();
+  QSizeF result = this->instance->boundedTo(*otherSize);
+  auto resultInstance = QSizeFWrap::constructor.New(
+      {Napi::External<QSizeF>::New(env, new QSizeF(result))});
+  return resultInstance;
+}
+
+Napi::Value QSizeFWrap::expandedTo(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  QSizeFWrap* otherSizeWrap =
+      Napi::ObjectWrap<QSizeFWrap>::Unwrap(info[0].As<Napi::Object>());
+  QSizeF* otherSize = otherSizeWrap->getInternalInstance();
+  QSizeF result = this->instance->expandedTo(*otherSize);
+  auto resultInstance = QSizeFWrap::constructor.New(
+      {Napi::External<QSizeF>::New(env, new QSizeF(result))});
+  return resultInstance;
+}
+Napi::Value QSizeFWrap::isEmpty(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  bool result = this->instance->isEmpty();
+  return Napi::Boolean::New(env, result);
+}
+
+Napi::Value QSizeFWrap::isNull(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  bool result = this->instance->isNull();
+  return Napi::Boolean::New(env, result);
+}
+
+Napi::Value QSizeFWrap::isValid(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  bool result = this->instance->isValid();
+  return Napi::Boolean::New(env, result);
+}
+
+Napi::Value QSizeFWrap::scale(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  qreal width = info[0].As<Napi::Number>().FloatValue();
+  qreal height = info[1].As<Napi::Number>().FloatValue();
+  Qt::AspectRatioMode mode =
+      static_cast<Qt::AspectRatioMode>(info[2].As<Napi::Number>().Int32Value());
+  this->instance->scale(width, height, mode);
+  return env.Null();
+}
+
+Napi::Value QSizeFWrap::scaled(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  qreal width = info[0].As<Napi::Number>().FloatValue();
+  qreal height = info[1].As<Napi::Number>().FloatValue();
+  Qt::AspectRatioMode mode =
+      static_cast<Qt::AspectRatioMode>(info[2].As<Napi::Number>().Int32Value());
+  QSizeF result = this->instance->scaled(width, height, mode);
+  auto resultInstance = QSizeFWrap::constructor.New(
+      {Napi::External<QSizeF>::New(env, new QSizeF(result))});
+  return resultInstance;
+}
+Napi::Value QSizeFWrap::toSize(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  QSize result = this->instance->toSize();
+  auto resultInstance = QSizeWrap::constructor.New(
+      {Napi::External<QSize>::New(env, new QSize(result))});
+  return resultInstance;
+}
+
+Napi::Value QSizeFWrap::transpose(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  this->instance->transpose();
+  return env.Null();
+}
+
+Napi::Value QSizeFWrap::transposed(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  QSizeF result = this->instance->transposed();
+  auto resultInstance = QSizeFWrap::constructor.New(
+      {Napi::External<QSizeF>::New(env, new QSizeF(result))});
+  return resultInstance;
+}

src/cpp/lib/QtCore/QTime/qtime_wrap.cpp

@@ -12,7 +12,6 @@ Napi::Object QTimeWrap::init(Napi::Env env, Napi::Object exports) {
       env, CLASSNAME,
       {InstanceMethod("addMSecs", &QTimeWrap::addMSecs),
        InstanceMethod("addSecs", &QTimeWrap::addSecs),
-       InstanceMethod("elapsed", &QTimeWrap::elapsed),
        InstanceMethod("hour", &QTimeWrap::hour),
        InstanceMethod("isNull", &QTimeWrap::isNull),
        InstanceMethod("isValid", &QTimeWrap::isValid),
@@ -20,11 +19,9 @@ Napi::Object QTimeWrap::init(Napi::Env env, Napi::Object exports) {
        InstanceMethod("msec", &QTimeWrap::msec),
        InstanceMethod("msecsSinceStartOfDay", &QTimeWrap::msecsSinceStartOfDay),
        InstanceMethod("msecsTo", &QTimeWrap::msecsTo),
-       InstanceMethod("restart", &QTimeWrap::restart),
        InstanceMethod("second", &QTimeWrap::second),
        InstanceMethod("secsTo", &QTimeWrap::secsTo),
        InstanceMethod("setHMS", &QTimeWrap::setHMS),
-       InstanceMethod("start", &QTimeWrap::start),
        InstanceMethod("toString$", &QTimeWrap::toString),
        StaticMethod("currentTime", &StaticTimeWrapMethods::currentTime),
        StaticMethod("fromMSecsSinceStartOfDay",
@@ -81,11 +78,6 @@ Napi::Value QTimeWrap::addSecs(const Napi::CallbackInfo& info) {
   return instance;
 }
 
-Napi::Value QTimeWrap::elapsed(const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  return Napi::Value::From(env, this->instance->elapsed());
-}
-
 Napi::Value QTimeWrap::hour(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   return Napi::Value::From(env, this->instance->hour());
@@ -124,12 +116,6 @@ Napi::Value QTimeWrap::msecsTo(const Napi::CallbackInfo& info) {
   return Napi::Value::From(env, result);
 }
 
-Napi::Value QTimeWrap::restart(const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  int result = this->instance->restart();
-  return Napi::Value::From(env, result);
-}
-
 Napi::Value QTimeWrap::second(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   return Napi::Value::From(env, this->instance->second());
@@ -153,12 +139,6 @@ Napi::Value QTimeWrap::setHMS(const Napi::CallbackInfo& info) {
   return Napi::Value::From(env, result);
 }
 
-Napi::Value QTimeWrap::start(const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  this->instance->start();
-  return env.Null();
-}
-
 Napi::Value QTimeWrap::toString(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   QString result;

src/cpp/lib/QtGui/QEvent/QInputMethodEvent/qinputmethodevent_wrap.cpp

@@ -0,0 +1,90 @@
+#include "QtGui/QEvent/QInputMethodEvent/qinputmethodevent_wrap.h"
+
+#include <QString>
+
+#include "Extras/Utils/nutils.h"
+
+Napi::FunctionReference QInputMethodEventWrap::constructor;
+
+Napi::Object QInputMethodEventWrap::init(Napi::Env env, Napi::Object exports) {
+  Napi::HandleScope scope(env);
+  char CLASSNAME[] = "QInputMethodEvent";
+  Napi::Function func = DefineClass(
+      env, CLASSNAME,
+      {InstanceMethod("commitString", &QInputMethodEventWrap::commitString),
+       InstanceMethod("preeditString", &QInputMethodEventWrap::preeditString),
+       InstanceMethod("replacementLength",
+                      &QInputMethodEventWrap::replacementLength),
+       InstanceMethod("replacementStart",
+                      &QInputMethodEventWrap::replacementStart),
+       InstanceMethod("setCommitString",
+                      &QInputMethodEventWrap::setCommitString),
+
+       COMPONENT_WRAPPED_METHODS_EXPORT_DEFINE(QInputMethodEventWrap)
+           QEVENT_WRAPPED_METHODS_EXPORT_DEFINE(QInputMethodEventWrap)});
+  constructor = Napi::Persistent(func);
+  exports.Set(CLASSNAME, func);
+  return exports;
+}
+
+QInputMethodEvent* QInputMethodEventWrap::getInternalInstance() {
+  return this->instance;
+}
+
+QInputMethodEventWrap::QInputMethodEventWrap(const Napi::CallbackInfo& info)
+    : Napi::ObjectWrap<QInputMethodEventWrap>(info) {
+  Napi::Env env = info.Env();
+  if (info.Length() == 1) {
+    Napi::External<QInputMethodEvent> eventObject =
+        info[0].As<Napi::External<QInputMethodEvent>>();
+    this->instance = static_cast<QInputMethodEvent*>(eventObject.Data());
+  } else {
+    Napi::TypeError::New(env, "Wrong number of arguments")
+        .ThrowAsJavaScriptException();
+  }
+  this->rawData = extrautils::configureComponent(this->getInternalInstance());
+}
+
+QInputMethodEventWrap::~QInputMethodEventWrap() {
+  // Do not destroy instance here. It will be done by Qt Event loop.
+}
+
+Napi::Value QInputMethodEventWrap::setCommitString(
+    const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::String setCommitString = info[0].As<Napi::String>();
+  int replaceFrom = info[1].As<Napi::Number>().Int32Value();
+  int replaceLength = info[2].As<Napi::Number>().Int32Value();
+  this->instance->setCommitString(
+      QString::fromStdString(setCommitString.Utf8Value()), replaceFrom,
+      replaceLength);
+  return env.Null();
+}
+
+Napi::Value QInputMethodEventWrap::commitString(
+    const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  QString commitString = this->instance->commitString();
+  return Napi::Value::From(env, commitString.toStdString());
+}
+
+Napi::Value QInputMethodEventWrap::preeditString(
+    const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  QString preeditString = this->instance->preeditString();
+  return Napi::Value::From(env, preeditString.toStdString());
+}
+
+Napi::Value QInputMethodEventWrap::replacementLength(
+    const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  int x = this->instance->replacementLength();
+  return Napi::Number::From(env, x);
+}
+
+Napi::Value QInputMethodEventWrap::replacementStart(
+    const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  int x = this->instance->replacementStart();
+  return Napi::Number::From(env, x);
+}

src/cpp/lib/QtGui/QEvent/QInputMethodQueryEvent/qinputmethodqueryevent_wrap.cpp

@@ -0,0 +1,79 @@
+#include "QtGui/QEvent/QInputMethodQueryEvent/qinputmethodqueryevent_wrap.h"
+
+#include <QString>
+
+#include "Extras/Utils/nutils.h"
+#include "QtCore/QVariant/qvariant_wrap.h"
+
+Napi::FunctionReference QInputMethodQueryEventWrap::constructor;
+
+Napi::Object QInputMethodQueryEventWrap::init(Napi::Env env,
+                                              Napi::Object exports) {
+  Napi::HandleScope scope(env);
+  char CLASSNAME[] = "QInputMethodQueryEvent";
+  Napi::Function func = DefineClass(
+      env, CLASSNAME,
+      {InstanceMethod("queries", &QInputMethodQueryEventWrap::queries),
+       InstanceMethod("setValue", &QInputMethodQueryEventWrap::setValue),
+       InstanceMethod("value", &QInputMethodQueryEventWrap::value),
+
+       COMPONENT_WRAPPED_METHODS_EXPORT_DEFINE(QInputMethodQueryEventWrap)
+           QEVENT_WRAPPED_METHODS_EXPORT_DEFINE(QInputMethodQueryEventWrap)});
+  constructor = Napi::Persistent(func);
+  exports.Set(CLASSNAME, func);
+  return exports;
+}
+
+QInputMethodQueryEvent* QInputMethodQueryEventWrap::getInternalInstance() {
+  return this->instance;
+}
+
+QInputMethodQueryEventWrap::QInputMethodQueryEventWrap(
+    const Napi::CallbackInfo& info)
+    : Napi::ObjectWrap<QInputMethodQueryEventWrap>(info) {
+  Napi::Env env = info.Env();
+  if (info.Length() == 1) {
+    Napi::External<QInputMethodQueryEvent> eventObject =
+        info[0].As<Napi::External<QInputMethodQueryEvent>>();
+    this->instance = static_cast<QInputMethodQueryEvent*>(eventObject.Data());
+  } else {
+    Napi::TypeError::New(env, "Wrong number of arguments")
+        .ThrowAsJavaScriptException();
+  }
+  this->rawData = extrautils::configureComponent(this->getInternalInstance());
+}
+
+QInputMethodQueryEventWrap::~QInputMethodQueryEventWrap() {
+  // Do not destroy instance here. It will be done by Qt Event loop.
+}
+
+Napi::Value QInputMethodQueryEventWrap::queries(
+    const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Qt::InputMethodQueries queries = this->instance->queries();
+  return Napi::Number::From(env, queries.toInt());
+}
+
+Napi::Value QInputMethodQueryEventWrap::setValue(
+    const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Qt::InputMethodQuery query = static_cast<Qt::InputMethodQuery>(
+      info[0].As<Napi::Number>().Int32Value());
+  Napi::Value value = info[1];
+  QVariant* valueVariant = extrautils::convertToQVariant(env, value);
+  this->instance->setValue(query, *valueVariant);
+  delete valueVariant;
+  return env.Null();
+}
+
+Napi::Value QInputMethodQueryEventWrap::value(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  Qt::InputMethodQuery query = static_cast<Qt::InputMethodQuery>(
+      info[0].As<Napi::Number>().Int32Value());
+  QVariant value = this->instance->value(query);
+
+  auto instance = QVariantWrap::constructor.New(
+      {Napi::External<QVariant>::New(env, new QVariant(value))});
+  return instance;
+}

src/cpp/lib/QtGui/QFont/qfont_wrap.cpp

@@ -141,13 +141,13 @@ Napi::Value QFontWrap::stretch(const Napi::CallbackInfo& info) {
 Napi::Value QFontWrap::setWeight(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   int weight = info[0].As<Napi::Number>().Int32Value();
-  this->instance->setWeight(weight);
+  this->instance->setWeight(static_cast<QFont::Weight>(weight));
   return env.Null();
 }
 
 Napi::Value QFontWrap::weight(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
-  return Napi::Value::From(env, this->instance->weight());
+  return Napi::Value::From(env, static_cast<int>(this->instance->weight()));
 }
 
 Napi::Value QFontWrap::setItalic(const Napi::CallbackInfo& info) {

src/cpp/lib/QtGui/QIcon/qicon_wrap.cpp

@@ -1,8 +1,10 @@
 #include "QtGui/QIcon/qicon_wrap.h"
 
 #include "Extras/Utils/nutils.h"
+#include "QtCore/QSize/qsize_wrap.h"
 #include "QtCore/QVariant/qvariant_wrap.h"
 #include "QtGui/QPixmap/qpixmap_wrap.h"
+#include "QtWidgets/QPainter/qpainter_wrap.h"
 
 Napi::FunctionReference QIconWrap::constructor;
 
@@ -11,9 +13,17 @@ Napi::Object QIconWrap::init(Napi::Env env, Napi::Object exports) {
   char CLASSNAME[] = "QIcon";
   Napi::Function func = DefineClass(
       env, CLASSNAME,
-      {InstanceMethod("pixmap", &QIconWrap::pixmap),
+      {InstanceMethod("actualSize", &QIconWrap::actualSize),
+       InstanceMethod("addFile", &QIconWrap::addFile),
+       InstanceMethod("addPixmap", &QIconWrap::addPixmap),
+       InstanceMethod("availableSizes", &QIconWrap::availableSizes),
+       InstanceMethod("pixmap", &QIconWrap::pixmap),
        InstanceMethod("isMask", &QIconWrap::isMask),
+       InstanceMethod("isNull", &QIconWrap::isNull),
+       InstanceMethod("name", &QIconWrap::name),
+       InstanceMethod("paint", &QIconWrap::paint),
        InstanceMethod("setIsMask", &QIconWrap::setIsMask),
+       InstanceMethod("swap", &QIconWrap::swap),
        InstanceMethod("cacheKey", &QIconWrap::cacheKey),
        StaticMethod("fromQVariant", &StaticQIconWrapMethods::fromQVariant),
        COMPONENT_WRAPPED_METHODS_EXPORT_DEFINE(QIconWrap)});
@@ -30,9 +40,16 @@ QIconWrap::QIconWrap(const Napi::CallbackInfo& info)
       this->instance =
           std::unique_ptr<QIcon>(info[0].As<Napi::External<QIcon>>().Data());
     } else {
-      Napi::String url = info[0].As<Napi::String>();
+      if (info[0].IsString()) {
-      QString imageUrl = QString::fromUtf8(url.Utf8Value().c_str());
+        Napi::String url = info[0].As<Napi::String>();
-      this->instance = std::make_unique<QIcon>(imageUrl);
+        QString imageUrl = QString::fromUtf8(url.Utf8Value().c_str());
+        this->instance = std::make_unique<QIcon>(imageUrl);
+      } else {
+        QPixmapWrap* pixmapWrap =
+            Napi::ObjectWrap<QPixmapWrap>::Unwrap(info[0].As<Napi::Object>());
+        QPixmap* pixmap = pixmapWrap->getInternalInstance();
+        this->instance = std::make_unique<QIcon>(*pixmap);
+      }
     }
   } else if (info.Length() == 0) {
     this->instance = std::make_unique<QIcon>();
@@ -47,6 +64,64 @@ QIconWrap::~QIconWrap() { this->instance.reset(); }
 
 QIcon* QIconWrap::getInternalInstance() { return this->instance.get(); }
 
+Napi::Value QIconWrap::actualSize(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  QSizeWrap* sizeWrap =
+      Napi::ObjectWrap<QSizeWrap>::Unwrap(info[0].As<Napi::Object>());
+  QSize* size = sizeWrap->getInternalInstance();
+  QIcon::Mode mode =
+      static_cast<QIcon::Mode>(info[1].As<Napi::Number>().Int32Value());
+  QIcon::State state =
+      static_cast<QIcon::State>(info[2].As<Napi::Number>().Int32Value());
+  QSize result = this->instance->actualSize(*size, mode, state);
+  auto resultInstance = QSizeWrap::constructor.New(
+      {Napi::External<QSize>::New(env, new QSize(result))});
+  return resultInstance;
+}
+
+Napi::Value QIconWrap::addFile(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  std::string fileNameNapiText = info[0].As<Napi::String>().Utf8Value();
+  QString fileName = QString::fromUtf8(fileNameNapiText.c_str());
+  QSizeWrap* sizeWrap =
+      Napi::ObjectWrap<QSizeWrap>::Unwrap(info[1].As<Napi::Object>());
+  QSize* size = sizeWrap->getInternalInstance();
+  QIcon::Mode mode =
+      static_cast<QIcon::Mode>(info[2].As<Napi::Number>().Int32Value());
+  QIcon::State state =
+      static_cast<QIcon::State>(info[3].As<Napi::Number>().Int32Value());
+  this->instance->addFile(fileName, *size, mode, state);
+  return env.Null();
+}
+
+Napi::Value QIconWrap::addPixmap(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  QPixmapWrap* pixmapWrap =
+      Napi::ObjectWrap<QPixmapWrap>::Unwrap(info[0].As<Napi::Object>());
+  QPixmap* pixmap = pixmapWrap->getInternalInstance();
+  QIcon::Mode mode =
+      static_cast<QIcon::Mode>(info[1].As<Napi::Number>().Int32Value());
+  QIcon::State state =
+      static_cast<QIcon::State>(info[2].As<Napi::Number>().Int32Value());
+  this->instance->addPixmap(*pixmap, mode, state);
+  return env.Null();
+}
+
+Napi::Value QIconWrap::availableSizes(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  QIcon::Mode mode =
+      static_cast<QIcon::Mode>(info[0].As<Napi::Number>().Int32Value());
+  QIcon::State state =
+      static_cast<QIcon::State>(info[1].As<Napi::Number>().Int32Value());
+  QList<QSize> result = this->instance->availableSizes(mode, state);
+  Napi::Array resultArrayNapi = Napi::Array::New(env, result.size());
+  for (int i = 0; i < result.size(); i++) {
+    resultArrayNapi[i] = QSizeWrap::constructor.New(
+        {Napi::External<QSize>::New(env, new QSize(result[i]))});
+  }
+  return resultArrayNapi;
+}
+
 Napi::Value QIconWrap::pixmap(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   Napi::Number widthValue = info[0].As<Napi::Number>();
@@ -73,6 +148,37 @@ Napi::Value QIconWrap::pixmap(const Napi::CallbackInfo& info) {
   return instance;
 }
 
+Napi::Value QIconWrap::isNull(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  bool result = this->instance->isNull();
+  return Napi::Boolean::New(env, result);
+}
+
+Napi::Value QIconWrap::name(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  QString result = this->instance->name();
+  return Napi::String::New(env, result.toStdString());
+}
+
+Napi::Value QIconWrap::paint(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  QPainterWrap* painterWrap =
+      Napi::ObjectWrap<QPainterWrap>::Unwrap(info[0].As<Napi::Object>());
+  QPainter* painter = painterWrap->getInternalInstance();
+  int x = info[1].As<Napi::Number>().Int32Value();
+  int y = info[2].As<Napi::Number>().Int32Value();
+  int w = info[3].As<Napi::Number>().Int32Value();
+  int h = info[4].As<Napi::Number>().Int32Value();
+  Qt::Alignment alignment =
+      static_cast<Qt::Alignment>(info[5].As<Napi::Number>().Int32Value());
+  QIcon::Mode mode =
+      static_cast<QIcon::Mode>(info[6].As<Napi::Number>().Int32Value());
+  QIcon::State state =
+      static_cast<QIcon::State>(info[7].As<Napi::Number>().Int32Value());
+  this->instance->paint(painter, x, y, w, h, alignment, mode, state);
+  return env.Null();
+}
+
 Napi::Value QIconWrap::isMask(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   return Napi::Boolean::New(env, this->instance->isMask());
@@ -95,6 +201,15 @@ Napi::Value QIconWrap::cacheKey(const Napi::CallbackInfo& info) {
   return Napi::Value::From(env, this->instance->cacheKey());
 }
 
+Napi::Value QIconWrap::swap(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  QIconWrap* qiconWrap =
+      Napi::ObjectWrap<QIconWrap>::Unwrap(info[0].As<Napi::Object>());
+  QIcon* other = qiconWrap->getInternalInstance();
+  this->instance->swap(*other);
+  return env.Null();
+}
+
 Napi::Value StaticQIconWrapMethods::fromQVariant(
     const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();

src/cpp/lib/QtGui/QImage/qimage_wrap.cpp

@@ -453,7 +453,7 @@ void QImageWrap::setColorCount(const Napi::CallbackInfo& info) {
 
 void QImageWrap::setDevicePixelRatio(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
-  int64_t scaleFactor = info[0].As<Napi::Number>();
+  qreal scaleFactor = info[0].As<Napi::Number>();
   this->instance->setDevicePixelRatio(scaleFactor);
 }
 

src/cpp/lib/QtGui/QWindow/qwindow_wrap.cpp

@@ -71,6 +71,15 @@ void QWindowWrap::connectSignalsToEventEmitter() {
                                Napi::Number::New(env, visibility)});
       });
 
+  QObject::connect(
+      this->instance.data(), &QWindow::windowStateChanged,
+      [=](Qt::WindowState windowState) {
+        Napi::Env env = this->emitOnNode.Env();
+        Napi::HandleScope scope(env);
+        this->emitOnNode.Call({Napi::String::New(env, "windowStateChanged"),
+                               Napi::Number::New(env, windowState)});
+      });
+
   this->instance->installEventFilter(this);
 }
 

src/cpp/lib/QtWidgets/QColorDialog/qcolordialog_wrap.cpp

@@ -91,6 +91,20 @@ Napi::Value QColorDialogWrap::testOption(const Napi::CallbackInfo& info) {
   return Napi::Boolean::New(env, on);
 }
 
+Napi::Value QColorDialogWrap::accept(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  this->instance->accept();
+  return env.Null();
+}
+
+Napi::Value QColorDialogWrap::done(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::TypeError::New(
+      env, "NodeGui: QColorDialog: done() is protected and can't be called.")
+      .ThrowAsJavaScriptException();
+  return env.Null();
+}
+
 Napi::Value StaticQColorDialogWrapMethods::customColor(
     const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();

src/cpp/lib/QtWidgets/QErrorMessage/qerrormessage_wrap.cpp

@@ -64,3 +64,17 @@ Napi::Value QErrorMessageWrap::showMessage(const Napi::CallbackInfo& info) {
   this->instance->showMessage(message);
   return env.Null();
 }
+
+Napi::Value QErrorMessageWrap::accept(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  this->instance->accept();
+  return env.Null();
+}
+
+Napi::Value QErrorMessageWrap::done(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::TypeError::New(
+      env, "NodeGui: QErrorMessage: done() is protected and can't be called.")
+      .ThrowAsJavaScriptException();
+  return env.Null();
+}

src/cpp/lib/QtWidgets/QFileDialog/qfiledialog_wrap.cpp

@@ -134,3 +134,19 @@ Napi::Value QFileDialogWrap::selectedFiles(const Napi::CallbackInfo& info) {
   }
   return fileList;
 }
+
+Napi::Value QFileDialogWrap::accept(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::TypeError::New(
+      env, "NodeGui: QFileDialog: accept() is protected and can't be called.")
+      .ThrowAsJavaScriptException();
+  return env.Null();
+}
+
+Napi::Value QFileDialogWrap::done(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::TypeError::New(
+      env, "NodeGui: QFileDialog: done() is protected and can't be called.")
+      .ThrowAsJavaScriptException();
+  return env.Null();
+}

src/cpp/lib/QtWidgets/QFontDialog/qfontdialog_wrap.cpp

@@ -78,3 +78,17 @@ Napi::Value QFontDialogWrap::testOption(const Napi::CallbackInfo& info) {
       static_cast<QFontDialog::FontDialogOption>(option));
   return Napi::Boolean::New(env, on);
 }
+
+Napi::Value QFontDialogWrap::accept(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  this->instance->accept();
+  return env.Null();
+}
+
+Napi::Value QFontDialogWrap::done(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::TypeError::New(
+      env, "NodeGui: QFontDialog: done() is protected and can't be called.")
+      .ThrowAsJavaScriptException();
+  return env.Null();
+}

src/cpp/lib/QtWidgets/QMainWindow/qmainwindow_wrap.cpp

@@ -1,7 +1,6 @@
 #include "QtWidgets/QMainWindow/qmainwindow_wrap.h"
 
 #include <QApplication>
-#include <QDesktopWidget>
 
 #include "Extras/Utils/nutils.h"
 #include "QtWidgets/QMenuBar/qmenubar_wrap.h"
@@ -21,7 +20,6 @@ Napi::Object QMainWindowWrap::init(Napi::Env env, Napi::Object exports) {
        InstanceMethod("setMenuBar", &QMainWindowWrap::setMenuBar),
        InstanceMethod("menuBar", &QMainWindowWrap::menuBar),
        InstanceMethod("setMenuWidget", &QMainWindowWrap::setMenuWidget),
-       InstanceMethod("center", &QMainWindowWrap::center),
        InstanceMethod("setStatusBar", &QMainWindowWrap::setStatusBar),
        InstanceMethod("statusBar", &QMainWindowWrap::statusBar),
        QWIDGET_WRAPPED_METHODS_EXPORT_DEFINE(QMainWindowWrap)});
@@ -116,17 +114,6 @@ Napi::Value QMainWindowWrap::setMenuWidget(const Napi::CallbackInfo& info) {
   return env.Null();
 }
 
-Napi::Value QMainWindowWrap::center(const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  auto window = this->getInternalInstance();
-  // https://wiki.qt.io/How_to_Center_a_Window_on_the_Screen
-  window->setGeometry(
-      QStyle::alignedRect(Qt::LeftToRight, Qt::AlignCenter, window->size(),
-                          QApplication::desktop()->availableGeometry(window)));
-
-  return env.Null();
-}
-
 Napi::Value QMainWindowWrap::setStatusBar(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   Napi::Object statusBarArg = info[0].As<Napi::Object>();

src/cpp/lib/QtWidgets/QMessageBox/qmessagebox_wrap.cpp

@@ -16,8 +16,6 @@ Napi::Object QMessageBoxWrap::init(Napi::Env env, Napi::Object exports) {
       env, CLASSNAME,
       {InstanceMethod("setDefaultButton", &QMessageBoxWrap::setDefaultButton),
        InstanceMethod("addButton", &QMessageBoxWrap::addButton),
-       InstanceMethod("accept", &QMessageBoxWrap::accept),
-       InstanceMethod("done", &QMessageBoxWrap::done),
        StaticMethod("about", &StaticQMessageBoxWrapMethods::about),
        StaticMethod("aboutQt", &StaticQMessageBoxWrapMethods::aboutQt),
        QDIALOG_WRAPPED_METHODS_EXPORT_DEFINE(QMessageBoxWrap)});
@@ -79,17 +77,6 @@ Napi::Value QMessageBoxWrap::addButton(const Napi::CallbackInfo& info) {
   this->instance->addButton(btn, QMessageBox::ButtonRole(role));
   return env.Null();
 }
-Napi::Value QMessageBoxWrap::accept(const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  this->instance->accept();
-  return env.Null();
-}
-Napi::Value QMessageBoxWrap::done(const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  Napi::Number r = info[0].As<Napi::Number>();
-  this->instance->done(r.Int32Value());
-  return env.Null();
-}
 
 Napi::Value StaticQMessageBoxWrapMethods::about(
     const Napi::CallbackInfo& info) {

src/cpp/lib/QtWidgets/QPainter/qpainter_wrap.cpp

@@ -2,7 +2,9 @@
 
 #include "Extras/Utils/nutils.h"
 #include "QtCore/QPoint/qpoint_wrap.h"
+#include "QtCore/QPointF/qpointf_wrap.h"
 #include "QtCore/QRect/qrect_wrap.h"
+#include "QtCore/QRectF/qrectf_wrap.h"
 #include "QtGui/QBrush/qbrush_wrap.h"
 #include "QtGui/QColor/qcolor_wrap.h"
 #include "QtGui/QFont/qfont_wrap.h"
@@ -19,42 +21,55 @@ Napi::Object QPainterWrap::init(Napi::Env env, Napi::Object exports) {
   char CLASSNAME[] = "QPainter";
   Napi::Function func = DefineClass(
       env, CLASSNAME,
-      {InstanceMethod("drawArc", &QPainterWrap::drawArc),
+      {InstanceMethod("begin", &QPainterWrap::begin),
-       InstanceMethod("drawText", &QPainterWrap::drawText),
-       InstanceMethod("drawPath", &QPainterWrap::drawPath),
-       InstanceMethod("drawPie", &QPainterWrap::drawPie),
-       InstanceMethod("drawEllipse", &QPainterWrap::drawEllipse),
-       InstanceMethod("drawImage", &QPainterWrap::drawImage),
-       InstanceMethod("strokePath", &QPainterWrap::strokePath),
-       InstanceMethod("begin", &QPainterWrap::begin),
-       InstanceMethod("end", &QPainterWrap::end),
-       InstanceMethod("rotate", &QPainterWrap::rotate),
-       InstanceMethod("setFont", &QPainterWrap::setFont),
-       InstanceMethod("setPen", &QPainterWrap::setPen),
-       InstanceMethod("setBrush", &QPainterWrap::setBrush),
-       InstanceMethod("setTransform", &QPainterWrap::setTransform),
-       InstanceMethod("drawLine", &QPainterWrap::drawLine),
-       InstanceMethod("scale", &QPainterWrap::scale),
-       InstanceMethod("translate", &QPainterWrap::translate),
-       InstanceMethod("setRenderHint", &QPainterWrap::setRenderHint),
-       InstanceMethod("drawConvexPolygon", &QPainterWrap::drawConvexPolygon),
-       InstanceMethod("save", &QPainterWrap::save),
-       InstanceMethod("restore", &QPainterWrap::restore),
        InstanceMethod("beginNativePainting",
                       &QPainterWrap::beginNativePainting),
-       InstanceMethod("endNativePainting", &QPainterWrap::endNativePainting),
-       InstanceMethod("fillRect", &QPainterWrap::fillRect),
-       InstanceMethod("compositionMode", &QPainterWrap::compositionMode),
-       InstanceMethod("setCompositionMode", &QPainterWrap::setCompositionMode),
-       InstanceMethod("opacity", &QPainterWrap::opacity),
-       InstanceMethod("setOpacity", &QPainterWrap::setOpacity),
-       InstanceMethod("drawPoint", &QPainterWrap::drawPoint),
-       InstanceMethod("drawRect", &QPainterWrap::drawRect),
-       InstanceMethod("eraseRect", &QPainterWrap::eraseRect),
        InstanceMethod("boundingRect", &QPainterWrap::boundingRect),
+       InstanceMethod("boundingRectF", &QPainterWrap::boundingRectF),
+       InstanceMethod("compositionMode", &QPainterWrap::compositionMode),
+       InstanceMethod("drawArc", &QPainterWrap::drawArc),
+       InstanceMethod("drawArcF", &QPainterWrap::drawArcF),
        InstanceMethod("drawChord", &QPainterWrap::drawChord),
+       InstanceMethod("drawChordF", &QPainterWrap::drawChord),
+       InstanceMethod("drawConvexPolygon", &QPainterWrap::drawConvexPolygon),
+       InstanceMethod("drawConvexPolygonF", &QPainterWrap::drawConvexPolygonF),
+       InstanceMethod("drawEllipse", &QPainterWrap::drawEllipse),
+       InstanceMethod("drawEllipseF", &QPainterWrap::drawEllipseF),
+       InstanceMethod("drawImage", &QPainterWrap::drawImage),
+       InstanceMethod("drawImageF", &QPainterWrap::drawImageF),
+       InstanceMethod("drawLine", &QPainterWrap::drawLine),
+       InstanceMethod("drawLineF", &QPainterWrap::drawLineF),
+       InstanceMethod("drawPath", &QPainterWrap::drawPath),
        InstanceMethod("drawPie", &QPainterWrap::drawPie),
+       InstanceMethod("drawPieF", &QPainterWrap::drawPieF),
+       InstanceMethod("drawPoint", &QPainterWrap::drawPoint),
+       InstanceMethod("drawPointF", &QPainterWrap::drawPointF),
+       InstanceMethod("drawRect", &QPainterWrap::drawRect),
+       InstanceMethod("drawRectF", &QPainterWrap::drawRectF),
+       InstanceMethod("drawText", &QPainterWrap::drawText),
+       InstanceMethod("drawTextF", &QPainterWrap::drawTextF),
+       InstanceMethod("end", &QPainterWrap::end),
+       InstanceMethod("endNativePainting", &QPainterWrap::endNativePainting),
+       InstanceMethod("eraseRect", &QPainterWrap::eraseRect),
+       InstanceMethod("eraseRectF", &QPainterWrap::eraseRectF),
+       InstanceMethod("fillRect", &QPainterWrap::fillRect),
+       InstanceMethod("fillRectF", &QPainterWrap::fillRectF),
+       InstanceMethod("opacity", &QPainterWrap::opacity),
+       InstanceMethod("restore", &QPainterWrap::restore),
+       InstanceMethod("rotate", &QPainterWrap::rotate),
+       InstanceMethod("save", &QPainterWrap::save),
+       InstanceMethod("scale", &QPainterWrap::scale),
+       InstanceMethod("setBrush", &QPainterWrap::setBrush),
        InstanceMethod("setBrushOrigin", &QPainterWrap::setBrushOrigin),
+       InstanceMethod("setBrushOriginF", &QPainterWrap::setBrushOriginF),
+       InstanceMethod("setCompositionMode", &QPainterWrap::setCompositionMode),
+       InstanceMethod("setFont", &QPainterWrap::setFont),
+       InstanceMethod("setOpacity", &QPainterWrap::setOpacity),
+       InstanceMethod("setPen", &QPainterWrap::setPen),
+       InstanceMethod("setRenderHint", &QPainterWrap::setRenderHint),
+       InstanceMethod("setTransform", &QPainterWrap::setTransform),
+       InstanceMethod("strokePath", &QPainterWrap::strokePath),
+       InstanceMethod("translate", &QPainterWrap::translate),
        COMPONENT_WRAPPED_METHODS_EXPORT_DEFINE(QPainterWrap)});
   constructor = Napi::Persistent(func);
   exports.Set(CLASSNAME, func);
@@ -91,6 +106,17 @@ Napi::Value QPainterWrap::drawArc(const Napi::CallbackInfo& info) {
   this->instance->drawArc(x, y, width, height, startAngle, spanAngle);
   return env.Null();
 }
+Napi::Value QPainterWrap::drawArcF(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  qreal x = info[0].As<Napi::Number>().DoubleValue();
+  qreal y = info[1].As<Napi::Number>().DoubleValue();
+  qreal width = info[2].As<Napi::Number>().DoubleValue();
+  qreal height = info[3].As<Napi::Number>().DoubleValue();
+  int startAngle = info[4].As<Napi::Number>().Int32Value();
+  int spanAngle = info[5].As<Napi::Number>().Int32Value();
+  this->instance->drawArc(QRectF(x, y, width, height), startAngle, spanAngle);
+  return env.Null();
+}
 Napi::Value QPainterWrap::drawText(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   int x = info[0].As<Napi::Number>().Int32Value();
@@ -100,6 +126,15 @@ Napi::Value QPainterWrap::drawText(const Napi::CallbackInfo& info) {
   this->instance->drawText(x, y, QString::fromUtf8(text.c_str()));
   return env.Null();
 }
+Napi::Value QPainterWrap::drawTextF(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  qreal x = info[0].As<Napi::Number>().DoubleValue();
+  qreal y = info[1].As<Napi::Number>().DoubleValue();
+  Napi::String napiText = info[2].As<Napi::String>();
+  std::string text = napiText.Utf8Value();
+  this->instance->drawText(QPointF(x, y), QString::fromUtf8(text.c_str()));
+  return env.Null();
+}
 Napi::Value QPainterWrap::drawPath(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   Napi::Object pathObject = info[0].As<Napi::Object>();
@@ -189,11 +224,27 @@ Napi::Value QPainterWrap::drawEllipse(const Napi::CallbackInfo& info) {
         .ThrowAsJavaScriptException();
     return env.Null();
   }
+  int x = info[0].As<Napi::Number>().Int32Value();
+  int y = info[1].As<Napi::Number>().Int32Value();
+  int width = info[2].As<Napi::Number>().Int32Value();
+  int height = info[3].As<Napi::Number>().Int32Value();
+  this->instance->drawEllipse(x, y, width, height);
+
+  return env.Null();
+}
+
+Napi::Value QPainterWrap::drawEllipseF(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 4) {
+    Napi::TypeError::New(env, "Invalid number of arguments to drawEllipseF")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
   qreal x = info[0].As<Napi::Number>().DoubleValue();
   qreal y = info[1].As<Napi::Number>().DoubleValue();
   qreal width = info[2].As<Napi::Number>().DoubleValue();
   qreal height = info[3].As<Napi::Number>().DoubleValue();
-  this->instance->drawEllipse(x, y, width, height);
+  this->instance->drawEllipse(QRectF(x, y, width, height));
 
   return env.Null();
 }
@@ -217,7 +268,44 @@ Napi::Value QPainterWrap::drawImage(const Napi::CallbackInfo& info) {
   return env.Null();
 }
 
+Napi::Value QPainterWrap::drawImageF(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  qreal x = info[0].As<Napi::Number>().DoubleValue();
+  qreal y = info[1].As<Napi::Number>().DoubleValue();
+
+  Napi::Object imageObject = info[2].As<Napi::Object>();
+  QImageWrap* imageWrap = Napi::ObjectWrap<QImageWrap>::Unwrap(imageObject);
+  QImage* image = imageWrap->getInternalInstance();
+
+  qreal sx = info[3].As<Napi::Number>().DoubleValue();
+  qreal sy = info[4].As<Napi::Number>().DoubleValue();
+  qreal sw = info[5].As<Napi::Number>().DoubleValue();
+  qreal sh = info[6].As<Napi::Number>().DoubleValue();
+  this->instance->drawImage(QPointF(x, y), *image, QRectF(sx, sy, sw, sh));
+
+  return env.Null();
+}
+
 Napi::Value QPainterWrap::drawPie(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 6) {
+    Napi::TypeError::New(env, "Invalid number of arguments to drawPie")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  int x = info[0].As<Napi::Number>().Int32Value();
+  int y = info[1].As<Napi::Number>().Int32Value();
+  int width = info[2].As<Napi::Number>().Int32Value();
+  int height = info[3].As<Napi::Number>().Int32Value();
+  int startAngle = info[4].As<Napi::Number>().Int32Value();
+  int sweepLength = info[5].As<Napi::Number>().Int32Value();
+  this->instance->drawPie(x, y, width, height, startAngle, sweepLength);
+
+  return env.Null();
+}
+
+Napi::Value QPainterWrap::drawPieF(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   if (info.Length() < 6) {
     Napi::TypeError::New(env, "Invalid number of arguments to drawPie")
@@ -228,12 +316,13 @@ Napi::Value QPainterWrap::drawPie(const Napi::CallbackInfo& info) {
   qreal y = info[1].As<Napi::Number>().DoubleValue();
   qreal width = info[2].As<Napi::Number>().DoubleValue();
   qreal height = info[3].As<Napi::Number>().DoubleValue();
-  qreal startAngle = info[4].As<Napi::Number>().DoubleValue();
+  int startAngle = info[4].As<Napi::Number>().Int32Value();
-  qreal sweepLength = info[5].As<Napi::Number>().DoubleValue();
+  int sweepLength = info[5].As<Napi::Number>().Int32Value();
-  this->instance->drawPie(x, y, width, height, startAngle, sweepLength);
+  this->instance->drawPie(QRectF(x, y, width, height), startAngle, sweepLength);
 
   return env.Null();
 }
+
 Napi::Value QPainterWrap::drawLine(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   int x1 = info[0].As<Napi::Number>().Int32Value();
@@ -243,6 +332,15 @@ Napi::Value QPainterWrap::drawLine(const Napi::CallbackInfo& info) {
   this->instance->drawLine(x1, y1, x2, y2);
   return env.Null();
 }
+Napi::Value QPainterWrap::drawLineF(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  qreal x1 = info[0].As<Napi::Number>().DoubleValue();
+  qreal y1 = info[1].As<Napi::Number>().DoubleValue();
+  qreal x2 = info[2].As<Napi::Number>().DoubleValue();
+  qreal y2 = info[3].As<Napi::Number>().DoubleValue();
+  this->instance->drawLine(QLineF(x1, y1, x2, y2));
+  return env.Null();
+}
 Napi::Value QPainterWrap::scale(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   qreal sx = info[0].As<Napi::Number>().DoubleValue();
@@ -270,6 +368,19 @@ Napi::Value QPainterWrap::drawConvexPolygon(const Napi::CallbackInfo& info) {
   this->instance->drawConvexPolygon(polygon);
   return env.Null();
 }
+Napi::Value QPainterWrap::drawConvexPolygonF(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::Array pointsNapi = info[0].As<Napi::Array>();
+  QPolygonF polygon;
+  for (int i = 0; i < pointsNapi.Length(); i++) {
+    Napi::Object pointObject = pointsNapi.Get(i).As<Napi::Object>();
+    QPointFWrap* pointWrap = Napi::ObjectWrap<QPointFWrap>::Unwrap(pointObject);
+    QPointF* point = pointWrap->getInternalInstance();
+    polygon << *point;
+  }
+  this->instance->drawConvexPolygon(polygon);
+  return env.Null();
+}
 Napi::Value QPainterWrap::save(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   this->instance->save();
@@ -349,6 +460,18 @@ Napi::Value QPainterWrap::fillRect(const Napi::CallbackInfo& info) {
   this->instance->fillRect(x, y, width, height, *color);
   return env.Null();
 }
+Napi::Value QPainterWrap::fillRectF(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  qreal x = info[0].As<Napi::Number>().DoubleValue();
+  qreal y = info[1].As<Napi::Number>().DoubleValue();
+  qreal width = info[2].As<Napi::Number>().DoubleValue();
+  qreal height = info[3].As<Napi::Number>().DoubleValue();
+  Napi::Object colorObject = info[4].As<Napi::Object>();
+  QColorWrap* colorWrap = Napi::ObjectWrap<QColorWrap>::Unwrap(colorObject);
+  QColor* color = colorWrap->getInternalInstance();
+  this->instance->fillRect(QRectF(x, y, width, height), *color);
+  return env.Null();
+}
 Napi::Value QPainterWrap::compositionMode(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   uint mode = static_cast<uint>(this->instance->compositionMode());
@@ -379,6 +502,13 @@ Napi::Value QPainterWrap::drawPoint(const Napi::CallbackInfo& info) {
   this->instance->drawPoint(x, y);
   return env.Null();
 }
+Napi::Value QPainterWrap::drawPointF(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  qreal x = info[0].As<Napi::Number>().DoubleValue();
+  qreal y = info[1].As<Napi::Number>().DoubleValue();
+  this->instance->drawPoint(QPointF(x, y));
+  return env.Null();
+}
 Napi::Value QPainterWrap::drawRect(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   int x = info[0].As<Napi::Number>().Int32Value();
@@ -388,6 +518,15 @@ Napi::Value QPainterWrap::drawRect(const Napi::CallbackInfo& info) {
   this->instance->drawRect(x, y, width, height);
   return env.Null();
 }
+Napi::Value QPainterWrap::drawRectF(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  qreal x = info[0].As<Napi::Number>().DoubleValue();
+  qreal y = info[1].As<Napi::Number>().DoubleValue();
+  qreal width = info[2].As<Napi::Number>().DoubleValue();
+  qreal height = info[3].As<Napi::Number>().DoubleValue();
+  this->instance->drawRect(QRectF(x, y, width, height));
+  return env.Null();
+}
 Napi::Value QPainterWrap::eraseRect(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   int x = info[0].As<Napi::Number>().Int32Value();
@@ -397,6 +536,15 @@ Napi::Value QPainterWrap::eraseRect(const Napi::CallbackInfo& info) {
   this->instance->eraseRect(x, y, width, height);
   return env.Null();
 }
+Napi::Value QPainterWrap::eraseRectF(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  qreal x = info[0].As<Napi::Number>().DoubleValue();
+  qreal y = info[1].As<Napi::Number>().DoubleValue();
+  qreal width = info[2].As<Napi::Number>().DoubleValue();
+  qreal height = info[3].As<Napi::Number>().DoubleValue();
+  this->instance->eraseRect(QRectF(x, y, width, height));
+  return env.Null();
+}
 Napi::Value QPainterWrap::boundingRect(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   int x = info[0].As<Napi::Number>().Int32Value();
@@ -411,6 +559,20 @@ Napi::Value QPainterWrap::boundingRect(const Napi::CallbackInfo& info) {
       {Napi::External<QRect>::New(env, new QRect(result))});
   return resultInstance;
 }
+Napi::Value QPainterWrap::boundingRectF(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  qreal x = info[0].As<Napi::Number>().DoubleValue();
+  qreal y = info[1].As<Napi::Number>().DoubleValue();
+  qreal w = info[2].As<Napi::Number>().DoubleValue();
+  qreal h = info[3].As<Napi::Number>().DoubleValue();
+  int flags = info[4].As<Napi::Number>().Int32Value();
+  std::string textNapiText = info[5].As<Napi::String>().Utf8Value();
+  QString text = QString::fromUtf8(textNapiText.c_str());
+  QRectF result = this->instance->boundingRect(QRectF(x, y, w, h), flags, text);
+  auto resultInstance = QRectFWrap::constructor.New(
+      {Napi::External<QRectF>::New(env, new QRectF(result))});
+  return resultInstance;
+}
 Napi::Value QPainterWrap::drawChord(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   int x = info[0].As<Napi::Number>().Int32Value();
@@ -422,6 +584,17 @@ Napi::Value QPainterWrap::drawChord(const Napi::CallbackInfo& info) {
   this->instance->drawChord(x, y, width, height, startAngle, spanAngle);
   return env.Null();
 }
+Napi::Value QPainterWrap::drawChordF(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  qreal x = info[0].As<Napi::Number>().DoubleValue();
+  qreal y = info[1].As<Napi::Number>().DoubleValue();
+  qreal width = info[2].As<Napi::Number>().DoubleValue();
+  qreal height = info[3].As<Napi::Number>().DoubleValue();
+  int startAngle = info[4].As<Napi::Number>().Int32Value();
+  int spanAngle = info[5].As<Napi::Number>().Int32Value();
+  this->instance->drawChord(QRectF(x, y, width, height), startAngle, spanAngle);
+  return env.Null();
+}
 Napi::Value QPainterWrap::setBrushOrigin(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   int x = info[0].As<Napi::Number>().Int32Value();
@@ -429,3 +602,10 @@ Napi::Value QPainterWrap::setBrushOrigin(const Napi::CallbackInfo& info) {
   this->instance->setBrushOrigin(x, y);
   return env.Null();
 }
+Napi::Value QPainterWrap::setBrushOriginF(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  qreal x = info[0].As<Napi::Number>().DoubleValue();
+  qreal y = info[1].As<Napi::Number>().DoubleValue();
+  this->instance->setBrushOrigin(QPointF(x, y));
+  return env.Null();
+}

src/cpp/lib/QtWidgets/QTableWidget/qtablewidget_wrap.cpp

@@ -82,6 +82,10 @@ Napi::Object QTableWidgetWrap::init(Napi::Env env, Napi::Object exports) {
        InstanceMethod("visualColumn", &QTableWidgetWrap::visualColumn),
        InstanceMethod("visualItemRect", &QTableWidgetWrap::visualItemRect),
        InstanceMethod("visualRow", &QTableWidgetWrap::visualRow),
+       InstanceMethod("clearSelection", &QTableWidgetWrap::clearSelection),
+       InstanceMethod("selectAll", &QTableWidgetWrap::selectAll),
+       InstanceMethod("scrollToBottom", &QTableWidgetWrap::scrollToBottom),
+       InstanceMethod("scrollToTop", &QTableWidgetWrap::scrollToTop),
 
        QABSTRACTSCROLLAREA_WRAPPED_METHODS_EXPORT_DEFINE(QTableWidgetWrap)});
   constructor = Napi::Persistent(func);
@@ -647,3 +651,27 @@ Napi::Value QTableWidgetWrap::isSortingEnabled(const Napi::CallbackInfo& info) {
   bool enabled = this->instance->isSortingEnabled();
   return Napi::Boolean::New(env, enabled);
 }
+
+Napi::Value QTableWidgetWrap::clearSelection(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  this->instance->clearSelection();
+  return env.Null();
+}
+
+Napi::Value QTableWidgetWrap::selectAll(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  this->instance->clearSelection();
+  return env.Null();
+}
+
+Napi::Value QTableWidgetWrap::scrollToBottom(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  this->instance->scrollToBottom();
+  return env.Null();
+}
+
+Napi::Value QTableWidgetWrap::scrollToTop(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  this->instance->scrollToTop();
+  return env.Null();
+}

src/cpp/lib/core/Integration/integration.cpp

@@ -19,7 +19,6 @@ int QtRunLoopWrapper() {
 void integrate() {
   // Bootstrap Qt
   QCoreApplication::setAttribute(Qt::AA_ShareOpenGLContexts);
-  QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
   app = new NApplication(qode::qode_argc, qode::qode_argv);
   qode::InjectCustomRunLoop(&QtRunLoopWrapper);
   // Other init settings

src/cpp/lib/core/YogaWidget/nodestyle.cpp

@@ -50,7 +50,7 @@ std::unordered_map<std::string, int> NodeStyle::NodeWrap{
 
 NodeValueUnit NodeStyle::parseMeasurement(QString rawValue) {
   float value = std::stof(rawValue.toStdString());
-  if (rawValue.back() == "%") {
+  if (rawValue.back() == '%') {
     return NodeValueUnit(value, YGUnitPercent);
   }
   return NodeValueUnit(value, YGUnitPoint);

src/cpp/main.cpp

@@ -27,6 +27,8 @@
 #include "QtGui/QEvent/QDragLeaveEvent/qdragleaveevent_wrap.h"
 #include "QtGui/QEvent/QDragMoveEvent/qdragmoveevent_wrap.h"
 #include "QtGui/QEvent/QDropEvent/qdropevent_wrap.h"
+#include "QtGui/QEvent/QInputMethodEvent/qinputmethodevent_wrap.h"
+#include "QtGui/QEvent/QInputMethodQueryEvent/qinputmethodqueryevent_wrap.h"
 #include "QtGui/QEvent/QKeyEvent/qkeyevent_wrap.h"
 #include "QtGui/QEvent/QMouseEvent/qmouseevent_wrap.h"
 #include "QtGui/QEvent/QMoveEvent/qmoveevent_wrap.h"
@@ -246,6 +248,8 @@ Napi::Object Main(Napi::Env env, Napi::Object exports) {
   QResizeEventWrap::init(env, exports);
   QTimerEventWrap::init(env, exports);
   QAbstractItemDelegateWrap::init(env, exports);
+  QInputMethodEventWrap::init(env, exports);
+  QInputMethodQueryEventWrap::init(env, exports);
 
   // Test
   CacheTestQObjectWrap::init(env, exports);

src/index.ts

@@ -22,6 +22,8 @@ export { QFontDatabase, SystemFont, WritingSystem } from './lib/QtGui/QFontDatab
 export { QFontMetrics } from './lib/QtGui/QFontMetrics';
 export { QFontMetricsF } from './lib/QtGui/QFontMetricsF';
 // Events: Maybe a separate module ?
+export { QInputMethodEvent } from './lib/QtGui/QEvent/QInputMethodEvent';
+export { QInputMethodQueryEvent } from './lib/QtGui/QEvent/QInputMethodQueryEvent';
 export { QKeyEvent } from './lib/QtGui/QEvent/QKeyEvent';
 export { QMouseEvent } from './lib/QtGui/QEvent/QMouseEvent';
 export { QMoveEvent } from './lib/QtGui/QEvent/QMoveEvent';

src/lib/QtCore/QSize.ts

@@ -1,4 +1,5 @@
 import { NativeElement, Component } from '../core/Component';
+import { AspectRatioMode } from '../QtEnums';
 import addon from '../utils/addon';
 import { checkIfNativeElement } from '../utils/helpers';
 import { QVariant } from './QVariant';
@@ -17,17 +18,44 @@ export class QSize extends Component {
         }
         super(native);
     }
-    setWidth(width: number): void {
+    boundedTo(otherSize: QSize): QSize {
-        return this.native.setWidth(width);
+        return new QSize(this.native.boundedTo(otherSize));
     }
-    width(): number {
+    expandedTo(otherSize: QSize): QSize {
-        return this.native.width();
+        return new QSize(this.native.expandedTo(otherSize));
+    }
+    height(): number {
+        return this.native.height();
+    }
+    isEmpty(): boolean {
+        return this.native.isEmpty();
+    }
+    isNull(): boolean {
+        return this.native.isNull();
+    }
+    isValid(): boolean {
+        return this.native.isValid();
+    }
+    scale(width: number, height: number, mode: AspectRatioMode): void {
+        this.native.scale(width, height, mode);
+    }
+    scaled(width: number, height: number, mode: AspectRatioMode): QSize {
+        return new QSize(this.native.scaled(width, height, mode));
     }
     setHeight(height: number): void {
         return this.native.setHeight(height);
     }
-    height(): number {
+    setWidth(width: number): void {
-        return this.native.height();
+        return this.native.setWidth(width);
+    }
+    transpose(): void {
+        this.native.transpose();
+    }
+    transposed(): QSize {
+        return new QSize(this.native.transposed());
+    }
+    width(): number {
+        return this.native.width();
     }
     static fromQVariant(variant: QVariant): QSize {
         return new QSize(addon.QSize.fromQVariant(variant.native));

src/lib/QtCore/QSizeF.ts

@@ -1,6 +1,8 @@
 import { NativeElement, Component } from '../core/Component';
+import { AspectRatioMode } from '../QtEnums';
 import addon from '../utils/addon';
 import { checkIfNativeElement } from '../utils/helpers';
+import { QSize } from './QSize';
 import { QVariant } from './QVariant';
 
 export class QSizeF extends Component {
@@ -15,17 +17,47 @@ export class QSizeF extends Component {
         }
         super(native);
     }
-    setWidth(width: number): void {
+    boundedTo(otherSize: QSizeF): QSizeF {
-        return this.native.setWidth(width);
+        return new QSizeF(this.native.boundedTo(otherSize));
     }
-    width(): number {
+    expandedTo(otherSize: QSizeF): QSizeF {
-        return this.native.width();
+        return new QSizeF(this.native.expandedTo(otherSize));
+    }
+    height(): number {
+        return this.native.height();
+    }
+    isEmpty(): boolean {
+        return this.native.isEmpty();
+    }
+    isNull(): boolean {
+        return this.native.isNull();
+    }
+    isValid(): boolean {
+        return this.native.isValid();
+    }
+    scale(width: number, height: number, mode: AspectRatioMode): void {
+        this.native.scale(width, height, mode);
+    }
+    scaled(width: number, height: number, mode: AspectRatioMode): QSizeF {
+        return new QSizeF(this.native.scaled(width, height, mode));
     }
     setHeight(height: number): void {
         return this.native.setHeight(height);
     }
-    height(): number {
+    setWidth(width: number): void {
-        return this.native.height();
+        return this.native.setWidth(width);
+    }
+    toSize(): QSize {
+        return new QSize(this.native.toSize());
+    }
+    transpose(): void {
+        this.native.transpose();
+    }
+    transposed(): QSizeF {
+        return new QSizeF(this.native.transposed());
+    }
+    width(): number {
+        return this.native.width();
     }
     static fromQVariant(variant: QVariant): QSizeF {
         return new QSizeF(addon.QSizeF.fromQVariant(variant.native));

src/lib/QtCore/QTime.ts

@@ -23,9 +23,6 @@ export class QTime extends Component {
     addSecs(s: number): QTime {
         return new QTime(this.native.addSecs(s));
     }
-    elapsed(): number {
-        return this.native.elapsed();
-    }
     hour(): number {
         return this.native.hour();
     }
@@ -47,9 +44,6 @@ export class QTime extends Component {
     msecsTo(t: QTime): number {
         return this.native.msecsTo(t.native);
     }
-    restart(): number {
-        return this.native.restart();
-    }
     second(): number {
         return this.native.second();
     }
@@ -59,9 +53,6 @@ export class QTime extends Component {
     setHMS(h: number, m: number, s: number, ms = 0): boolean {
         return this.native.setHMS(h, m, s, ms);
     }
-    start(): void {
-        this.native.start();
-    }
     toString(format: string | DateFormat): string {
         return this.native.toString$(format);
     }

src/lib/QtCore/QVariant.ts

@@ -1,8 +1,9 @@
 import { NativeElement, Component } from '../core/Component';
 import addon from '../utils/addon';
 import { checkIfNativeElement } from '../utils/helpers';
+import { QRect } from './QRect';
 
-export type QVariantType = NativeElement | string | string[] | number | boolean;
+export type QVariantType = NativeElement | string | string[] | number | boolean | QRect;
 
 export class QVariant extends Component {
     constructor();
@@ -35,3 +36,14 @@ export class QVariant extends Component {
         return this.native.toStringList();
     }
 }
+
+/**
+ * Get the correct native object which should be passed down to the
+ * C++ wrapper from a QVariantType object.
+ */
+export function nativeObjectFromVariantType(obj: QVariantType): any {
+    if (obj instanceof QRect) {
+        return obj.native;
+    }
+    return obj;
+}

src/lib/QtEnums/InputMethodQuery/index.ts

@@ -1,6 +1,5 @@
 export enum InputMethodQuery {
     ImEnabled = 0x1,
-    ImMicroFocus = 0x2,
     ImCursorRectangle = 0x2,
     ImFont = 0x4,
     ImCursorPosition = 0x8,
@@ -17,6 +16,7 @@ export enum InputMethodQuery {
     ImEnterKeyType = 0x2000,
     ImAnchorRectangle = 0x4000,
     ImInputItemClipRectangle = 0x8000,
+    ImReadOnly = 0x10000,
     //Masks:
     ImQueryAll = 0xffffffff,
 }

src/lib/QtGui/QApplication.ts

@@ -105,7 +105,9 @@ export class QApplication extends QObject<QApplicationSignals> {
 wrapperCache.registerWrapper('QApplicationWrap', QApplication);
 
 export interface QApplicationSignals extends QObjectSignals {
+    applicationDisplayNameChanged: () => void;
     focusWindowChanged: () => void;
+    lastWindowClosed: () => void;
     primaryScreenChanged: (screen: QScreen) => void;
     screenAdded: (screen: QScreen) => void;
     screenRemoved: (screen: QScreen) => void;

src/lib/QtGui/QEvent/QInputMethodEvent.ts

@@ -0,0 +1,24 @@
+import addon from '../../utils/addon';
+import { NativeRawPointer } from '../../core/Component';
+import { QEvent } from './QEvent';
+
+export class QInputMethodEvent extends QEvent {
+    constructor(event: NativeRawPointer<'QEvent'>) {
+        super(new addon.QInputMethodEvent(event));
+    }
+    commitString(): string {
+        return this.native.commitString();
+    }
+    preeditString(): string {
+        return this.native.preeditString();
+    }
+    replacementLength(): number {
+        return this.native.replacementLength();
+    }
+    replacementStart(): number {
+        return this.native.replacementStart();
+    }
+    setCommitString(commitString: string, replaceFrom = 0, replaceLength = 0): void {
+        this.native.setCommitString(commitString, replaceFrom, replaceLength);
+    }
+}

src/lib/QtGui/QEvent/QInputMethodQueryEvent.ts

@@ -0,0 +1,28 @@
+import addon from '../../utils/addon';
+import { NativeRawPointer } from '../../core/Component';
+import { QVariant, QVariantType, nativeObjectFromVariantType } from '../../QtCore/QVariant';
+import { QEvent } from './QEvent';
+
+/**
+ * Note: Qt performs some default processing for `QInputMethodQueryEvents`.
+ * When attaching an event listener via `addEventListener()` use the
+ * options object to specify that you want to run after the default
+ * processing, otherwise your `setValue()` calls will be overwritten.
+ */
+export class QInputMethodQueryEvent extends QEvent {
+    constructor(event: NativeRawPointer<'QEvent'>) {
+        super(new addon.QInputMethodQueryEvent(event));
+    }
+
+    queries(): number /* InputMethodQueries */ {
+        return this.native.queries();
+    }
+
+    setValue(query: number /* InputMethodQuery */, value: QVariantType): void {
+        this.native.setValue(query, nativeObjectFromVariantType(value));
+    }
+
+    value(query: number /* InputMethodQuery */): QVariant {
+        return new QVariant(this.native.value(query));
+    }
+}

src/lib/QtGui/QFont.ts

@@ -100,13 +100,13 @@ export enum QFontCapitalization {
     Capitalize = 4,
 }
 export enum QFontWeight {
-    Thin = 0,
+    Thin = 100,
-    ExtraLight = 12,
+    ExtraLight = 200,
-    Light = 25,
+    Light = 300,
-    Normal = 50,
+    Normal = 400,
-    Medium = 57,
+    Medium = 500,
-    DemiBold = 63,
+    DemiBold = 600,
-    Bold = 75,
+    Bold = 700,
-    ExtraBold = 81,
+    ExtraBold = 800,
-    Black = 87,
+    Black = 900,
 }

src/lib/QtGui/QIcon.ts

@@ -3,9 +3,12 @@ import { Component, NativeElement } from '../core/Component';
 import { QPixmap } from './QPixmap';
 import { QVariant } from '../QtCore/QVariant';
 import { checkIfNativeElement } from '../utils/helpers';
+import { QSize } from '../QtCore/QSize';
+import { AlignmentFlag } from '../QtEnums/AlignmentFlag';
+import { QPainter } from '../QtWidgets/QPainter';
 
 /**
- 
+
 > The QIcon class provides scalable icons in different modes and states.
 
 * **This class is a JS wrapper around Qt's [QIcon class](https://doc.qt.io/qt-5/qicon.html)**
@@ -23,11 +26,14 @@ export class QIcon extends Component {
     constructor();
     constructor(native: NativeElement);
     constructor(filePath: string);
-    constructor(arg?: string | NativeElement) {
+    constructor(pixmap: QPixmap);
+    constructor(arg?: string | NativeElement | QPixmap) {
         let native: NativeElement;
         if (typeof arg === 'string') {
             const imagePath = arg;
             native = new addon.QIcon(imagePath);
+        } else if (arg instanceof QPixmap) {
+            native = new addon.QIcon(arg.native);
         } else if (checkIfNativeElement(arg)) {
             native = arg as NativeElement;
         } else {
@@ -35,26 +41,61 @@ export class QIcon extends Component {
         }
         super(native);
     }
-    pixmap(width: number, height: number, mode?: QIconMode, state?: QIconState): QPixmap {
+
-        let nativePixmap;
+    // *** Public Functions ***
-        if (mode && state) {
+    actualSize(size: QSize = null, mode = QIconMode.Normal, state = QIconState.Off): QSize {
-            nativePixmap = this.native.pixmap(width, height, mode, state);
+        return new QSize(this.native.actualSize(size ?? new QSize(), mode, state));
-        } else if (mode) {
-            nativePixmap = this.native.pixmap(width, height, mode);
-        } else {
-            nativePixmap = this.native.pixmap(width, height);
-        }
-        return new QPixmap(nativePixmap);
     }
-    isMask(): boolean {
+    // TODO: QSize 	actualSize(QWindow *window, const QSize &size, QIcon::Mode mode = Normal, QIcon::State state = Off) const
-        return this.native.isMask();
+    addFile(fileName: string, size: QSize = null, mode = QIconMode.Normal, state = QIconState.Off): void {
+        this.native.addFile(fileName, (size ?? new QSize()).native, mode, state);
     }
-    setIsMask(isMask: boolean): void {
+    addPixmap(pixmap: QPixmap, mode = QIconMode.Normal, state = QIconState.Off): void {
-        this.native.setIsMask(isMask);
+        this.native.addPixmap(pixmap.native, mode, state);
+    }
+    availableSizes(mode = QIconMode.Normal, state = QIconState.Off): QSize[] {
+        const methodResult = this.native.availableSizes(mode, state);
+        return methodResult.map((item: any) => new QSize(item));
     }
     cacheKey(): number {
         return this.native.cacheKey();
     }
+    isMask(): boolean {
+        return this.native.isMask();
+    }
+    isNull(): boolean {
+        return this.native.isNull();
+    }
+    name(): string {
+        return this.native.name();
+    }
+    // TODO: void 	paint(QPainter *painter, const QRect &rect, Qt::Alignment alignment = Qt::AlignCenter, QIcon::Mode mode = Normal, QIcon::State state = Off) const
+    paint(
+        painter: QPainter,
+        x: number,
+        y: number,
+        w: number,
+        h: number,
+        alignment = AlignmentFlag.AlignCenter,
+        mode = QIconMode.Normal,
+        state = QIconState.Off,
+    ): void {
+        this.native.paint(painter.native, x, y, w, h, alignment, mode, state);
+    }
+    // TODO: QPixmap 	pixmap(const QSize &size, QIcon::Mode mode = Normal, QIcon::State state = Off) const
+    pixmap(width: number, height: number, mode = QIconMode.Normal, state = QIconState.Off): QPixmap {
+        const nativePixmap = this.native.pixmap(width, height, mode, state);
+        return new QPixmap(nativePixmap);
+    }
+    // TODO: QPixmap 	pixmap(int extent, QIcon::Mode mode = Normal, QIcon::State state = Off) const
+    // TODO: QPixmap 	pixmap(QWindow *window, const QSize &size, QIcon::Mode mode = Normal, QIcon::State state = Off) const
+    setIsMask(isMask: boolean): void {
+        this.native.setIsMask(isMask);
+    }
+    swap(other: QIcon): void {
+        this.native.swap(other.native);
+    }
+    // TODO: QVariant 	operator QVariant() const
     static fromQVariant(variant: QVariant): QIcon {
         return new QIcon(addon.QIcon.fromQVariant(variant.native));
     }

src/lib/QtGui/QWindow.ts

@@ -74,6 +74,7 @@ wrapperCache.registerWrapper('QWindowWrap', QWindow);
 export interface QWindowSignals extends QObjectSignals {
     screenChanged: (screen: QScreen) => void;
     visibilityChanged: (visibility: Visibility) => void;
+    windowStateChanged: (windowState: WindowState) => void;
 }
 
 registerNativeWrapFunction('QWindowWrap', (native: any) => {

src/lib/QtWidgets/QAbstractButton.ts

@@ -14,8 +14,8 @@ It is inherited by QCheckBox, QPushButton, QRadioButton, and QToolButton.
 
  */
 export abstract class QAbstractButton<Signals extends QAbstractButtonSignals> extends QWidget<Signals> {
-    animateClick(msec: number): void {
+    animateClick(): void {
-        this.native.animateClick(msec);
+        this.native.animateClick();
     }
     click(): void {
         this.native.click();

src/lib/QtWidgets/QAbstractItemView.ts

@@ -10,6 +10,7 @@ import { QItemSelectionModel } from '../QtCore/QItemSelectionModel';
 import { NativeElement } from '../core/Component';
 import { wrapperCache } from '../core/WrapperCache';
 import { QAbstractItemDelegate } from './QAbstractItemDelegate';
+import { QRect } from '../QtCore/QRect';
 
 /**
 
@@ -197,9 +198,11 @@ export abstract class QAbstractItemView<Signals extends QAbstractItemViewSignals
     showDropIndicator(): boolean {
         return this.property('showDropIndicator').toBool();
     }
-    // TODO: virtual int 	sizeHintForColumn(int column) const
+    // TODO: virtual int    sizeHintForColumn(int column) const
-    // TODO: QSize 	sizeHintForIndex(const QModelIndex &index) const
+    sizeHintForIndex(index: QModelIndex): QSize {
-    // TODO: virtual int 	sizeHintForRow(int row) const
+        return new QSize(this.native.sizeHintForIndex(index.native));
+    }
+    // TODO: virtual int    sizeHintForRow(int row) const
     tabKeyNavigation(): boolean {
         return this.property('tabKeyNavigation').toBool();
     }
@@ -209,7 +212,9 @@ export abstract class QAbstractItemView<Signals extends QAbstractItemViewSignals
     verticalScrollMode(): ScrollMode {
         return this.property('verticalScrollMode').toInt();
     }
-    // TODO: virtual QRect 	visualRect(const QModelIndex &index) const = 0
+    visualRect(index: QModelIndex): QRect {
+        return new QRect(this.native.visualRect(index.native));
+    }
 
     // *** Public Slots ***
     clearSelection(): void {

src/lib/QtWidgets/QAbstractScrollArea.ts

@@ -19,11 +19,8 @@ QAbstractScrollArea will list all methods and properties that are common to all
 
  */
 export abstract class QAbstractScrollArea<Signals extends QAbstractScrollAreaSignals> extends QFrame<Signals> {
-    setViewport(widget: QWidget): void {
+    horizontalScrollBar(): QScrollBar {
-        this.native.setViewport(widget.native);
+        return wrapperCache.getWrapper(this.native.horizontalScrollBar()) as QScrollBar;
-    }
-    viewport(): QWidget {
-        return wrapperCache.getWrapper(this.native.viewport()) as QWidget;
     }
     maximumViewportSize(): QSize {
         return this.native.maximumViewportSize();
@@ -34,12 +31,21 @@ export abstract class QAbstractScrollArea<Signals extends QAbstractScrollAreaSig
     setHorizontalScrollBarPolicy(policy: ScrollBarPolicy): void {
         this.native.setProperty('horizontalScrollBarPolicy', policy);
     }
+    setViewport(widget: QWidget): void {
+        this.native.setViewport(widget.native);
+    }
     setVerticalScrollBar(scrollBar: QScrollBar): void {
         this.native.setVerticalScrollBar(scrollBar.native);
     }
     setVerticalScrollBarPolicy(policy: ScrollBarPolicy): void {
         this.native.setProperty('verticalScrollBarPolicy', policy);
     }
+    verticalScrollBar(): QScrollBar {
+        return wrapperCache.getWrapper(this.native.verticalScrollBar()) as QScrollBar;
+    }
+    viewport(): QWidget {
+        return wrapperCache.getWrapper(this.native.viewport()) as QWidget;
+    }
 }
 
 export type QAbstractScrollAreaSignals = QFrameSignals;

src/lib/QtWidgets/QButtonGroup.ts

@@ -7,7 +7,10 @@ import { checkIfNativeElement } from '../utils/helpers';
 import { wrapperCache } from '../core/WrapperCache';
 
 export interface QButtonGroupSignals extends QObjectSignals {
-    buttonClicked: (id?: number) => void;
+    idClicked: (id: number) => void;
+    idPressed: (id: number) => void;
+    idReleased: (id: number) => void;
+    idToggled: (id: number, checked: boolean) => void;
 }
 
 export class QButtonGroup extends QObject<any> {

src/lib/QtWidgets/QDialog.ts

@@ -43,6 +43,12 @@ export class QDialog<Signals extends QDialogSignals = QDialogSignals> extends QW
     isSizeGripEnabled(): boolean {
         return this.property('sizeGripEnabled').toBool();
     }
+    accept(): void {
+        this.native.accept();
+    }
+    done(r: number): void {
+        this.native.done(r);
+    }
     exec(): DialogCode {
         return this.native.exec();
     }

src/lib/QtWidgets/QMainWindow.ts

@@ -89,9 +89,6 @@ export class QMainWindow extends QWidget<QMainWindowSignals> {
         }
         return super.layout();
     }
-    center(): void {
-        this.native.center();
-    }
 
     /**
      * Sets the status bar for the main window to statusbar.

src/lib/QtWidgets/QPainter.ts

@@ -10,6 +10,7 @@ import { QWidget } from './QWidget';
 import { QImage } from '../QtGui/QImage';
 import { QFont } from '../QtGui/QFont';
 import { QRect } from '../QtCore/QRect';
+import { QRectF } from '../QtCore/QRectF';
 
 /**
 
@@ -46,7 +47,7 @@ win.show();
 https://github.com/nodegui/examples/blob/master/nodegui/custom-native-widget-qpainter
 */
 export class QPainter extends Component {
-    constructor(device?: Component) {
+    constructor(device?: QWidget) {
         let native: NativeElement;
         if (device) {
             native = new addon.QPainter(device.native);
@@ -74,6 +75,12 @@ export class QPainter extends Component {
     boundingRect(x: number, y: number, w: number, h: number, flags: number, text: string): QRect {
         return new QRect(this.native.boundingRect(x, y, w, h, flags, text));
     }
+    /**
+     * Version of boundingRect() which takes floating point parameters.
+     */
+    boundingRectF(x: number, y: number, w: number, h: number, flags: number, text: string): QRect {
+        return new QRectF(this.native.boundingRectF(x, y, w, h, flags, text));
+    }
     // TODO: QRectF 	boundingRect(const QRectF &rectangle, const QString &text, const QTextOption &option = QTextOption())
     // TODO: const QBrush &	brush() const
     // TODO: QPoint 	brushOrigin() const
@@ -90,27 +97,61 @@ export class QPainter extends Component {
     drawArc(x: number, y: number, width: number, height: number, startAngle: number, spanAngle: number): void {
         this.native.drawArc(x, y, width, height, startAngle, spanAngle);
     }
+    /**
+     * Version of drawArc() which takes floating point parameters.
+     */
+    drawArcF(x: number, y: number, width: number, height: number, startAngle: number, spanAngle: number): void {
+        this.native.drawArcF(x, y, width, height, startAngle, spanAngle);
+    }
     // TODO: void 	drawChord(const QRectF &rectangle, int startAngle, int spanAngle)
     drawChord(x: number, y: number, width: number, height: number, startAngle: number, spanAngle: number): void {
         this.native.drawChord(x, y, width, height, startAngle, spanAngle);
     }
+    /**
+     * Version of drawChord() which takes floating point parameters.
+     */
+    drawChordF(x: number, y: number, width: number, height: number, startAngle: number, spanAngle: number): void {
+        this.native.drawChordF(x, y, width, height, startAngle, spanAngle);
+    }
     // TODO: void 	drawChord(const QRect &rectangle, int startAngle, int spanAngle)
     drawConvexPolygon(points: QPoint[]): void {
         const nativePoints = points.map((point) => point.native);
         this.native.drawConvexPolygon(nativePoints);
     }
+    drawConvexPolygonF(points: QPoint[]): void {
+        const nativePoints = points.map((point) => point.native);
+        this.native.drawConvexPolygonF(nativePoints);
+    }
     // TODO: void 	drawConvexPolygon(const QPolygonF &polygon)
     drawEllipse(x: number, y: number, width: number, height: number): void {
         return this.native.drawEllipse(x, y, width, height);
     }
+    /**
+     * Version of drawEllipse() which takes floating point parameters.
+     */
+    drawEllipseF(x: number, y: number, width: number, height: number): void {
+        return this.native.drawEllipseF(x, y, width, height);
+    }
     // TODO: void 	drawEllipse(const QRectF &rectangle)
     // TODO: void 	drawGlyphRun(const QPointF &position, const QGlyphRun &glyphs)
     drawImage(x: number, y: number, image: QImage, sx = 0, sy = 0, sw = -1, sh = -1): void {
         this.native.drawImage(x, y, image.native, sx, sy, sw, sh);
     }
+    /**
+     * Version of drawImage() which takes floating point parameters.
+     */
+    drawImageF(x: number, y: number, image: QImage, sx = 0, sy = 0, sw = -1, sh = -1): void {
+        this.native.drawImageF(x, y, image.native, sx, sy, sw, sh);
+    }
     drawLine(x1: number, y1: number, x2: number, y2: number): void {
         this.native.drawLine(x1, y1, x2, y2);
     }
+    /**
+     * Version of drawLine() which takes floating point parameters.
+     */
+    drawLineF(x1: number, y1: number, x2: number, y2: number): void {
+        this.native.drawLineF(x1, y1, x2, y2);
+    }
     // TODO: void 	drawLines(const QVector<QLineF> &lines)
     drawPath(path: QPainterPath): void {
         return this.native.drawPath(path.native);
@@ -119,22 +160,43 @@ export class QPainter extends Component {
     drawPie(x: number, y: number, width: number, height: number, startAngle: number, sweepLength: number): void {
         return this.native.drawPie(x, y, width, height, startAngle, sweepLength);
     }
+    /**
+     * Version of drawPie() which takes floating point parameters.
+     */
+    drawPieF(x: number, y: number, width: number, height: number, startAngle: number, sweepLength: number): void {
+        return this.native.drawPieF(x, y, width, height, startAngle, sweepLength);
+    }
     // TODO: void 	drawPixmap(int x, int y, int w, int h, const QPixmap &pixmap, int sx, int sy, int sw, int sh)
     // TODO: void 	drawPixmapFragments(const QPainter::PixmapFragment *fragments, int fragmentCount, const QPixmap &pixmap, QPainter::PixmapFragmentHints hints = PixmapFragmentHints())
     drawPoint(x: number, y: number): void {
         this.native.drawPoint(x, y);
     }
+    drawPointF(x: number, y: number): void {
+        this.native.drawPointF(x, y);
+    }
     // TODO: void 	drawPoints(const QPointF *points, int pointCount)
     // TODO: void 	drawPolygon(const QPointF *points, int pointCount, Qt::FillRule fillRule = Qt::OddEvenFill)
     drawRect(x: number, y: number, width: number, height: number): void {
         this.native.drawRect(x, y, width, height);
     }
+    /**
+     * Version of drawRect() which takes floating point parameters.
+     */
+    drawRectF(x: number, y: number, width: number, height: number): void {
+        this.native.drawRectF(x, y, width, height);
+    }
     // TODO: void 	drawRects(const QVector<QRectF> &rectangles)
     // TODO: void 	drawRoundedRect(int x, int y, int w, int h, qreal xRadius, qreal yRadius, Qt::SizeMode mode = Qt::AbsoluteSize)
     // TODO: void 	drawStaticText(int left, int top, const QStaticText &staticText)
     drawText(x: number, y: number, text: string): void {
         return this.native.drawText(x, y, text);
     }
+    /**
+     * Version of drawText() which takes floating point parameters
+     */
+    drawTextF(x: number, y: number, text: string): void {
+        return this.native.drawTextF(x, y, text);
+    }
     // TODO: void 	drawText(int x, int y, int width, int height, int flags, const QString &text, QRect *boundingRect = nullptr)
     // TODO: void 	drawTiledPixmap(int x, int y, int width, int height, const QPixmap &pixmap, int sx = 0, int sy = 0)
     end(): boolean {
@@ -146,9 +208,21 @@ export class QPainter extends Component {
     eraseRect(x: number, y: number, width: number, height: number): void {
         this.native.eraseRect(x, y, width, height);
     }
+    /**
+     * Version of eraseRect() which takes floating point parameters.
+     */
+    eraseRectF(x: number, y: number, width: number, height: number): void {
+        this.native.eraseRectF(x, y, width, height);
+    }
     fillRect(x: number, y: number, width: number, height: number, color: QColor): void {
         this.native.fillRect(x, y, width, height, color.native);
     }
+    /**
+     * Version of fillRect() which takes floating point parameters.
+     */
+    fillRectF(x: number, y: number, width: number, height: number, color: QColor): void {
+        this.native.fillRectF(x, y, width, height, color.native);
+    }
     // TODO: const QFont &	font() const
     // TODO: QFontInfo 	fontInfo() const
     // TODO: QFontMetrics 	fontMetrics() const
@@ -187,6 +261,12 @@ export class QPainter extends Component {
     setBrushOrigin(x: number, y: number): void {
         this.native.setBrushOrigin(x, y);
     }
+    /**
+     * Version of setBrushOrigin() which takes floating point parameters.
+     */
+    setBrushOriginF(x: number, y: number): void {
+        this.native.setBrushOriginF(x, y);
+    }
     setCompositionMode(mode: CompositionMode): void {
         this.native.setCompositionMode(mode);
     }

src/lib/QtWidgets/QTableWidget.ts

@@ -238,6 +238,18 @@ export class QTableWidget extends QAbstractScrollArea<QTableWidgetSignals> {
     isSortingEnabled(): boolean {
         return this.native.isSortingEnabled();
     }
+    selectAll(): void {
+        this.native.selectAll();
+    }
+    clearSelection(): void {
+        this.native.clearSelection();
+    }
+    scrollToTop(): void {
+        this.native.scrollToTop();
+    }
+    scrollToBottom(): void {
+        this.native.scrollToBottom();
+    }
 }
 wrapperCache.registerWrapper('QTableWidgetWrap', QTableWidget);
 

src/lib/QtWidgets/QWidget.ts

@@ -2,7 +2,7 @@ import addon from '../utils/addon';
 import { QLayout } from './QLayout';
 import { NativeElement } from '../core/Component';
 import { FlexLayout } from '../core/FlexLayout';
-import { WidgetAttribute, WindowType, ContextMenuPolicy, FocusReason, FocusPolicy } from '../QtEnums';
+import { WidgetAttribute, WindowType, ContextMenuPolicy, FocusReason, FocusPolicy, InputMethodQuery } from '../QtEnums';
 import { QIcon } from '../QtGui/QIcon';
 import { QCursor } from '../QtGui/QCursor';
 import { CursorShape, WindowState } from '../QtEnums';
@@ -193,7 +193,9 @@ export class QWidget<Signals extends QWidgetSignals = QWidgetSignals> extends Yo
     heightForWidth(w: number): number {
         return this.native.heightForWidth(w);
     }
-    // TODO: Qt::InputMethodHints 	inputMethodHints() const
+    inputMethodHints(): number {
+        return this.property('inputMethodHints').toInt();
+    }
     // TODO: virtual QVariant 	inputMethodQuery(Qt::InputMethodQuery query) const
     // TODO: void 	insertAction(QAction *before, QAction *action)
     // TODO: void 	insertActions(QAction *before, QList<QAction *> actions)
@@ -396,7 +398,9 @@ export class QWidget<Signals extends QWidgetSignals = QWidgetSignals> extends Yo
     setGraphicsEffect(effect: QGraphicsEffect<any>): void {
         this.native.setGraphicsEffect(effect.native);
     }
-    // TODO: void 	setInputMethodHints(Qt::InputMethodHints hints)
+    setInputMethodHints(hints: number): void {
+        this.setProperty('inputMethodHints', hints);
+    }
     setInlineStyle(style: string, postprocess = true): void {
         if (postprocess) {
             this._rawInlineStyle = style;
@@ -560,6 +564,11 @@ export class QWidget<Signals extends QWidgetSignals = QWidgetSignals> extends Yo
     updatesEnabled(): boolean {
         return this.property('updatesEnabled').toBool();
     }
+
+    updateMicroFocus(query: number = InputMethodQuery.ImQueryAll): void {
+        this.native.updateMicroFocus(query);
+    }
+
     // TODO: QRegion 	visibleRegion() const
     whatsThis(): string {
         return this.property('whatsThis').toString();
@@ -611,6 +620,43 @@ export class QWidget<Signals extends QWidgetSignals = QWidgetSignals> extends Yo
         return this.property('y').toInt();
     }
 
+    // QPaintDevice public methods
+    colorCount(): number {
+        return this.native.colorCount();
+    }
+    depth(): number {
+        return this.native.depth();
+    }
+    devicePixelRatio(): number {
+        return this.native.devicePixelRatio();
+    }
+    devicePixelRatioF(): number {
+        return this.native.devicePixelRatioF();
+    }
+    heightMM(): number {
+        return this.native.heightMM();
+    }
+    logicalDpiX(): number {
+        return this.native.logicalDpiX();
+    }
+    logicalDpiY(): number {
+        return this.native.logicalDpiY();
+    }
+    paintingActive(): boolean {
+        return this.native.paintingActive();
+    }
+    physicalDpiX(): number {
+        return this.native.physicalDpiX();
+    }
+    physicalDpiY(): number {
+        return this.native.physicalDpiY();
+    }
+    widthMM(): number {
+        return this.native.widthMM();
+    }
+
+    // TODO: virtual QPaintEngine *	paintEngine() const = 0
+
     // *** Public Slots ***
     close(): boolean {
         return this.native.close();

src/lib/QtWidgets/__tests__/QMainWindow.test.ts

@@ -14,6 +14,6 @@ describe('QMainWindow', () => {
         const win = new QMainWindow();
         const widget = new QWidget();
         win.setCentralWidget(widget);
-        expect(win.centralWidget).toEqual(widget);
+        expect(win.centralWidget()).toEqual(widget);
     });
 });

src/lib/core/EventWidget.ts

@@ -80,7 +80,7 @@ export abstract class EventWidget<Signals extends unknown> extends Component {
                         this.emitter.emit(eventName, event);
                     } else {
                         this._isEventProcessed = baseWidgetResult;
-                        this.emitter.emit(`${eventName}_after`);
+                        this.emitter.emit(`${eventName}_after`, event);
                     }
                 } catch (e) {
                     console.log(

src/lib/core/__test__/WrapperCache.test.ts

@@ -35,7 +35,7 @@ describe('WrapperCache using CacheTestQObject', () => {
         const fooId = foo.native.__id__();
         a.clearFoo();
         expect(foo.native).toBeNull();
-
+        console.log(''); // for some reason this fixes the test in macos
         const foo2 = a.foo();
         expect(foo2).not.toBe(foo);
         expect(foo2.native.__id__()).not.toBe(fooId);

website/docs/guides/getting-started.md

@@ -7,13 +7,13 @@ NodeGui enables you to create desktop applications with JavaScript. You could se
 as a lightly modified variant of the Node.js runtime that is focused on desktop applications
 instead of web servers.
 
-NodeGui is also an efficient JavaScript binding to a cross platform graphical user interface
+NodeGui is also an efficient JavaScript binding to the cross platform graphical user interface
-(GUI) library `Qt`. Qt is one of the most mature and efficient library for building desktop applications.
+(GUI) library `Qt`. Qt is one of the most mature and efficient libraries for building desktop applications.
-This enabled NodeGui to be extremely memory and CPU efficient as compared to other popular Javascript Desktop GUI solutions. A hello world app built with NodeGui runs on less than 20Mb of memory.
+This enables NodeGui to be extremely memory and CPU efficient compared to other popular Javascript desktop GUI solutions. A hello world app built with NodeGui runs on less than 20MB of memory.
 
 ## Developer environment
 
-To turn your operating system into an environment capable of building desktop apps with NodeGui, you would need Node.js, npm,a code editor of your choice, and a rudimentary understanding of your operating system's command line client.
+To turn your operating system into an environment capable of building desktop apps with NodeGui, you would need Node.js, npm, a code editor of your choice, and a rudimentary understanding of your operating system's command line.
 
 Along with these, there are a few operating system dependent instructions that are listed below.
 
@@ -22,11 +22,9 @@ Along with these, there are a few operating system dependent instructions that a
 **Requirements:**
 
 - NodeGui supports macOS 10.10 (Yosemite) and up. NodeGui currently only supports 64bit OS.
-- CMake 3.1 and up (Installation instructions can be found here: https://cmake.org/install/)
+- Currently supported Node.Js versions are 16.x.
-- Make, GCC v7
-- Currently supported Node.Js versions are 14.x.
 
-We strongly suggest you use some kind of version manager for Node.Js. This would allow you to switch to any version of nodejs quite easily. We recommend `nvm`: https://github.com/nvm-sh/nvm
+We strongly suggest you use some kind of version manager for Node.js. This would allow you to switch to any version of Node.js quite easily. We recommend `nvm`: https://github.com/nvm-sh/nvm
 
 Confirm that both `node` and `npm` are available by running:
 
@@ -44,16 +42,12 @@ for JavaScript development.
 
 ### Setting up on Windows
 
-> NodeGui supports Windows 7 and later versions – attempting to develop NodeGui
-> applications on earlier versions of Windows might not work. NodeGui currently only supports 64bit OS.
-
 **Requirements:**
 
-- Visual studio 2017 and up.
+- NodeGui supports Windows 7 and later on 64bit operating systems.
-- CMake 3.1 and up (Installation instructions can be found here: https://cmake.org/install/)
+- Currently supported Node.js versions are 16.x and up.
-- Currently supported Node.Js versions are 12.x and up.
 
-We strongly suggest you use some kind of version manager for Node.Js. This would allow you to switch to any version of nodejs quite easily.
+We strongly suggest you use some kind of version manager for Node.js. This would allow you to switch to any version of Node.js quite easily.
 
 We strongly recommend Powershell as preferred terminal in Windows.
 
@@ -77,12 +71,9 @@ for JavaScript development.
 
 **Requirements:**
 
-- Make, GCC v7
+- Currently supported Node.js versions are 16.x and up.
-- CMake 3.1 and up (Installation instructions can be found here: https://cmake.org/install/)
-- Currently supported Node.Js versions are 12.x and up.
-- On Ubuntu and Ubuntu-based distros it is advisable to run `sudo apt-get update`, followed by `sudo apt-get install pkg-config build-essential mesa-common-dev libglu1-mesa-dev`
 
-We strongly suggest you use some kind of version manager for Node.Js. This would allow you to switch to any version of nodejs quite easily. We recommend `nvm`: https://github.com/nvm-sh/nvm
+We strongly suggest you use some kind of version manager for Node.js. This would allow you to switch to any version of Node.js quite easily. We recommend `nvm`: https://github.com/nvm-sh/nvm
 
 Confirm that both `node` and `npm` are available by running:
 
@@ -100,12 +91,9 @@ for JavaScript development.
 
 ### A Good Editor
 
-We might suggest two free popular editors:
+We might suggest two free popular editors: GitHub's [Atom][atom] and Microsoft's [Visual Studio Code][code]. Both of them have excellent JavaScript support.
-GitHub's [Atom][atom] and Microsoft's [Visual Studio Code][code]. Both of
-them have excellent JavaScript support.
 
-If you are one of the many developers with a strong preference, know that
+If you are one of the many developers with a strong preference, know that virtually all code editors and IDEs these days support JavaScript.
-virtually all code editors and IDEs these days support JavaScript.
 
 [code]: https://code.visualstudio.com/
 [atom]: https://atom.io/
@@ -114,7 +102,7 @@ virtually all code editors and IDEs these days support JavaScript.
 
 **Compiling Qt from source**
 
-You will need to download and install Qt from source since there are no binaries from Qt for M1 yet. 
+You will need to download and install Qt from source since there are no binaries from Qt for M1 yet.
 
 (https://www.reddit.com/r/QtFramework/comments/ll58wg/how_to_build_qt_creator_for_macos_arm64_a_guide/)