From 609e243866e28d7d30049b30e0c186321d955feb Mon Sep 17 00:00:00 2001 From: slidinghotdog <33790211+slidinghotdog@users.noreply.github.com> Date: Sun, 29 Dec 2019 01:25:33 -0300 Subject: [PATCH] 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 | 1 + .../include/nodegui/QtGui/QFont/qfont_wrap.h | 38 ++++ src/cpp/lib/QtGui/QFont/qfont_wrap.cpp | 168 ++++++++++++++++++ .../lib/QtWidgets/QAction/qaction_wrap.cpp | 13 +- src/cpp/main.cpp | 2 + src/demo.ts | 30 +++- src/index.ts | 1 + src/lib/QtGui/QFont.ts | 93 ++++++++++ src/lib/QtWidgets/QAction.ts | 5 +- 9 files changed, 341 insertions(+), 10 deletions(-) create mode 100644 src/cpp/include/nodegui/QtGui/QFont/qfont_wrap.h create mode 100644 src/cpp/lib/QtGui/QFont/qfont_wrap.cpp create mode 100644 src/lib/QtGui/QFont.ts diff --git a/CMakeLists.txt b/CMakeLists.txt index cbc9a2fba..6ce5f13ad 100644 --- a/CMakeLists.txt +++ b/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" diff --git a/src/cpp/include/nodegui/QtGui/QFont/qfont_wrap.h b/src/cpp/include/nodegui/QtGui/QFont/qfont_wrap.h new file mode 100644 index 000000000..30e37b81b --- /dev/null +++ b/src/cpp/include/nodegui/QtGui/QFont/qfont_wrap.h @@ -0,0 +1,38 @@ +#pragma once + +#include + +#include + +#include "core/Component/component_macro.h" + +class QFontWrap : public Napi::ObjectWrap { + private: + std::unique_ptr 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 diff --git a/src/cpp/lib/QtGui/QFont/qfont_wrap.cpp b/src/cpp/lib/QtGui/QFont/qfont_wrap.cpp new file mode 100644 index 000000000..74537fec4 --- /dev/null +++ b/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(info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + if (info.Length() == 4) { + std::string family = info[0].As().Utf8Value(); + int pointSize = info[1].As().Int32Value(); + int weight = info[2].As().Int32Value(); + bool italic = info[3].As().Value(); + this->instance = std::make_unique( + QString::fromStdString(family.c_str()), pointSize, weight, italic); + } else if (info.Length() == 1) { + this->instance = + std::unique_ptr(info[0].As>().Data()); + } else if (info.Length() == 0) { + this->instance = std::make_unique(); + } else { + Napi::TypeError::New(env, "Wrong number of arguments") + .ThrowAsJavaScriptException(); + } + this->rawData = extrautils::configureComponent(this->getInternalInstance()); +} + +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( + info[0].As().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(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().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().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().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().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().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(); + QVariantWrap* variantWrap = + Napi::ObjectWrap::Unwrap(variantObject); + QVariant* variant = variantWrap->getInternalInstance(); + QFont font = variant->value(); + auto instance = QFontWrap::constructor.New( + {Napi::External::New(env, new QFont(font))}); + return instance; +} \ No newline at end of file diff --git a/src/cpp/lib/QtWidgets/QAction/qaction_wrap.cpp b/src/cpp/lib/QtWidgets/QAction/qaction_wrap.cpp index d90965b0b..dd3e71f60 100644 --- a/src/cpp/lib/QtWidgets/QAction/qaction_wrap.cpp +++ b/src/cpp/lib/QtWidgets/QAction/qaction_wrap.cpp @@ -4,6 +4,7 @@ #include #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().Utf8Value(); - int pointSize = info[1].As().Int32Value(); - int weight = info[2].As().Int32Value(); - bool italic = info[3].As().Value(); - QFont f(QString::fromStdString(family.c_str()), pointSize, weight, italic); - this->instance->setFont(f); + + Napi::Object fontObject = info[0].As(); + QFontWrap* fontWrap = Napi::ObjectWrap::Unwrap(fontObject); + QFont* font = fontWrap->getInternalInstance(); + + this->instance->setFont(*font); return env.Null(); } \ No newline at end of file diff --git a/src/cpp/main.cpp b/src/cpp/main.cpp index e169c6858..9fb9b62db 100644 --- a/src/cpp/main.cpp +++ b/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); diff --git a/src/demo.ts b/src/demo.ts index e746cf25c..760d11d42 100644 --- a/src/demo.ts +++ b/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!'); diff --git a/src/index.ts b/src/index.ts index 7c31715be..21fd0a9b0 100644 --- a/src/index.ts +++ b/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'; diff --git a/src/lib/QtGui/QFont.ts b/src/lib/QtGui/QFont.ts new file mode 100644 index 000000000..f1fe30de7 --- /dev/null +++ b/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)); + } +} diff --git a/src/lib/QtWidgets/QAction.ts b/src/lib/QtWidgets/QAction.ts index 9568786c0..8cd3f518b 100644 --- a/src/lib/QtWidgets/QAction.ts +++ b/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 { 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); } }