From bd6b127358095b246509dcbd9a208f72bb57e485 Mon Sep 17 00:00:00 2001 From: Simon Edwards Date: Mon, 20 Sep 2021 21:45:14 +0200 Subject: [PATCH] Add `QSizeF` and `QFontMetricsF` --- CMakeLists.txt | 2 + .../nodegui/QtCore/QSizeF/qsizef_wrap.h | 30 ++ .../QtGui/QFontMetricsF/qfontmetricsf_wrap.h | 49 +++ src/cpp/lib/QtCore/QSizeF/qsizef_wrap.cpp | 86 +++++ .../QFontMetricsF/qfontmetricsf_wrap.cpp | 304 ++++++++++++++++++ src/cpp/main.cpp | 4 + src/index.ts | 2 + src/lib/QtCore/QSizeF.ts | 36 +++ src/lib/QtGui/QFontMetricsF.ts | 181 +++++++++++ 9 files changed, 694 insertions(+) create mode 100644 src/cpp/include/nodegui/QtCore/QSizeF/qsizef_wrap.h create mode 100644 src/cpp/include/nodegui/QtGui/QFontMetricsF/qfontmetricsf_wrap.h create mode 100644 src/cpp/lib/QtCore/QSizeF/qsizef_wrap.cpp create mode 100644 src/cpp/lib/QtGui/QFontMetricsF/qfontmetricsf_wrap.cpp create mode 100644 src/lib/QtCore/QSizeF.ts create mode 100644 src/lib/QtGui/QFontMetricsF.ts diff --git a/CMakeLists.txt b/CMakeLists.txt index b78288c64..752fde426 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -55,6 +55,7 @@ add_library(${CORE_WIDGETS_ADDON} SHARED "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtGui/QEvent/QDragLeaveEvent/qdragleaveevent_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" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtGui/QPicture/qpicture_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtGui/QPixmap/qpixmap_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtGui/QIcon/qicon_wrap.cpp" @@ -73,6 +74,7 @@ add_library(${CORE_WIDGETS_ADDON} SHARED "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtCore/QObject/qobject_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtCore/QVariant/qvariant_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtCore/QSize/qsize_wrap.cpp" + "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtCore/QSizeF/qsizef_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtCore/QSettings/qsettings_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtCore/QRect/qrect_wrap.cpp" "${PROJECT_SOURCE_DIR}/src/cpp/lib/QtCore/QRectF/qrectf_wrap.cpp" diff --git a/src/cpp/include/nodegui/QtCore/QSizeF/qsizef_wrap.h b/src/cpp/include/nodegui/QtCore/QSizeF/qsizef_wrap.h new file mode 100644 index 000000000..c5d020964 --- /dev/null +++ b/src/cpp/include/nodegui/QtCore/QSizeF/qsizef_wrap.h @@ -0,0 +1,30 @@ +#pragma once + +#include + +#include + +#include "Extras/Export/export.h" +#include "core/Component/component_macro.h" + +class DLL_EXPORT QSizeFWrap : public Napi::ObjectWrap { + COMPONENT_WRAPPED_METHODS_DECLARATION + private: + std::unique_ptr instance; + + public: + static Napi::FunctionReference constructor; + static Napi::Object init(Napi::Env env, Napi::Object exports); + QSizeFWrap(const Napi::CallbackInfo& info); + ~QSizeFWrap(); + QSizeF* getInternalInstance(); + // Wrapped methods + Napi::Value setHeight(const Napi::CallbackInfo& info); + Napi::Value setWidth(const Napi::CallbackInfo& info); + Napi::Value height(const Napi::CallbackInfo& info); + Napi::Value width(const Napi::CallbackInfo& info); +}; + +namespace StaticQSizeFWrapMethods { +DLL_EXPORT Napi::Value fromQVariant(const Napi::CallbackInfo& info); +} // namespace StaticQSizeFWrapMethods \ No newline at end of file diff --git a/src/cpp/include/nodegui/QtGui/QFontMetricsF/qfontmetricsf_wrap.h b/src/cpp/include/nodegui/QtGui/QFontMetricsF/qfontmetricsf_wrap.h new file mode 100644 index 000000000..8a3b330e2 --- /dev/null +++ b/src/cpp/include/nodegui/QtGui/QFontMetricsF/qfontmetricsf_wrap.h @@ -0,0 +1,49 @@ +#pragma once + +#include + +#include + +#include "Extras/Export/export.h" +#include "core/Component/component_macro.h" + +class DLL_EXPORT QFontMetricsFWrap + : public Napi::ObjectWrap { + COMPONENT_WRAPPED_METHODS_DECLARATION + + private: + std::unique_ptr instance; + + public: + static Napi::FunctionReference constructor; + static Napi::Object init(Napi::Env env, Napi::Object exports); + QFontMetricsFWrap(const Napi::CallbackInfo& info); + QFontMetricsF* getInternalInstance(); + // Wrapped methods + Napi::Value ascent(const Napi::CallbackInfo& info); + Napi::Value averageCharWidth(const Napi::CallbackInfo& info); + Napi::Value capHeight(const Napi::CallbackInfo& info); + Napi::Value descent(const Napi::CallbackInfo& info); + Napi::Value fontDpi(const Napi::CallbackInfo& info); + Napi::Value height(const Napi::CallbackInfo& info); + Napi::Value horizontalAdvance(const Napi::CallbackInfo& info); + Napi::Value inFont(const Napi::CallbackInfo& info); + Napi::Value leading(const Napi::CallbackInfo& info); + Napi::Value leftBearing(const Napi::CallbackInfo& info); + Napi::Value lineSpacing(const Napi::CallbackInfo& info); + Napi::Value lineWidth(const Napi::CallbackInfo& info); + Napi::Value overlinePos(const Napi::CallbackInfo& info); + Napi::Value rightBearing(const Napi::CallbackInfo& info); + Napi::Value size(const Napi::CallbackInfo& info); + Napi::Value strikeOutPos(const Napi::CallbackInfo& info); + Napi::Value swap(const Napi::CallbackInfo& info); + Napi::Value underlinePos(const Napi::CallbackInfo& info); + Napi::Value xHeight(const Napi::CallbackInfo& info); + Napi::Value maxWidth(const Napi::CallbackInfo& info); + Napi::Value minLeftBearing(const Napi::CallbackInfo& info); + Napi::Value minRightBearing(const Napi::CallbackInfo& info); + Napi::Value inFontUcs4(const Napi::CallbackInfo& info); + Napi::Value boundingRect(const Napi::CallbackInfo& info); + Napi::Value tightBoundingRect(const Napi::CallbackInfo& info); + Napi::Value elidedText(const Napi::CallbackInfo& info); +}; diff --git a/src/cpp/lib/QtCore/QSizeF/qsizef_wrap.cpp b/src/cpp/lib/QtCore/QSizeF/qsizef_wrap.cpp new file mode 100644 index 000000000..bd334dd4a --- /dev/null +++ b/src/cpp/lib/QtCore/QSizeF/qsizef_wrap.cpp @@ -0,0 +1,86 @@ +#include "QtCore/QSizeF/qsizef_wrap.h" + +#include "Extras/Utils/nutils.h" +#include "QtCore/QVariant/qvariant_wrap.h" + +Napi::FunctionReference QSizeFWrap::constructor; + +Napi::Object QSizeFWrap::init(Napi::Env env, Napi::Object exports) { + Napi::HandleScope scope(env); + char CLASSNAME[] = "QSizeF"; + Napi::Function func = DefineClass( + env, CLASSNAME, + {InstanceMethod("setHeight", &QSizeFWrap::setHeight), + InstanceMethod("setWidth", &QSizeFWrap::setWidth), + InstanceMethod("height", &QSizeFWrap::height), + InstanceMethod("width", &QSizeFWrap::width), + StaticMethod("fromQVariant", &StaticQSizeFWrapMethods::fromQVariant), + COMPONENT_WRAPPED_METHODS_EXPORT_DEFINE(QSizeFWrap)}); + constructor = Napi::Persistent(func); + exports.Set(CLASSNAME, func); + return exports; +} + +QSizeFWrap::QSizeFWrap(const Napi::CallbackInfo& info) + : Napi::ObjectWrap(info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + if (info.Length() == 2) { + int width = info[0].As().Int32Value(); + int height = info[1].As().Int32Value(); + this->instance = std::make_unique(width, height); + } 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()); +} + +QSizeFWrap::~QSizeFWrap() { this->instance.reset(); } + +QSizeF* QSizeFWrap::getInternalInstance() { return this->instance.get(); } + +Napi::Value QSizeFWrap::setHeight(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + qreal height = info[0].As().FloatValue(); + this->instance->setHeight(height); + return env.Null(); +} +Napi::Value QSizeFWrap::setWidth(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + qreal width = info[0].As().FloatValue(); + this->instance->setWidth(width); + return env.Null(); +} +Napi::Value QSizeFWrap::height(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + return Napi::Value::From(env, this->instance->height()); +} +Napi::Value QSizeFWrap::width(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + return Napi::Value::From(env, this->instance->width()); +} + +Napi::Value StaticQSizeFWrapMethods::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(); + QSizeF size = variant->value(); + auto instance = QSizeFWrap::constructor.New({Napi::External::New( + env, new QSizeF(size.width(), size.height()))}); + return instance; +} diff --git a/src/cpp/lib/QtGui/QFontMetricsF/qfontmetricsf_wrap.cpp b/src/cpp/lib/QtGui/QFontMetricsF/qfontmetricsf_wrap.cpp new file mode 100644 index 000000000..528d00d67 --- /dev/null +++ b/src/cpp/lib/QtGui/QFontMetricsF/qfontmetricsf_wrap.cpp @@ -0,0 +1,304 @@ +#include "QtGui/QFontMetricsF/qfontmetricsf_wrap.h" + +#include "Extras/Utils/nutils.h" +#include "QtCore/QRectF/qrectf_wrap.h" +#include "QtCore/QSizeF/qsizef_wrap.h" +#include "QtGui/QFont/qfont_wrap.h" + +Napi::FunctionReference QFontMetricsFWrap::constructor; + +Napi::Object QFontMetricsFWrap::init(Napi::Env env, Napi::Object exports) { + Napi::HandleScope scope(env); + char CLASSNAME[] = "QFontMetricsF"; + Napi::Function func = DefineClass( + env, CLASSNAME, + {InstanceMethod("ascent", &QFontMetricsFWrap::ascent), + InstanceMethod("averageCharWidth", &QFontMetricsFWrap::averageCharWidth), + InstanceMethod("capHeight", &QFontMetricsFWrap::capHeight), + InstanceMethod("descent", &QFontMetricsFWrap::descent), + InstanceMethod("fontDpi", &QFontMetricsFWrap::fontDpi), + InstanceMethod("height", &QFontMetricsFWrap::height), + InstanceMethod("horizontalAdvance", + &QFontMetricsFWrap::horizontalAdvance), + InstanceMethod("inFont", &QFontMetricsFWrap::inFont), + InstanceMethod("leading", &QFontMetricsFWrap::leading), + InstanceMethod("leftBearing", &QFontMetricsFWrap::leftBearing), + InstanceMethod("lineSpacing", &QFontMetricsFWrap::lineSpacing), + InstanceMethod("lineWidth", &QFontMetricsFWrap::lineWidth), + InstanceMethod("overlinePos", &QFontMetricsFWrap::overlinePos), + InstanceMethod("rightBearing", &QFontMetricsFWrap::rightBearing), + InstanceMethod("size", &QFontMetricsFWrap::size), + InstanceMethod("strikeOutPos", &QFontMetricsFWrap::strikeOutPos), + InstanceMethod("swap", &QFontMetricsFWrap::swap), + InstanceMethod("underlinePos", &QFontMetricsFWrap::underlinePos), + InstanceMethod("xHeight", &QFontMetricsFWrap::xHeight), + InstanceMethod("maxWidth", &QFontMetricsFWrap::maxWidth), + InstanceMethod("minLeftBearing", &QFontMetricsFWrap::minLeftBearing), + InstanceMethod("minRightBearing", &QFontMetricsFWrap::minRightBearing), + InstanceMethod("inFontUcs4", &QFontMetricsFWrap::inFontUcs4), + InstanceMethod("boundingRect", &QFontMetricsFWrap::boundingRect), + InstanceMethod("tightBoundingRect", + &QFontMetricsFWrap::tightBoundingRect), + InstanceMethod("elidedText", &QFontMetricsFWrap::elidedText), + COMPONENT_WRAPPED_METHODS_EXPORT_DEFINE(QFontMetricsFWrap)}); + constructor = Napi::Persistent(func); + exports.Set(CLASSNAME, func); + return exports; +} + +QFontMetricsFWrap::QFontMetricsFWrap(const Napi::CallbackInfo& info) + : Napi::ObjectWrap(info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + if (info.Length() == 1) { + if (info[0].IsExternal()) { + this->instance = std::unique_ptr( + info[0].As>().Data()); + } else { + Napi::Object wrap0_0 = info[0].As(); + QFontWrap* wrap0_1 = Napi::ObjectWrap::Unwrap(wrap0_0); + this->instance = + std::make_unique(*wrap0_1->getInternalInstance()); + } + } else { + Napi::TypeError::New(env, "Wrong number of arguments") + .ThrowAsJavaScriptException(); + } + this->rawData = extrautils::configureComponent(this->getInternalInstance()); +} + +QFontMetricsF* QFontMetricsFWrap::getInternalInstance() { + return this->instance.get(); +} + +Napi::Value QFontMetricsFWrap::ascent(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + return Napi::Value::From(env, this->instance->ascent()); +} + +Napi::Value QFontMetricsFWrap::averageCharWidth( + const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + return Napi::Value::From(env, this->instance->averageCharWidth()); +} + +Napi::Value QFontMetricsFWrap::capHeight(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + return Napi::Value::From(env, this->instance->capHeight()); +} + +Napi::Value QFontMetricsFWrap::descent(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + return Napi::Value::From(env, this->instance->descent()); +} + +Napi::Value QFontMetricsFWrap::fontDpi(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + return Napi::Value::From(env, this->instance->fontDpi()); +} + +Napi::Value QFontMetricsFWrap::height(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + return Napi::Value::From(env, this->instance->height()); +} + +Napi::Value QFontMetricsFWrap::horizontalAdvance( + const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + std::string format = info[0].As().Utf8Value(); + QString text = QString::fromUtf8(format.c_str()); + if (info.Length() <= 2 && text.length() == 1) { + return Napi::Value::From(env, this->instance->horizontalAdvance(text[0])); + } else if (info.Length() == 2) { + int len = info[1].As().Int32Value(); + return Napi::Value::From(env, this->instance->horizontalAdvance(text, len)); + } else { + Napi::TypeError::New(env, + "Invalid number of arguments to horizontalAdvance") + .ThrowAsJavaScriptException(); + return env.Null(); + } +} + +Napi::Value QFontMetricsFWrap::inFont(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + char ch = info[0].As().Utf8Value()[0]; + return Napi::Boolean::New(env, this->instance->inFont(ch)); +} + +Napi::Value QFontMetricsFWrap::leading(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + return Napi::Value::From(env, this->instance->leading()); +} + +Napi::Value QFontMetricsFWrap::leftBearing(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + char ch = info[0].As().Utf8Value()[0]; + return Napi::Boolean::New(env, this->instance->leftBearing(ch)); +} + +Napi::Value QFontMetricsFWrap::lineSpacing(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + return Napi::Value::From(env, this->instance->lineSpacing()); +} + +Napi::Value QFontMetricsFWrap::lineWidth(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + return Napi::Value::From(env, this->instance->lineWidth()); +} + +Napi::Value QFontMetricsFWrap::overlinePos(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + return Napi::Value::From(env, this->instance->overlinePos()); +} + +Napi::Value QFontMetricsFWrap::rightBearing(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + char ch = info[0].As().Utf8Value()[0]; + return Napi::Boolean::New(env, this->instance->rightBearing(ch)); +} + +Napi::Value QFontMetricsFWrap::size(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + if (info.Length() != 2 && info.Length() != 3) { + Napi::TypeError::New(env, "Invalid number of arguments to size") + .ThrowAsJavaScriptException(); + return env.Null(); + } + int flags = info[0].As().Int32Value(); + std::string format = info[1].As().Utf8Value(); + QString text = QString::fromUtf8(format.c_str()); + int tabStops = info[2].As().Int32Value(); + QSizeF size = this->instance->size(flags, text, tabStops); + auto instance = QSizeFWrap::constructor.New( + {Napi::External::New(env, new QSizeF(size))}); + return instance; +} + +Napi::Value QFontMetricsFWrap::strikeOutPos(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + return Napi::Value::From(env, this->instance->strikeOutPos()); +} + +Napi::Value QFontMetricsFWrap::swap(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + Napi::Object wrap0_0 = info[0].As(); + QFontMetricsFWrap* wrap0_1 = + Napi::ObjectWrap::Unwrap(wrap0_0); + this->instance->swap(*wrap0_1->getInternalInstance()); + return env.Null(); +} + +Napi::Value QFontMetricsFWrap::underlinePos(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + return Napi::Value::From(env, this->instance->underlinePos()); +} + +Napi::Value QFontMetricsFWrap::xHeight(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + + return Napi::Value::From(env, this->instance->xHeight()); +} + +Napi::Value QFontMetricsFWrap::maxWidth(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + int result = this->instance->maxWidth(); + return Napi::Number::New(env, result); +} + +Napi::Value QFontMetricsFWrap::minLeftBearing(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + int result = this->instance->minLeftBearing(); + return Napi::Number::New(env, result); +} + +Napi::Value QFontMetricsFWrap::minRightBearing(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + int result = this->instance->minRightBearing(); + return Napi::Number::New(env, result); +} + +Napi::Value QFontMetricsFWrap::inFontUcs4(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + uint ucs4 = info[0].As().Uint32Value(); + bool result = this->instance->inFontUcs4(ucs4); + return Napi::Boolean::New(env, result); +} + +Napi::Value QFontMetricsFWrap::boundingRect(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + std::string textNapiText = info[0].As().Utf8Value(); + QString text = QString::fromUtf8(textNapiText.c_str()); + QRectF result = this->instance->boundingRect(text); + auto resultInstance = QRectFWrap::constructor.New( + {Napi::External::New(env, new QRectF(result))}); + return resultInstance; +} + +Napi::Value QFontMetricsFWrap::tightBoundingRect( + const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + std::string textNapiText = info[0].As().Utf8Value(); + QString text = QString::fromUtf8(textNapiText.c_str()); + QRectF result = this->instance->tightBoundingRect(text); + auto resultInstance = QRectFWrap::constructor.New( + {Napi::External::New(env, new QRectF(result))}); + return resultInstance; +} + +Napi::Value QFontMetricsFWrap::elidedText(const Napi::CallbackInfo& info) { + Napi::Env env = info.Env(); + Napi::HandleScope scope(env); + std::string textNapiText = info[0].As().Utf8Value(); + QString text = QString::fromUtf8(textNapiText.c_str()); + Qt::TextElideMode mode = + static_cast(info[1].As().Int32Value()); + int width = info[2].As().Int32Value(); + int flags = info[3].As().Int32Value(); + QString result = this->instance->elidedText(text, mode, width, flags); + return Napi::String::New(env, result.toStdString()); +} diff --git a/src/cpp/main.cpp b/src/cpp/main.cpp index 5e87c73ef..14963003c 100644 --- a/src/cpp/main.cpp +++ b/src/cpp/main.cpp @@ -14,6 +14,7 @@ #include "QtCore/QRectF/qrectf_wrap.h" #include "QtCore/QSettings/qsettings_wrap.h" #include "QtCore/QSize/qsize_wrap.h" +#include "QtCore/QSizeF/qsizef_wrap.h" #include "QtCore/QTime/qtime_wrap.h" #include "QtCore/QUrl/qurl_wrap.h" #include "QtCore/QVariant/qvariant_wrap.h" @@ -35,6 +36,7 @@ #include "QtGui/QFont/qfont_wrap.h" #include "QtGui/QFontDatabase/qfontdatabase_wrap.h" #include "QtGui/QFontMetrics/qfontmetrics_wrap.h" +#include "QtGui/QFontMetricsF/qfontmetricsf_wrap.h" #include "QtGui/QIcon/qicon_wrap.h" #include "QtGui/QImage/qimage_wrap.h" #include "QtGui/QKeySequence/qkeysequence_wrap.h" @@ -131,6 +133,7 @@ Napi::Object Main(Napi::Env env, Napi::Object exports) { QRectWrap::init(env, exports); QRectFWrap::init(env, exports); QSizeWrap::init(env, exports); + QSizeFWrap::init(env, exports); QTimeWrap::init(env, exports); QUrlWrap::init(env, exports); QVariantWrap::init(env, exports); @@ -145,6 +148,7 @@ Napi::Object Main(Napi::Env env, Napi::Object exports) { QKeySequenceWrap::init(env, exports); QFontDatabaseWrap::init(env, exports); QFontMetricsWrap::init(env, exports); + QFontMetricsFWrap::init(env, exports); QIconWrap::init(env, exports); QImageWrap::init(env, exports); QFontWrap::init(env, exports); diff --git a/src/index.ts b/src/index.ts index f321e91de..a63d50611 100644 --- a/src/index.ts +++ b/src/index.ts @@ -20,6 +20,7 @@ export { QClipboard, QClipboardMode } from './lib/QtGui/QClipboard'; export { QStyle, QStylePixelMetric } from './lib/QtGui/QStyle'; export { QFontDatabase, SystemFont, WritingSystem } from './lib/QtGui/QFontDatabase'; export { QFontMetrics } from './lib/QtGui/QFontMetrics'; +export { QFontMetricsF } from './lib/QtGui/QFontMetricsF'; // Events: Maybe a separate module ? export { QKeyEvent } from './lib/QtGui/QEvent/QKeyEvent'; export { QMouseEvent } from './lib/QtGui/QEvent/QMouseEvent'; @@ -150,6 +151,7 @@ export { QMimeData } from './lib/QtCore/QMimeData'; export { QObject, QObjectSignals, NodeObject } from './lib/QtCore/QObject'; export { QVariant } from './lib/QtCore/QVariant'; export { QSize } from './lib/QtCore/QSize'; +export { QSizeF } from './lib/QtCore/QSizeF'; export { QRect } from './lib/QtCore/QRect'; export { QRectF } from './lib/QtCore/QRectF'; export { QPoint } from './lib/QtCore/QPoint'; diff --git a/src/lib/QtCore/QSizeF.ts b/src/lib/QtCore/QSizeF.ts new file mode 100644 index 000000000..bb5acd124 --- /dev/null +++ b/src/lib/QtCore/QSizeF.ts @@ -0,0 +1,36 @@ +import { NativeElement, Component } from '../core/Component'; +import addon from '../utils/addon'; +import { checkIfNativeElement } from '../utils/helpers'; +import { QVariant } from './QVariant'; + +export class QSizeF extends Component { + native: NativeElement; + constructor(); + constructor(nativeElement: NativeElement); + constructor(width?: number, height?: number); + constructor(arg?: number | NativeElement, height?: number) { + super(); + if (!arg) { + this.native = new addon.QSizeF(); + } else if (checkIfNativeElement(arg)) { + this.native = arg as NativeElement; + } else { + this.native = new addon.QSizeF(arg, height); + } + } + setWidth(width: number): void { + return this.native.setWidth(width); + } + width(): number { + return this.native.width(); + } + setHeight(height: number): void { + return this.native.setHeight(height); + } + height(): number { + return this.native.height(); + } + static fromQVariant(variant: QVariant): QSizeF { + return new QSizeF(addon.QSizeF.fromQVariant(variant.native)); + } +} diff --git a/src/lib/QtGui/QFontMetricsF.ts b/src/lib/QtGui/QFontMetricsF.ts new file mode 100644 index 000000000..f5c840d8c --- /dev/null +++ b/src/lib/QtGui/QFontMetricsF.ts @@ -0,0 +1,181 @@ +import addon from '../utils/addon'; +import { Component, NativeElement } from '../core/Component'; +import { QFont } from './QFont'; +import { checkIfNativeElement } from '../utils/helpers'; +import { QSize } from '../QtCore/QSize'; +import { TextElideMode, TextFlag } from '../QtEnums'; +import { QRect } from '../..'; + +export class QFontMetricsF extends Component { + native: NativeElement; + constructor(native: NativeElement); + constructor(qfont: QFont); + constructor(qfontmetricsf: QFontMetricsF); + constructor(arg: QFont | QFontMetricsF | NativeElement) { + super(); + if (checkIfNativeElement(arg)) { + this.native = arg as NativeElement; + } else if (arg instanceof QFontMetricsF) { + this.native = arg.native; + } else { + this.native = new addon.QFontMetricsF(arg.native); + } + } + // *** Public Functions *** + + /** Returns the ascent of the font */ + ascent(): number { + return this.native.ascent(); + } + + /** Returns the average width of glyphs in the font */ + averageCharWidth(): number { + return this.native.averageCharWidth(); + } + + boundingRect(text: string): QRect { + return new QRect(this.native.boundingRect(text)); + } + + /** Returns the cap height of the font */ + capHeight(): number { + return this.native.capHeight(); + } + + /** Returns the descent of the font */ + descent(): number { + return this.native.descent(); + } + + elidedText(text: string, mode: TextElideMode, width: number, flags = 0): string { + return this.native.elidedText(text, mode, width, flags); + } + + /** Returns the font DPI */ + fontDpi(): number { + return this.native.fontDpi(); + } + + /** Returns the height of the font */ + height(): number { + return this.native.height(); + } + + /** Returns the horizontal advance in pixels of the first len characters of text. If len is negative (the default), the entire string is used */ + horizontalAdvance(text: string, len = -1): number { + return this.native.horizontalAdvance(text, len); + } + + /** Returns true if character ch is a valid character in the font; otherwise returns false */ + inFont(text: string): number { + return this.native.inFont(text); + } + + inFontUcs4(ucs4: number): boolean { + return this.native.inFontUcs4(ucs4); + } + + /** Returns the leading of the font */ + leading(): number { + return this.native.leading(); + } + + /** Returns the left bearing of character ch in the font */ + leftBearing(text: string): number { + return this.native.leftBearing(text); + } + + /** Returns the distance from one base line to the next */ + lineSpacing(): number { + return this.native.lineSpacing(); + } + + /** Returns the width of the underline and strikeout lines, adjusted for the point size of the font */ + lineWidth(): number { + return this.native.lineWidth(); + } + maxWidth(): number { + return this.native.maxWidth(); + } + minLeftBearing(): number { + return this.native.minLeftBearing(); + } + minRightBearing(): number { + return this.native.minRightBearing(); + } + + /** Returns the distance from the base line to where an overline should be drawn */ + overlinePos(): number { + return this.native.overlinePos(); + } + + /** Returns the right bearing of character ch in the font */ + rightBearing(text: string): number { + return this.native.rightBearing(text); + } + + /** + * Returns the size in pixels of text + * + * See QtEnums::TextFlag for flags + */ + size(flags: TextFlag, text: string, tabStops = 0): QSize { + const native = this.native.size(flags, text, tabStops); + return new QSize(native); + } + + /** Returns the distance from the base line to where the strikeout line should be drawn */ + strikeOutPos(): number { + return this.native.strikeOutPos(); + } + + /** Swaps metrics other with this metrics. This operation is very fast and never fails */ + swap(other: QFontMetricsF): void { + return this.native.swap(other.native); + } + + tightBoundingRect(text: string): QRect { + return new QRect(this.native.tightBoundingRect(text)); + } + + /** Returns the distance from the base line to where an underscore should be drawn */ + underlinePos(): number { + return this.native.underlinePos(); + } + + /** Returns the 'x' height of the font. This is often but not always the same as the height of the character 'x'. */ + xHeight(): number { + return this.native.xHeight(); + } + // TODO: qreal ascent() const + // TODO: qreal averageCharWidth() const + // TODO: QRectF boundingRect(const QString &text) const + // TODO: QRectF boundingRect(QChar ch) const + // TODO: QRectF boundingRect(const QRectF &rect, int flags, const QString &text, int tabStops = 0, int *tabArray = nullptr) const + // TODO: qreal capHeight() const + // TODO: qreal descent() const + // TODO: QString elidedText(const QString &text, Qt::TextElideMode mode, qreal width, int flags = 0) const + // TODO: qreal fontDpi() const + // TODO: qreal height() const + // TODO: qreal horizontalAdvance(const QString &text, int length = -1) const + // TODO: qreal horizontalAdvance(QChar ch) const + // TODO: bool inFont(QChar ch) const + // TODO: bool inFontUcs4(uint ch) const + // TODO: qreal leading() const + // TODO: qreal leftBearing(QChar ch) const + // TODO: qreal lineSpacing() const + // TODO: qreal lineWidth() const + // TODO: qreal maxWidth() const + // TODO: qreal minLeftBearing() const + // TODO: qreal minRightBearing() const + // TODO: qreal overlinePos() const + // TODO: qreal rightBearing(QChar ch) const + // TODO: QSizeF size(int flags, const QString &text, int tabStops = 0, int *tabArray = nullptr) const + // TODO: qreal strikeOutPos() const + // TODO: void swap(QFontMetricsF &other) + // TODO: QRectF tightBoundingRect(const QString &text) const + // TODO: qreal underlinePos() const + // TODO: qreal xHeight() const + // TODO: bool operator!=(const QFontMetricsF &other) const + // TODO: bool operator==(const QFontMetricsF &other) const +}