Add QFont and change QAction.setFont() to accept QFont (#309)

* Add QFont and change QAction.setFont() to accept QFont

* fix constructor

* fix .fromQVariant()

CMakeLists.txt

@@ -43,6 +43,7 @@ add_library(${CORE_WIDGETS_ADDON} SHARED
     "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtGui/QFontDatabase/qfontdatabase_wrap.cpp"
     "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtGui/QPixmap/qpixmap_wrap.cpp"
     "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtGui/QIcon/qicon_wrap.cpp"
+    "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtGui/QFont/qfont_wrap.cpp"
     "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtGui/QCursor/qcursor_wrap.cpp"
     "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtGui/QKeySequence/qkeysequence_wrap.cpp"
     "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtGui/QMovie/qmovie_wrap.cpp"

src/cpp/include/nodegui/QtGui/QFont/qfont_wrap.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <napi.h>
+
+#include <QFont>
+
+#include "core/Component/component_macro.h"
+
+class QFontWrap : public Napi::ObjectWrap<QFontWrap> {
+ private:
+  std::unique_ptr<QFont> instance;
+
+ public:
+  static Napi::FunctionReference constructor;
+  static Napi::Object init(Napi::Env env, Napi::Object exports);
+  QFontWrap(const Napi::CallbackInfo& info);
+  ~QFontWrap();
+  QFont* getInternalInstance();
+  // Wrapped methods
+  Napi::Value setCapitalization(const Napi::CallbackInfo& info);
+  Napi::Value capitalization(const Napi::CallbackInfo& info);
+  Napi::Value setFamily(const Napi::CallbackInfo& info);
+  Napi::Value family(const Napi::CallbackInfo& info);
+  Napi::Value setPointSize(const Napi::CallbackInfo& info);
+  Napi::Value pointSize(const Napi::CallbackInfo& info);
+  Napi::Value setStretch(const Napi::CallbackInfo& info);
+  Napi::Value stretch(const Napi::CallbackInfo& info);
+  Napi::Value setWeight(const Napi::CallbackInfo& info);
+  Napi::Value weight(const Napi::CallbackInfo& info);
+  Napi::Value setItalic(const Napi::CallbackInfo& info);
+  Napi::Value italic(const Napi::CallbackInfo& info);
+  Napi::Value toString(const Napi::CallbackInfo& info);
+  COMPONENT_WRAPPED_METHODS_DECLARATION
+};
+
+namespace StaticQFontWrapMethods {
+Napi::Value fromQVariant(const Napi::CallbackInfo& info);
+}  // namespace StaticQFontWrapMethods

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

@@ -0,0 +1,168 @@
+#include "QtGui/QFont/qfont_wrap.h"
+
+#include "Extras/Utils/nutils.h"
+#include "QtCore/QVariant/qvariant_wrap.h"
+
+Napi::FunctionReference QFontWrap::constructor;
+
+Napi::Object QFontWrap::init(Napi::Env env, Napi::Object exports) {
+  Napi::HandleScope scope(env);
+  char CLASSNAME[] = "QFont";
+  Napi::Function func = DefineClass(
+      env, CLASSNAME,
+      {InstanceMethod("setCapitalization", &QFontWrap::setCapitalization),
+       InstanceMethod("capitalization", &QFontWrap::capitalization),
+       InstanceMethod("setFamily", &QFontWrap::setFamily),
+       InstanceMethod("family", &QFontWrap::family),
+       InstanceMethod("setPointSize", &QFontWrap::setPointSize),
+       InstanceMethod("pointSize", &QFontWrap::pointSize),
+       InstanceMethod("setStretch", &QFontWrap::setStretch),
+       InstanceMethod("stretch", &QFontWrap::stretch),
+       InstanceMethod("setWeight", &QFontWrap::setWeight),
+       InstanceMethod("weight", &QFontWrap::weight),
+       InstanceMethod("setItalic", &QFontWrap::setItalic),
+       InstanceMethod("italic", &QFontWrap::italic),
+       InstanceMethod("toString", &QFontWrap::toString),
+       StaticMethod("fromQVariant", &StaticQFontWrapMethods::fromQVariant),
+       COMPONENT_WRAPPED_METHODS_EXPORT_DEFINE});
+  constructor = Napi::Persistent(func);
+  exports.Set(CLASSNAME, func);
+  return exports;
+}
+
+QFontWrap::QFontWrap(const Napi::CallbackInfo& info)
+    : Napi::ObjectWrap<QFontWrap>(info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+
+  if (info.Length() == 4) {
+    std::string family = info[0].As<Napi::String>().Utf8Value();
+    int pointSize = info[1].As<Napi::Number>().Int32Value();
+    int weight = info[2].As<Napi::Number>().Int32Value();
+    bool italic = info[3].As<Napi::Boolean>().Value();
+    this->instance = std::make_unique<QFont>(
+        QString::fromStdString(family.c_str()), pointSize, weight, italic);
+  } else if (info.Length() == 1) {
+    this->instance =
+        std::unique_ptr<QFont>(info[0].As<Napi::External<QFont>>().Data());
+  } else if (info.Length() == 0) {
+    this->instance = std::make_unique<QFont>();
+  } else {
+    Napi::TypeError::New(env, "Wrong number of arguments")
+        .ThrowAsJavaScriptException();
+  }
+  this->rawData = extrautils::configureComponent(this->getInternalInstance());
+}
+
+QFontWrap::~QFontWrap() { this->instance.reset(); }
+
+QFont* QFontWrap::getInternalInstance() { return this->instance.get(); }
+
+Napi::Value QFontWrap::setCapitalization(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+
+  QFont::Capitalization caps = static_cast<QFont::Capitalization>(
+      info[0].As<Napi::Number>().Int32Value());
+  this->instance->setCapitalization(caps);
+  return env.Null();
+}
+
+Napi::Value QFontWrap::capitalization(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+  return Napi::Value::From(env,
+                           static_cast<int>(this->instance->capitalization()));
+}
+
+Napi::Value QFontWrap::setFamily(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+  std::string family = info[0].As<Napi::String>().Utf8Value();
+  this->instance->setFamily(QString::fromStdString(family.c_str()));
+  return env.Null();
+}
+
+Napi::Value QFontWrap::family(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+  QString family = this->instance->family();
+  return Napi::String::New(env, family.toStdString());
+}
+
+Napi::Value QFontWrap::setPointSize(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+  int pointSize = info[0].As<Napi::Number>().Int32Value();
+  this->instance->setPointSize(pointSize);
+  return env.Null();
+}
+
+Napi::Value QFontWrap::pointSize(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+  return Napi::Value::From(env, this->instance->pointSize());
+}
+
+Napi::Value QFontWrap::setStretch(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+  int factor = info[0].As<Napi::Number>().Int32Value();
+  this->instance->setStretch(factor);
+  return env.Null();
+}
+
+Napi::Value QFontWrap::stretch(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+  return Napi::Value::From(env, this->instance->stretch());
+}
+
+Napi::Value QFontWrap::setWeight(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+  int weight = info[0].As<Napi::Number>().Int32Value();
+  this->instance->setWeight(weight);
+  return env.Null();
+}
+
+Napi::Value QFontWrap::weight(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+  return Napi::Value::From(env, this->instance->weight());
+}
+
+Napi::Value QFontWrap::setItalic(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+  int enable = info[0].As<Napi::Boolean>().Value();
+  this->instance->setItalic(enable);
+  return env.Null();
+}
+
+Napi::Value QFontWrap::italic(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+  return Napi::Value::From(env, this->instance->italic());
+}
+
+Napi::Value QFontWrap::toString(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+  QString value = this->instance->toString();
+  return Napi::String::New(env, value.toStdString());
+}
+
+Napi::Value StaticQFontWrapMethods::fromQVariant(
+    const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+  Napi::Object variantObject = info[0].As<Napi::Object>();
+  QVariantWrap* variantWrap =
+      Napi::ObjectWrap<QVariantWrap>::Unwrap(variantObject);
+  QVariant* variant = variantWrap->getInternalInstance();
+  QFont font = variant->value<QFont>();
+  auto instance = QFontWrap::constructor.New(
+      {Napi::External<QFont>::New(env, new QFont(font))});
+  return instance;
+}

src/cpp/lib/QtWidgets/QAction/qaction_wrap.cpp

@@ -4,6 +4,7 @@
 #include <QWidget>
 
 #include "Extras/Utils/nutils.h"
+#include "QtGui/QFont/qfont_wrap.h"
 #include "QtGui/QKeySequence/qkeysequence_wrap.h"
 #include "QtWidgets/QMenu/qmenu_wrap.h"
 #include "QtWidgets/QWidget/qwidget_wrap.h"
@@ -196,11 +197,11 @@ Napi::Value QActionWrap::setSeparator(const Napi::CallbackInfo& info) {
 Napi::Value QActionWrap::setFont(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   Napi::HandleScope scope(env);
-  std::string family = info[0].As<Napi::String>().Utf8Value();
-  int pointSize = info[1].As<Napi::Number>().Int32Value();
-  int weight = info[2].As<Napi::Number>().Int32Value();
-  bool italic = info[3].As<Napi::Boolean>().Value();
-  QFont f(QString::fromStdString(family.c_str()), pointSize, weight, italic);
-  this->instance->setFont(f);
+
+  Napi::Object fontObject = info[0].As<Napi::Object>();
+  QFontWrap* fontWrap = Napi::ObjectWrap<QFontWrap>::Unwrap(fontObject);
+  QFont* font = fontWrap->getInternalInstance();
+
+  this->instance->setFont(*font);
   return env.Null();
 }

src/cpp/main.cpp

@@ -12,6 +12,7 @@
 #include "QtGui/QCursor/qcursor_wrap.h"
 #include "QtGui/QEvent/QKeyEvent/qkeyevent_wrap.h"
 #include "QtGui/QEvent/QMouseEvent/qmouseevent_wrap.h"
+#include "QtGui/QFont/qfont_wrap.h"
 #include "QtGui/QFontDatabase/qfontdatabase_wrap.h"
 #include "QtGui/QIcon/qicon_wrap.h"
 #include "QtGui/QKeySequence/qkeysequence_wrap.h"
@@ -72,6 +73,7 @@ Napi::Object Main(Napi::Env env, Napi::Object exports) {
   QKeySequenceWrap::init(env, exports);
   QFontDatabaseWrap::init(env, exports);
   QIconWrap::init(env, exports);
+  QFontWrap::init(env, exports);
   QMovieWrap::init(env, exports);
   QStyleWrap::init(env, exports);
   QCursorWrap::init(env, exports);

src/demo.ts

@@ -3,6 +3,7 @@ import { QLabel } from './lib/QtWidgets/QLabel';
 import { QSystemTrayIcon } from './lib/QtWidgets/QSystemTrayIcon';
 import { QMenu } from './lib/QtWidgets/QMenu';
 import { QAction } from './lib/QtWidgets/QAction';
+import { QFont, QFontWeight, QFontCapitalization, QFontStretch } from './lib/QtGui/QFont';
 
 const win = new QMainWindow();
 const center = new QWidget();
@@ -13,10 +14,35 @@ const tray = new QSystemTrayIcon();
 const menu = new QMenu();
 const action = new QAction();
 
-action.setText('action');
-action.setFont('Mono', 20);
+const font = new QFont('serif', 40, QFontWeight.ExtraLight, true);
+font.setCapitalization(QFontCapitalization.AllUppercase);
+font.setStretch(QFontStretch.UltraCondensed);
+
+const family = font.family();
+const pointSize = font.pointSize();
+const weight = font.weight();
+const italic = font.italic();
+const capitalization = font.capitalization();
+const stretch = font.stretch();
+console.log({ family, pointSize, weight, italic, capitalization, stretch });
+
+action.setText('action1');
+action.setFont(font);
 menu.addAction(action);
+
+const font2 = new QFont(font);
+font2.setFamily('mono');
+font2.setCapitalization(QFontCapitalization.Capitalize);
+font2.setStretch(QFontStretch.ExtraExpanded);
+font2.setPointSize(20);
+
+const action2 = new QAction();
+action2.setText('action2');
+action2.setFont(font2);
+menu.addAction(action2);
+
 tray.setContextMenu(menu);
+
 tray.show();
 
 label.setText('Hello!');

src/index.ts

@@ -7,6 +7,7 @@ export { QApplication } from './lib/QtGui/QApplication';
 export { QKeySequence } from './lib/QtGui/QKeySequence';
 export { QPixmap, ImageFormats } from './lib/QtGui/QPixmap';
 export { QIcon, QIconMode, QIconState } from './lib/QtGui/QIcon';
+export { QFont, QFontCapitalization, QFontStretch, QFontWeight } from './lib/QtGui/QFont';
 export { QMovie, CacheMode, MovieState } from './lib/QtGui/QMovie';
 export { QCursor } from './lib/QtGui/QCursor';
 export { QTextOptionWrapMode } from './lib/QtGui/QTextOption';

src/lib/QtGui/QFont.ts

@@ -0,0 +1,93 @@
+import { Component, NativeElement } from '../core/Component';
+import addon from '../utils/addon';
+import { QVariant } from '../QtCore/QVariant';
+
+export enum QFontStretch {
+    AnyStretch = 0,
+    UltraCondensed = 50,
+    ExtraCondensed = 62,
+    Condensed = 75,
+    SemiCondensed = 87,
+    Unstretched = 100,
+    SemiExpanded = 112,
+    Expanded = 125,
+    ExtraExpanded = 150,
+    UltraExpanded = 200,
+}
+export enum QFontCapitalization {
+    MixedCase = 0,
+    AllUppercase = 1,
+    AllLowercase = 2,
+    SmallCaps = 3,
+    Capitalize = 4,
+}
+export enum QFontWeight {
+    Thin = 0,
+    ExtraLight = 12,
+    Light = 25,
+    Normal = 50,
+    Medium = 57,
+    DemiBold = 63,
+    Bold = 75,
+    ExtraBold = 81,
+    Black = 87,
+}
+
+export class QFont extends Component {
+    native: NativeElement;
+    constructor();
+    constructor(font?: QFont);
+    constructor(family?: string, pointSize?: number, weight?: number, italic?: boolean);
+    constructor(arg?: QFont | string, pointSize = -1, weight = -1, italic = false) {
+        super();
+        if (arg instanceof QFont) {
+            this.native = arg.native;
+        } else if (typeof arg === 'string') {
+            this.native = new addon.QFont(arg, pointSize, weight, italic);
+        } else {
+            this.native = new addon.QFont();
+        }
+    }
+    setCapitalization(caps: QFontCapitalization): void {
+        this.native.setCapitalization(caps);
+    }
+    capitalization(): QFontCapitalization {
+        return this.native.capitalization();
+    }
+    setFamily(family: string): void {
+        this.native.setFamily(family);
+    }
+    family(): string {
+        return this.native.family();
+    }
+    setPointSize(value: number): void {
+        this.native.setPointSize(value);
+    }
+    pointSize(): number {
+        return this.native.pointSize();
+    }
+    setStretch(factor: QFontStretch): void {
+        this.native.setStretch(factor);
+    }
+    stretch(): QFontStretch {
+        return this.native.stretch();
+    }
+    setWeight(weight: QFontWeight): void {
+        this.native.setWeight(weight);
+    }
+    weight(): QFontWeight {
+        return this.native.weight();
+    }
+    setItalic(enable: boolean): void {
+        this.native.setItalic(enable);
+    }
+    italic(): boolean {
+        return this.native.italic();
+    }
+    toString(): string {
+        return this.native.toString();
+    }
+    static fromQVariant(variant: QVariant): QFont {
+        return new QFont(addon.QFont.fromQVariant(variant.native));
+    }
+}

src/lib/QtWidgets/QAction.ts

@@ -3,6 +3,7 @@ import { NodeWidget } from './QWidget';
 import { NativeElement } from '../core/Component';
 import { QMenu } from './QMenu';
 import { QIcon } from '../QtGui/QIcon';
+import { QFont } from '../QtGui/QFont';
 import { QKeySequence } from '../QtGui/QKeySequence';
 import { ShortcutContext } from '../QtEnums';
 import { NodeObject, QObjectSignals } from '../QtCore/QObject';
@@ -92,7 +93,7 @@ export class QAction extends NodeObject<QActionSignals> {
     setSeparator(isSeparator: boolean): void {
         this.native.setSeparator(isSeparator);
     }
-    setFont(family: string, pointSize = -1, weight = -1, italic = false): void {
-        this.native.setFont(family, pointSize, weight, italic);
+    setFont(font: QFont): void {
+        this.native.setFont(font.native);
     }
 }