ruby-qt6-qtgui 1.0.0

data/ext/qt6/qtgui/qfilesystemmodel-rb.cpp

@@ -0,0 +1,96 @@
+#include "qfilesystemmodel-rb.hpp"
+#include <qfilesystemmodel.h>
+#include <rice/qt6/qenum.hpp>
+#include <rice/qt6/qflags.hpp>
+
+#include <QAbstractFileIconProvider>
+#include <QMimeData>
+
+using namespace Rice;
+
+Rice::Class rb_cQFileSystemModel;
+
+void Init_qfilesystemmodel(Rice::Module rb_mQt6QtGui)
+{
+    rb_cQFileSystemModel =
+        // RubyQt6::QtGui::QFileSystemModel
+        define_class_under<QFileSystemModel, QAbstractItemModel>(rb_mQt6QtGui, "QFileSystemModel")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QFileSystemModel::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QFileSystemModel, QObject *>(), Arg("parent"))
+            // Public Functions
+            .define_method("can_fetch_more", &QFileSystemModel::canFetchMore, Arg("parent"))
+            .define_method("column_count", &QFileSystemModel::columnCount, Arg("parent") = static_cast<const QModelIndex &>(QModelIndex()))
+            .define_method("data", &QFileSystemModel::data, Arg("index"), Arg("role") = static_cast<int>(Qt::DisplayRole))
+            .define_method("drop_mime_data", &QFileSystemModel::dropMimeData, Arg("data"), Arg("action"), Arg("row"), Arg("column"), Arg("parent"))
+            .define_method("fetch_more", &QFileSystemModel::fetchMore, Arg("parent"))
+            .define_method("file_icon", &QFileSystemModel::fileIcon, Arg("index"))
+            .define_method("file_info", &QFileSystemModel::fileInfo, Arg("index"))
+            .define_method("file_name", &QFileSystemModel::fileName, Arg("index"))
+            .define_method("file_path", &QFileSystemModel::filePath, Arg("index"))
+            .define_method("filter", &QFileSystemModel::filter)
+            .define_method("flags", &QFileSystemModel::flags, Arg("index"))
+            .define_method("has_children", &QFileSystemModel::hasChildren, Arg("parent") = static_cast<const QModelIndex &>(QModelIndex()))
+            .define_method("header_data", &QFileSystemModel::headerData, Arg("section"), Arg("orientation"), Arg("role") = static_cast<int>(Qt::DisplayRole))
+            .define_method("icon_provider", &QFileSystemModel::iconProvider)
+            .define_method<QModelIndex (QFileSystemModel::*)(const QString &, int) const>("index", &QFileSystemModel::index, Arg("path"), Arg("column") = static_cast<int>(0))
+            .define_method<QModelIndex (QFileSystemModel::*)(int, int, const QModelIndex &) const>("index", &QFileSystemModel::index, Arg("row"), Arg("column"), Arg("parent") = static_cast<const QModelIndex &>(QModelIndex()))
+            .define_method("dir?", &QFileSystemModel::isDir, Arg("index"))
+            .define_method("read_only?", &QFileSystemModel::isReadOnly)
+            .define_method<QDateTime (QFileSystemModel::*)(const QModelIndex &) const>("last_modified", &QFileSystemModel::lastModified, Arg("index"))
+            .define_method<QDateTime (QFileSystemModel::*)(const QModelIndex &, const QTimeZone &) const>("last_modified", &QFileSystemModel::lastModified, Arg("index"), Arg("tz"))
+            .define_method("mime_data", &QFileSystemModel::mimeData, Arg("indexes"))
+            .define_method("mime_types", &QFileSystemModel::mimeTypes)
+            .define_method("mkdir", &QFileSystemModel::mkdir, Arg("parent"), Arg("name"))
+            .define_method("my_computer", &QFileSystemModel::myComputer, Arg("role") = static_cast<int>(Qt::DisplayRole))
+            .define_method("name_filter_disables", &QFileSystemModel::nameFilterDisables)
+            .define_method("name_filters", &QFileSystemModel::nameFilters)
+            .define_method("options", &QFileSystemModel::options)
+            // .define_method("parent", &QFileSystemModel::parent, Arg("child"))
+            .define_method("permissions", &QFileSystemModel::permissions, Arg("index"))
+            .define_method("remove", &QFileSystemModel::remove, Arg("index"))
+            .define_method("resolve_symlinks", &QFileSystemModel::resolveSymlinks)
+            .define_method("rmdir", &QFileSystemModel::rmdir, Arg("index"))
+            .define_method("role_names", &QFileSystemModel::roleNames)
+            .define_method("root_directory", &QFileSystemModel::rootDirectory)
+            .define_method("root_path", &QFileSystemModel::rootPath)
+            .define_method("row_count", &QFileSystemModel::rowCount, Arg("parent") = static_cast<const QModelIndex &>(QModelIndex()))
+            .define_method("set_data", &QFileSystemModel::setData, Arg("index"), Arg("value"), Arg("role") = static_cast<int>(Qt::EditRole))
+            .define_method("set_filter", &QFileSystemModel::setFilter, Arg("filters"))
+            .define_method("set_icon_provider", &QFileSystemModel::setIconProvider, Arg("provider"))
+            .define_method("set_name_filter_disables", &QFileSystemModel::setNameFilterDisables, Arg("enable"))
+            .define_method("set_name_filters", &QFileSystemModel::setNameFilters, Arg("filters"))
+            .define_method("set_option", &QFileSystemModel::setOption, Arg("option"), Arg("on") = static_cast<bool>(true))
+            .define_method("set_options", &QFileSystemModel::setOptions, Arg("options"))
+            .define_method("set_read_only", &QFileSystemModel::setReadOnly, Arg("enable"))
+            .define_method("set_resolve_symlinks", &QFileSystemModel::setResolveSymlinks, Arg("enable"))
+            .define_method("set_root_path", &QFileSystemModel::setRootPath, Arg("path"))
+            .define_method("sibling", &QFileSystemModel::sibling, Arg("row"), Arg("column"), Arg("idx"))
+            .define_method("size", &QFileSystemModel::size, Arg("index"))
+            .define_method("sort", &QFileSystemModel::sort, Arg("column"), Arg("order") = static_cast<Qt::SortOrder>(Qt::AscendingOrder))
+            .define_method("supported_drop_actions", &QFileSystemModel::supportedDropActions)
+            .define_method("test_option", &QFileSystemModel::testOption, Arg("option"))
+            .define_method("type", &QFileSystemModel::type, Arg("index"))
+            // Signals
+            .define_method("directory_loaded", &QFileSystemModel::directoryLoaded, Arg("path"))
+            .define_method("file_renamed", &QFileSystemModel::fileRenamed, Arg("path"), Arg("old_name"), Arg("new_name"))
+            .define_method("root_path_changed", &QFileSystemModel::rootPathChanged, Arg("new_path"));
+
+    Data_Type<QFileSystemModel::Roles> rb_cQFileSystemModelRoles =
+        // RubyQt6::QtGui::QFileSystemModel::Roles
+        define_qenum_under<QFileSystemModel::Roles>(rb_cQFileSystemModel, "Roles");
+        define_qenum_value_under(rb_cQFileSystemModelRoles, "FileIconRole", QFileSystemModel::Roles::FileIconRole);
+        define_qenum_value_under(rb_cQFileSystemModelRoles, "FileInfoRole", QFileSystemModel::Roles::FileInfoRole);
+
+    Data_Type<QFileSystemModel::Option> rb_cQFileSystemModelOption =
+        // RubyQt6::QtGui::QFileSystemModel::Option
+        define_qenum_under<QFileSystemModel::Option>(rb_cQFileSystemModel, "Option");
+        define_qenum_value_under(rb_cQFileSystemModelOption, "DontWatchForChanges", QFileSystemModel::Option::DontWatchForChanges);
+        define_qenum_value_under(rb_cQFileSystemModelOption, "DontResolveSymlinks", QFileSystemModel::Option::DontResolveSymlinks);
+        define_qenum_value_under(rb_cQFileSystemModelOption, "DontUseCustomDirectoryIcons", QFileSystemModel::Option::DontUseCustomDirectoryIcons);
+
+    Data_Type<QFlags<QFileSystemModel::Option>> rb_cQFileSystemModelOptions =
+        // RubyQt6::QtGui::QFileSystemModel::Options
+        define_qflags_under<QFileSystemModel::Option>(rb_cQFileSystemModel, "Options");
+}

data/ext/qt6/qtgui/qfilesystemmodel-rb.hpp

@@ -0,0 +1,4 @@
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+void Init_qfilesystemmodel(Rice::Module rb_mQt6QtGui);

data/ext/qt6/qtgui/qfont-rb.cpp

@@ -0,0 +1,193 @@
+#include "qfont-rb.hpp"
+#include <qfont.h>
+#include <rice/qt6/qenum.hpp>
+
+#include <QStringList>
+
+using namespace Rice;
+
+Rice::Class rb_cQFont;
+
+void Init_qfont(Rice::Module rb_mQt6QtGui)
+{
+    rb_cQFont =
+        // RubyQt6::QtGui::QFont
+        define_class_under<QFont>(rb_mQt6QtGui, "QFont")
+            // Constructor
+            .define_constructor(Constructor<QFont>())
+            .define_constructor(Constructor<QFont, const QString &>(), Arg("family"))
+            .define_constructor(Constructor<QFont, const QString &, int>(), Arg("family"), Arg("point_size"))
+            .define_constructor(Constructor<QFont, const QString &, int, int>(), Arg("family"), Arg("point_size"), Arg("weight"))
+            .define_constructor(Constructor<QFont, const QStringList &>(), Arg("families"))
+            .define_constructor(Constructor<QFont, const QStringList &, int>(), Arg("families"), Arg("point_size"))
+            .define_constructor(Constructor<QFont, const QStringList &, int, int>(), Arg("families"), Arg("point_size"), Arg("weight"))
+            // Public Functions
+            .define_method("bold", &QFont::bold)
+            .define_method("capitalization", &QFont::capitalization)
+            .define_method("clear_features", &QFont::clearFeatures)
+            .define_method("clear_variable_axes", &QFont::clearVariableAxes)
+            .define_method("default_family", &QFont::defaultFamily)
+            .define_method("exact_match", &QFont::exactMatch)
+            .define_method("families", &QFont::families)
+            .define_method("family", &QFont::family)
+            .define_method("feature_tags", &QFont::featureTags)
+            .define_method("feature_value", &QFont::featureValue, Arg("tag"))
+            .define_method("fixed_pitch", &QFont::fixedPitch)
+            .define_method("from_string", &QFont::fromString, Arg("descrip"))
+            .define_method("hinting_preference", &QFont::hintingPreference)
+            .define_method("copy_of?", &QFont::isCopyOf, Arg("f"))
+            .define_method("feature_set?", &QFont::isFeatureSet, Arg("tag"))
+            .define_method("variable_axis_set?", &QFont::isVariableAxisSet, Arg("tag"))
+            .define_method("italic", &QFont::italic)
+            .define_method("kerning", &QFont::kerning)
+            .define_method("key", &QFont::key)
+            .define_method("letter_spacing", &QFont::letterSpacing)
+            .define_method("letter_spacing_type", &QFont::letterSpacingType)
+            .define_method("overline", &QFont::overline)
+            .define_method("pixel_size", &QFont::pixelSize)
+            .define_method("point_size", &QFont::pointSize)
+            .define_method("point_size_f", &QFont::pointSizeF)
+            .define_method("resolve", &QFont::resolve, Arg("other"))
+            .define_method("resolve_mask", &QFont::resolveMask)
+            .define_method("set_bold", &QFont::setBold, Arg("enable"))
+            .define_method("set_capitalization", &QFont::setCapitalization, Arg("caps"))
+            .define_method("set_families", &QFont::setFamilies, Arg("families"))
+            .define_method("set_family", &QFont::setFamily, Arg("family"))
+            .define_method("set_feature", &QFont::setFeature, Arg("tag"), Arg("value"))
+            .define_method("set_fixed_pitch", &QFont::setFixedPitch, Arg("enable"))
+            .define_method("set_hinting_preference", &QFont::setHintingPreference, Arg("hinting_preference"))
+            .define_method("set_italic", &QFont::setItalic, Arg("b"))
+            .define_method("set_kerning", &QFont::setKerning, Arg("enable"))
+            .define_method("set_letter_spacing", &QFont::setLetterSpacing, Arg("type"), Arg("spacing"))
+            .define_method("set_overline", &QFont::setOverline, Arg("enable"))
+            .define_method("set_pixel_size", &QFont::setPixelSize, Arg("pixel_size"))
+            .define_method("set_point_size", &QFont::setPointSize, Arg("point_size"))
+            .define_method("set_point_size_f", &QFont::setPointSizeF, Arg("point_size"))
+            .define_method("set_resolve_mask", &QFont::setResolveMask, Arg("mask"))
+            .define_method("set_stretch", &QFont::setStretch, Arg("factor"))
+            .define_method("set_strike_out", &QFont::setStrikeOut, Arg("enable"))
+            .define_method("set_style", &QFont::setStyle, Arg("style"))
+            .define_method("set_style_hint", &QFont::setStyleHint, Arg("hint"), Arg("strategy") = static_cast<QFont::StyleStrategy>(QFont::StyleStrategy::PreferDefault))
+            .define_method("set_style_name", &QFont::setStyleName, Arg("name"))
+            .define_method("set_style_strategy", &QFont::setStyleStrategy, Arg("s"))
+            .define_method("set_underline", &QFont::setUnderline, Arg("enable"))
+            .define_method("set_variable_axis", &QFont::setVariableAxis, Arg("tag"), Arg("value"))
+            .define_method("set_weight", &QFont::setWeight, Arg("weight"))
+            .define_method("set_word_spacing", &QFont::setWordSpacing, Arg("spacing"))
+            .define_method("stretch", &QFont::stretch)
+            .define_method("strike_out", &QFont::strikeOut)
+            .define_method("style", &QFont::style)
+            .define_method("style_hint", &QFont::styleHint)
+            .define_method("style_name", &QFont::styleName)
+            .define_method("style_strategy", &QFont::styleStrategy)
+            .define_method("to_string", &QFont::toString)
+            .define_method("underline", &QFont::underline)
+            .define_method("unset_feature", &QFont::unsetFeature, Arg("tag"))
+            .define_method("unset_variable_axis", &QFont::unsetVariableAxis, Arg("tag"))
+            .define_method("variable_axis_tags", &QFont::variableAxisTags)
+            .define_method("variable_axis_value", &QFont::variableAxisValue, Arg("tag"))
+            .define_method("weight", &QFont::weight)
+            .define_method("word_spacing", &QFont::wordSpacing)
+            // Static Public Members
+            .define_singleton_function("cache_statistics", &QFont::cacheStatistics)
+            .define_singleton_function("cleanup", &QFont::cleanup)
+            .define_singleton_function("initialize", &QFont::initialize)
+            .define_singleton_function("insert_substitution", &QFont::insertSubstitution, Arg("family_name"), Arg("substitute_name"))
+            .define_singleton_function("insert_substitutions", &QFont::insertSubstitutions, Arg("family_name"), Arg("substitute_names"))
+            .define_singleton_function("remove_substitutions", &QFont::removeSubstitutions, Arg("family_name"))
+            .define_singleton_function("substitute", &QFont::substitute, Arg("family_name"))
+            .define_singleton_function("substitutes", &QFont::substitutes, Arg("family_name"))
+            .define_singleton_function("substitutions", &QFont::substitutions);
+
+    Data_Type<QFont::Capitalization> rb_cQFontCapitalization =
+        // RubyQt6::QtGui::QFont::Capitalization
+        define_qenum_under<QFont::Capitalization>(rb_cQFont, "Capitalization");
+        define_qenum_value_under(rb_cQFontCapitalization, "MixedCase", QFont::Capitalization::MixedCase);
+        define_qenum_value_under(rb_cQFontCapitalization, "AllUppercase", QFont::Capitalization::AllUppercase);
+        define_qenum_value_under(rb_cQFontCapitalization, "AllLowercase", QFont::Capitalization::AllLowercase);
+        define_qenum_value_under(rb_cQFontCapitalization, "SmallCaps", QFont::Capitalization::SmallCaps);
+        define_qenum_value_under(rb_cQFontCapitalization, "Capitalize", QFont::Capitalization::Capitalize);
+
+    Data_Type<QFont::HintingPreference> rb_cQFontHintingPreference =
+        // RubyQt6::QtGui::QFont::HintingPreference
+        define_qenum_under<QFont::HintingPreference>(rb_cQFont, "HintingPreference");
+        define_qenum_value_under(rb_cQFontHintingPreference, "PreferDefaultHinting", QFont::HintingPreference::PreferDefaultHinting);
+        define_qenum_value_under(rb_cQFontHintingPreference, "PreferNoHinting", QFont::HintingPreference::PreferNoHinting);
+        define_qenum_value_under(rb_cQFontHintingPreference, "PreferVerticalHinting", QFont::HintingPreference::PreferVerticalHinting);
+        define_qenum_value_under(rb_cQFontHintingPreference, "PreferFullHinting", QFont::HintingPreference::PreferFullHinting);
+
+    Data_Type<QFont::SpacingType> rb_cQFontSpacingType =
+        // RubyQt6::QtGui::QFont::SpacingType
+        define_qenum_under<QFont::SpacingType>(rb_cQFont, "SpacingType");
+        define_qenum_value_under(rb_cQFontSpacingType, "PercentageSpacing", QFont::SpacingType::PercentageSpacing);
+        define_qenum_value_under(rb_cQFontSpacingType, "AbsoluteSpacing", QFont::SpacingType::AbsoluteSpacing);
+
+    Data_Type<QFont::Stretch> rb_cQFontStretch =
+        // RubyQt6::QtGui::QFont::Stretch
+        define_qenum_under<QFont::Stretch>(rb_cQFont, "Stretch");
+        define_qenum_value_under(rb_cQFontStretch, "AnyStretch", QFont::Stretch::AnyStretch);
+        define_qenum_value_under(rb_cQFontStretch, "UltraCondensed", QFont::Stretch::UltraCondensed);
+        define_qenum_value_under(rb_cQFontStretch, "ExtraCondensed", QFont::Stretch::ExtraCondensed);
+        define_qenum_value_under(rb_cQFontStretch, "Condensed", QFont::Stretch::Condensed);
+        define_qenum_value_under(rb_cQFontStretch, "SemiCondensed", QFont::Stretch::SemiCondensed);
+        define_qenum_value_under(rb_cQFontStretch, "Unstretched", QFont::Stretch::Unstretched);
+        define_qenum_value_under(rb_cQFontStretch, "SemiExpanded", QFont::Stretch::SemiExpanded);
+        define_qenum_value_under(rb_cQFontStretch, "Expanded", QFont::Stretch::Expanded);
+        define_qenum_value_under(rb_cQFontStretch, "ExtraExpanded", QFont::Stretch::ExtraExpanded);
+        define_qenum_value_under(rb_cQFontStretch, "UltraExpanded", QFont::Stretch::UltraExpanded);
+
+    Data_Type<QFont::Style> rb_cQFontStyle =
+        // RubyQt6::QtGui::QFont::Style
+        define_qenum_under<QFont::Style>(rb_cQFont, "Style");
+        define_qenum_value_under(rb_cQFontStyle, "StyleNormal", QFont::Style::StyleNormal);
+        define_qenum_value_under(rb_cQFontStyle, "StyleItalic", QFont::Style::StyleItalic);
+        define_qenum_value_under(rb_cQFontStyle, "StyleOblique", QFont::Style::StyleOblique);
+
+    Data_Type<QFont::StyleHint> rb_cQFontStyleHint =
+        // RubyQt6::QtGui::QFont::StyleHint
+        define_qenum_under<QFont::StyleHint>(rb_cQFont, "StyleHint");
+        define_qenum_value_under(rb_cQFontStyleHint, "Helvetica", QFont::StyleHint::Helvetica);
+        define_qenum_value_under(rb_cQFontStyleHint, "SansSerif", QFont::StyleHint::SansSerif);
+        define_qenum_value_under(rb_cQFontStyleHint, "Times", QFont::StyleHint::Times);
+        define_qenum_value_under(rb_cQFontStyleHint, "Serif", QFont::StyleHint::Serif);
+        define_qenum_value_under(rb_cQFontStyleHint, "Courier", QFont::StyleHint::Courier);
+        define_qenum_value_under(rb_cQFontStyleHint, "TypeWriter", QFont::StyleHint::TypeWriter);
+        define_qenum_value_under(rb_cQFontStyleHint, "OldEnglish", QFont::StyleHint::OldEnglish);
+        define_qenum_value_under(rb_cQFontStyleHint, "Decorative", QFont::StyleHint::Decorative);
+        define_qenum_value_under(rb_cQFontStyleHint, "System", QFont::StyleHint::System);
+        define_qenum_value_under(rb_cQFontStyleHint, "AnyStyle", QFont::StyleHint::AnyStyle);
+        define_qenum_value_under(rb_cQFontStyleHint, "Cursive", QFont::StyleHint::Cursive);
+        define_qenum_value_under(rb_cQFontStyleHint, "Monospace", QFont::StyleHint::Monospace);
+        define_qenum_value_under(rb_cQFontStyleHint, "Fantasy", QFont::StyleHint::Fantasy);
+
+    Data_Type<QFont::StyleStrategy> rb_cQFontStyleStrategy =
+        // RubyQt6::QtGui::QFont::StyleStrategy
+        define_qenum_under<QFont::StyleStrategy>(rb_cQFont, "StyleStrategy");
+        define_qenum_value_under(rb_cQFontStyleStrategy, "PreferDefault", QFont::StyleStrategy::PreferDefault);
+        define_qenum_value_under(rb_cQFontStyleStrategy, "PreferBitmap", QFont::StyleStrategy::PreferBitmap);
+        define_qenum_value_under(rb_cQFontStyleStrategy, "PreferDevice", QFont::StyleStrategy::PreferDevice);
+        define_qenum_value_under(rb_cQFontStyleStrategy, "PreferOutline", QFont::StyleStrategy::PreferOutline);
+        define_qenum_value_under(rb_cQFontStyleStrategy, "ForceOutline", QFont::StyleStrategy::ForceOutline);
+        define_qenum_value_under(rb_cQFontStyleStrategy, "PreferMatch", QFont::StyleStrategy::PreferMatch);
+        define_qenum_value_under(rb_cQFontStyleStrategy, "PreferQuality", QFont::StyleStrategy::PreferQuality);
+        define_qenum_value_under(rb_cQFontStyleStrategy, "PreferAntialias", QFont::StyleStrategy::PreferAntialias);
+        define_qenum_value_under(rb_cQFontStyleStrategy, "NoAntialias", QFont::StyleStrategy::NoAntialias);
+        define_qenum_value_under(rb_cQFontStyleStrategy, "NoSubpixelAntialias", QFont::StyleStrategy::NoSubpixelAntialias);
+        define_qenum_value_under(rb_cQFontStyleStrategy, "PreferNoShaping", QFont::StyleStrategy::PreferNoShaping);
+        define_qenum_value_under(rb_cQFontStyleStrategy, "ContextFontMerging", QFont::StyleStrategy::ContextFontMerging);
+        define_qenum_value_under(rb_cQFontStyleStrategy, "PreferTypoLineMetrics", QFont::StyleStrategy::PreferTypoLineMetrics);
+        define_qenum_value_under(rb_cQFontStyleStrategy, "NoFontMerging", QFont::StyleStrategy::NoFontMerging);
+
+    Data_Type<QFont::Weight> rb_cQFontWeight =
+        // RubyQt6::QtGui::QFont::Weight
+        define_qenum_under<QFont::Weight>(rb_cQFont, "Weight");
+        define_qenum_value_under(rb_cQFontWeight, "Thin", QFont::Weight::Thin);
+        define_qenum_value_under(rb_cQFontWeight, "ExtraLight", QFont::Weight::ExtraLight);
+        define_qenum_value_under(rb_cQFontWeight, "Light", QFont::Weight::Light);
+        define_qenum_value_under(rb_cQFontWeight, "Normal", QFont::Weight::Normal);
+        define_qenum_value_under(rb_cQFontWeight, "Medium", QFont::Weight::Medium);
+        define_qenum_value_under(rb_cQFontWeight, "DemiBold", QFont::Weight::DemiBold);
+        define_qenum_value_under(rb_cQFontWeight, "Bold", QFont::Weight::Bold);
+        define_qenum_value_under(rb_cQFontWeight, "ExtraBold", QFont::Weight::ExtraBold);
+        define_qenum_value_under(rb_cQFontWeight, "Black", QFont::Weight::Black);
+}

data/ext/qt6/qtgui/qfont-rb.hpp

@@ -0,0 +1,4 @@
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+void Init_qfont(Rice::Module rb_mQt6QtGui);

data/ext/qt6/qtgui/qfontdatabase-rb.cpp

@@ -0,0 +1,101 @@
+#include "qfontdatabase-rb.hpp"
+#include <qfontdatabase.h>
+#include <rice/qt6/qenum.hpp>
+
+#include <QFontInfo>
+#include <QList>
+
+using namespace Rice;
+
+Rice::Class rb_cQFontDatabase;
+
+void Init_qfontdatabase(Rice::Module rb_mQt6QtGui)
+{
+    rb_cQFontDatabase =
+        // RubyQt6::QtGui::QFontDatabase
+        define_class_under<QFontDatabase>(rb_mQt6QtGui, "QFontDatabase")
+            // Static Public Members
+            .define_singleton_function("add_application_emoji_font_family", &QFontDatabase::addApplicationEmojiFontFamily, Arg("family_name"))
+            .define_singleton_function("add_application_fallback_font_family", &QFontDatabase::addApplicationFallbackFontFamily, Arg("script"), Arg("family_name"))
+            .define_singleton_function("add_application_font", &QFontDatabase::addApplicationFont, Arg("file_name"))
+            .define_singleton_function("add_application_font_from_data", &QFontDatabase::addApplicationFontFromData, Arg("font_data"))
+            .define_singleton_function("application_emoji_font_families", &QFontDatabase::applicationEmojiFontFamilies)
+            .define_singleton_function("application_fallback_font_families", &QFontDatabase::applicationFallbackFontFamilies, Arg("script"))
+            .define_singleton_function("application_font_families", &QFontDatabase::applicationFontFamilies, Arg("id"))
+            .define_singleton_function("bold", &QFontDatabase::bold, Arg("family"), Arg("style"))
+            .define_singleton_function("families", &QFontDatabase::families, Arg("writing_system") = static_cast<QFontDatabase::WritingSystem>(QFontDatabase::WritingSystem::Any))
+            .define_singleton_function("font", &QFontDatabase::font, Arg("family"), Arg("style"), Arg("point_size"))
+            .define_singleton_function("has_family", &QFontDatabase::hasFamily, Arg("family"))
+            .define_singleton_function("bitmap_scalable?", &QFontDatabase::isBitmapScalable, Arg("family"), Arg("style") = static_cast<const QString &>(QString()))
+            .define_singleton_function("fixed_pitch?", &QFontDatabase::isFixedPitch, Arg("family"), Arg("style") = static_cast<const QString &>(QString()))
+            .define_singleton_function("private_family?", &QFontDatabase::isPrivateFamily, Arg("family"))
+            .define_singleton_function("scalable?", &QFontDatabase::isScalable, Arg("family"), Arg("style") = static_cast<const QString &>(QString()))
+            .define_singleton_function("smoothly_scalable?", &QFontDatabase::isSmoothlyScalable, Arg("family"), Arg("style") = static_cast<const QString &>(QString()))
+            .define_singleton_function("italic", &QFontDatabase::italic, Arg("family"), Arg("style"))
+            .define_singleton_function("point_sizes", &QFontDatabase::pointSizes, Arg("family"), Arg("style") = static_cast<const QString &>(QString()))
+            .define_singleton_function("remove_all_application_fonts", &QFontDatabase::removeAllApplicationFonts)
+            .define_singleton_function("remove_application_emoji_font_family", &QFontDatabase::removeApplicationEmojiFontFamily, Arg("family_name"))
+            .define_singleton_function("remove_application_fallback_font_family", &QFontDatabase::removeApplicationFallbackFontFamily, Arg("script"), Arg("family_name"))
+            .define_singleton_function("remove_application_font", &QFontDatabase::removeApplicationFont, Arg("id"))
+            .define_singleton_function("set_application_emoji_font_families", &QFontDatabase::setApplicationEmojiFontFamilies, Arg("family_names"))
+            .define_singleton_function("set_application_fallback_font_families", &QFontDatabase::setApplicationFallbackFontFamilies, Arg("script"), Arg("family_names"))
+            .define_singleton_function("smooth_sizes", &QFontDatabase::smoothSizes, Arg("family"), Arg("style"))
+            .define_singleton_function("standard_sizes", &QFontDatabase::standardSizes)
+            .define_singleton_function<QString (*)(const QFont &)>("style_string", &QFontDatabase::styleString, Arg("font"))
+            .define_singleton_function<QString (*)(const QFontInfo &)>("style_string", &QFontDatabase::styleString, Arg("font_info"))
+            .define_singleton_function("styles", &QFontDatabase::styles, Arg("family"))
+            .define_singleton_function("system_font", &QFontDatabase::systemFont, Arg("type"))
+            .define_singleton_function("weight", &QFontDatabase::weight, Arg("family"), Arg("style"))
+            .define_singleton_function("writing_system_name", &QFontDatabase::writingSystemName, Arg("writing_system"))
+            .define_singleton_function("writing_system_sample", &QFontDatabase::writingSystemSample, Arg("writing_system"))
+            .define_singleton_function<QList<QFontDatabase::WritingSystem> (*)()>("writing_systems", &QFontDatabase::writingSystems)
+            .define_singleton_function<QList<QFontDatabase::WritingSystem> (*)(const QString &)>("writing_systems", &QFontDatabase::writingSystems, Arg("family"));
+
+    Data_Type<QFontDatabase::WritingSystem> rb_cQFontDatabaseWritingSystem =
+        // RubyQt6::QtGui::QFontDatabase::WritingSystem
+        define_qenum_under<QFontDatabase::WritingSystem>(rb_cQFontDatabase, "WritingSystem");
+        define_qenum_value_under(rb_cQFontDatabaseWritingSystem, "Any", QFontDatabase::WritingSystem::Any);
+        define_qenum_value_under(rb_cQFontDatabaseWritingSystem, "Latin", QFontDatabase::WritingSystem::Latin);
+        define_qenum_value_under(rb_cQFontDatabaseWritingSystem, "Greek", QFontDatabase::WritingSystem::Greek);
+        define_qenum_value_under(rb_cQFontDatabaseWritingSystem, "Cyrillic", QFontDatabase::WritingSystem::Cyrillic);
+        define_qenum_value_under(rb_cQFontDatabaseWritingSystem, "Armenian", QFontDatabase::WritingSystem::Armenian);
+        define_qenum_value_under(rb_cQFontDatabaseWritingSystem, "Hebrew", QFontDatabase::WritingSystem::Hebrew);
+        define_qenum_value_under(rb_cQFontDatabaseWritingSystem, "Arabic", QFontDatabase::WritingSystem::Arabic);
+        define_qenum_value_under(rb_cQFontDatabaseWritingSystem, "Syriac", QFontDatabase::WritingSystem::Syriac);
+        define_qenum_value_under(rb_cQFontDatabaseWritingSystem, "Thaana", QFontDatabase::WritingSystem::Thaana);
+        define_qenum_value_under(rb_cQFontDatabaseWritingSystem, "Devanagari", QFontDatabase::WritingSystem::Devanagari);
+        define_qenum_value_under(rb_cQFontDatabaseWritingSystem, "Bengali", QFontDatabase::WritingSystem::Bengali);
+        define_qenum_value_under(rb_cQFontDatabaseWritingSystem, "Gurmukhi", QFontDatabase::WritingSystem::Gurmukhi);
+        define_qenum_value_under(rb_cQFontDatabaseWritingSystem, "Gujarati", QFontDatabase::WritingSystem::Gujarati);
+        define_qenum_value_under(rb_cQFontDatabaseWritingSystem, "Oriya", QFontDatabase::WritingSystem::Oriya);
+        define_qenum_value_under(rb_cQFontDatabaseWritingSystem, "Tamil", QFontDatabase::WritingSystem::Tamil);
+        define_qenum_value_under(rb_cQFontDatabaseWritingSystem, "Telugu", QFontDatabase::WritingSystem::Telugu);
+        define_qenum_value_under(rb_cQFontDatabaseWritingSystem, "Kannada", QFontDatabase::WritingSystem::Kannada);
+        define_qenum_value_under(rb_cQFontDatabaseWritingSystem, "Malayalam", QFontDatabase::WritingSystem::Malayalam);
+        define_qenum_value_under(rb_cQFontDatabaseWritingSystem, "Sinhala", QFontDatabase::WritingSystem::Sinhala);
+        define_qenum_value_under(rb_cQFontDatabaseWritingSystem, "Thai", QFontDatabase::WritingSystem::Thai);
+        define_qenum_value_under(rb_cQFontDatabaseWritingSystem, "Lao", QFontDatabase::WritingSystem::Lao);
+        define_qenum_value_under(rb_cQFontDatabaseWritingSystem, "Tibetan", QFontDatabase::WritingSystem::Tibetan);
+        define_qenum_value_under(rb_cQFontDatabaseWritingSystem, "Myanmar", QFontDatabase::WritingSystem::Myanmar);
+        define_qenum_value_under(rb_cQFontDatabaseWritingSystem, "Georgian", QFontDatabase::WritingSystem::Georgian);
+        define_qenum_value_under(rb_cQFontDatabaseWritingSystem, "Khmer", QFontDatabase::WritingSystem::Khmer);
+        define_qenum_value_under(rb_cQFontDatabaseWritingSystem, "SimplifiedChinese", QFontDatabase::WritingSystem::SimplifiedChinese);
+        define_qenum_value_under(rb_cQFontDatabaseWritingSystem, "TraditionalChinese", QFontDatabase::WritingSystem::TraditionalChinese);
+        define_qenum_value_under(rb_cQFontDatabaseWritingSystem, "Japanese", QFontDatabase::WritingSystem::Japanese);
+        define_qenum_value_under(rb_cQFontDatabaseWritingSystem, "Korean", QFontDatabase::WritingSystem::Korean);
+        define_qenum_value_under(rb_cQFontDatabaseWritingSystem, "Vietnamese", QFontDatabase::WritingSystem::Vietnamese);
+        define_qenum_value_under(rb_cQFontDatabaseWritingSystem, "Symbol", QFontDatabase::WritingSystem::Symbol);
+        define_qenum_value_under(rb_cQFontDatabaseWritingSystem, "Other", QFontDatabase::WritingSystem::Other);
+        define_qenum_value_under(rb_cQFontDatabaseWritingSystem, "Ogham", QFontDatabase::WritingSystem::Ogham);
+        define_qenum_value_under(rb_cQFontDatabaseWritingSystem, "Runic", QFontDatabase::WritingSystem::Runic);
+        define_qenum_value_under(rb_cQFontDatabaseWritingSystem, "Nko", QFontDatabase::WritingSystem::Nko);
+        define_qenum_value_under(rb_cQFontDatabaseWritingSystem, "WritingSystemsCount", QFontDatabase::WritingSystem::WritingSystemsCount);
+
+    Data_Type<QFontDatabase::SystemFont> rb_cQFontDatabaseSystemFont =
+        // RubyQt6::QtGui::QFontDatabase::SystemFont
+        define_qenum_under<QFontDatabase::SystemFont>(rb_cQFontDatabase, "SystemFont");
+        define_qenum_value_under(rb_cQFontDatabaseSystemFont, "GeneralFont", QFontDatabase::SystemFont::GeneralFont);
+        define_qenum_value_under(rb_cQFontDatabaseSystemFont, "FixedFont", QFontDatabase::SystemFont::FixedFont);
+        define_qenum_value_under(rb_cQFontDatabaseSystemFont, "TitleFont", QFontDatabase::SystemFont::TitleFont);
+        define_qenum_value_under(rb_cQFontDatabaseSystemFont, "SmallestReadableFont", QFontDatabase::SystemFont::SmallestReadableFont);
+}

data/ext/qt6/qtgui/qfontdatabase-rb.hpp

@@ -0,0 +1,4 @@
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+void Init_qfontdatabase(Rice::Module rb_mQt6QtGui);

data/ext/qt6/qtgui/qfontinfo-rb.cpp

@@ -0,0 +1,34 @@
+#include "qfontinfo-rb.hpp"
+#include <qfontinfo.h>
+
+#include <QList>
+
+using namespace Rice;
+
+Rice::Class rb_cQFontInfo;
+
+void Init_qfontinfo(Rice::Module rb_mQt6QtGui)
+{
+    rb_cQFontInfo =
+        // RubyQt6::QtGui::QFontInfo
+        define_class_under<QFontInfo>(rb_mQt6QtGui, "QFontInfo")
+            // Constructor
+            .define_constructor(Constructor<QFontInfo, const QFont &>(), Arg("font"))
+            // Public Functions
+            .define_method("bold", &QFontInfo::bold)
+            .define_method("exact_match", &QFontInfo::exactMatch)
+            .define_method("family", &QFontInfo::family)
+            .define_method("fixed_pitch", &QFontInfo::fixedPitch)
+            .define_method("italic", &QFontInfo::italic)
+            .define_method("overline", &QFontInfo::overline)
+            .define_method("pixel_size", &QFontInfo::pixelSize)
+            .define_method("point_size", &QFontInfo::pointSize)
+            .define_method("point_size_f", &QFontInfo::pointSizeF)
+            .define_method("strike_out", &QFontInfo::strikeOut)
+            .define_method("style", &QFontInfo::style)
+            .define_method("style_hint", &QFontInfo::styleHint)
+            .define_method("style_name", &QFontInfo::styleName)
+            .define_method("underline", &QFontInfo::underline)
+            .define_method("variable_axes", &QFontInfo::variableAxes)
+            .define_method("weight", &QFontInfo::weight);
+}

data/ext/qt6/qtgui/qfontinfo-rb.hpp

@@ -0,0 +1,4 @@
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+void Init_qfontinfo(Rice::Module rb_mQt6QtGui);

data/ext/qt6/qtgui/qfontmetrics-rb.cpp

@@ -0,0 +1,90 @@
+#include "qfontmetrics-rb.hpp"
+#include <qfontmetrics.h>
+
+#include <QTextOption>
+
+using namespace Rice;
+
+Rice::Class rb_cQFontMetrics;
+Rice::Class rb_cQFontMetricsF;
+
+void Init_qfontmetrics(Rice::Module rb_mQt6QtGui)
+{
+    rb_cQFontMetrics =
+        // RubyQt6::QtGui::QFontMetrics
+        define_class_under<QFontMetrics>(rb_mQt6QtGui, "QFontMetrics")
+            // Constructor
+            .define_constructor(Constructor<QFontMetrics, const QFont &>(), Arg("font"))
+            // Public Functions
+            .define_method("ascent", &QFontMetrics::ascent)
+            .define_method("average_char_width", &QFontMetrics::averageCharWidth)
+            .define_method<QRect (QFontMetrics::*)(QChar) const>("bounding_rect", &QFontMetrics::boundingRect, Arg("char"))
+            .define_method<QRect (QFontMetrics::*)(const QRect &, int, const QString &, int, int *) const>("bounding_rect", &QFontMetrics::boundingRect, Arg("r"), Arg("flags"), Arg("text"), Arg("tabstops") = static_cast<int>(0), Arg("tabarray") = static_cast<int *>(nullptr))
+            .define_method<QRect (QFontMetrics::*)(const QString &) const>("bounding_rect", &QFontMetrics::boundingRect, Arg("text"))
+            .define_method<QRect (QFontMetrics::*)(const QString &, const QTextOption &) const>("bounding_rect", &QFontMetrics::boundingRect, Arg("text"), Arg("text_option"))
+            .define_method<QRect (QFontMetrics::*)(int, int, int, int, int, const QString &, int, int *) const>("bounding_rect", &QFontMetrics::boundingRect, Arg("x"), Arg("y"), Arg("w"), Arg("h"), Arg("flags"), Arg("text"), Arg("tabstops") = static_cast<int>(0), Arg("tabarray") = static_cast<int *>(nullptr))
+            .define_method("cap_height", &QFontMetrics::capHeight)
+            .define_method("descent", &QFontMetrics::descent)
+            .define_method("elided_text", &QFontMetrics::elidedText, Arg("text"), Arg("mode"), Arg("width"), Arg("flags") = static_cast<int>(0))
+            .define_method("font_dpi", &QFontMetrics::fontDpi)
+            .define_method("height", &QFontMetrics::height)
+            .define_method<int (QFontMetrics::*)(QChar) const>("horizontal_advance", &QFontMetrics::horizontalAdvance, Arg("char"))
+            .define_method<int (QFontMetrics::*)(const QString &, const QTextOption &) const>("horizontal_advance", &QFontMetrics::horizontalAdvance, Arg("text"), Arg("text_option"))
+            .define_method<int (QFontMetrics::*)(const QString &, int) const>("horizontal_advance", &QFontMetrics::horizontalAdvance, Arg("text"), Arg("len") = static_cast<int>(-1))
+            .define_method("in_font", &QFontMetrics::inFont, Arg("char"))
+            .define_method("in_font_ucs4", &QFontMetrics::inFontUcs4, Arg("ucs4"))
+            .define_method("leading", &QFontMetrics::leading)
+            .define_method("left_bearing", &QFontMetrics::leftBearing, Arg("char"))
+            .define_method("line_spacing", &QFontMetrics::lineSpacing)
+            .define_method("line_width", &QFontMetrics::lineWidth)
+            .define_method("max_width", &QFontMetrics::maxWidth)
+            .define_method("min_left_bearing", &QFontMetrics::minLeftBearing)
+            .define_method("min_right_bearing", &QFontMetrics::minRightBearing)
+            .define_method("overline_pos", &QFontMetrics::overlinePos)
+            .define_method("right_bearing", &QFontMetrics::rightBearing, Arg("char"))
+            .define_method("size", &QFontMetrics::size, Arg("flags"), Arg("str"), Arg("tabstops") = static_cast<int>(0), Arg("tabarray") = static_cast<int *>(nullptr))
+            .define_method("strike_out_pos", &QFontMetrics::strikeOutPos)
+            .define_method<QRect (QFontMetrics::*)(const QString &) const>("tight_bounding_rect", &QFontMetrics::tightBoundingRect, Arg("text"))
+            .define_method<QRect (QFontMetrics::*)(const QString &, const QTextOption &) const>("tight_bounding_rect", &QFontMetrics::tightBoundingRect, Arg("text"), Arg("text_option"))
+            .define_method("underline_pos", &QFontMetrics::underlinePos)
+            .define_method("x_height", &QFontMetrics::xHeight);
+
+    rb_cQFontMetricsF =
+        // RubyQt6::QtGui::QFontMetricsF
+        define_class_under<QFontMetricsF>(rb_mQt6QtGui, "QFontMetricsF")
+            // Constructor
+            .define_constructor(Constructor<QFontMetricsF, const QFont &>(), Arg("font"))
+            .define_constructor(Constructor<QFontMetricsF, const QFontMetrics &>(), Arg("font_metrics"))
+            // Public Functions
+            .define_method("ascent", &QFontMetricsF::ascent)
+            .define_method("average_char_width", &QFontMetricsF::averageCharWidth)
+            .define_method<QRectF (QFontMetricsF::*)(QChar) const>("bounding_rect", &QFontMetricsF::boundingRect, Arg("char"))
+            .define_method<QRectF (QFontMetricsF::*)(const QRectF &, int, const QString &, int, int *) const>("bounding_rect", &QFontMetricsF::boundingRect, Arg("r"), Arg("flags"), Arg("string"), Arg("tabstops") = static_cast<int>(0), Arg("tabarray") = static_cast<int *>(nullptr))
+            .define_method<QRectF (QFontMetricsF::*)(const QString &) const>("bounding_rect", &QFontMetricsF::boundingRect, Arg("string"))
+            .define_method<QRectF (QFontMetricsF::*)(const QString &, const QTextOption &) const>("bounding_rect", &QFontMetricsF::boundingRect, Arg("text"), Arg("text_option"))
+            .define_method("cap_height", &QFontMetricsF::capHeight)
+            .define_method("descent", &QFontMetricsF::descent)
+            .define_method("elided_text", &QFontMetricsF::elidedText, Arg("text"), Arg("mode"), Arg("width"), Arg("flags") = static_cast<int>(0))
+            .define_method("font_dpi", &QFontMetricsF::fontDpi)
+            .define_method("height", &QFontMetricsF::height)
+            .define_method<qreal (QFontMetricsF::*)(QChar) const>("horizontal_advance", &QFontMetricsF::horizontalAdvance, Arg("char"))
+            .define_method<qreal (QFontMetricsF::*)(const QString &, const QTextOption &) const>("horizontal_advance", &QFontMetricsF::horizontalAdvance, Arg("string"), Arg("text_option"))
+            .define_method<qreal (QFontMetricsF::*)(const QString &, int) const>("horizontal_advance", &QFontMetricsF::horizontalAdvance, Arg("string"), Arg("length") = static_cast<int>(-1))
+            .define_method("in_font", &QFontMetricsF::inFont, Arg("font"))
+            .define_method("in_font_ucs4", &QFontMetricsF::inFontUcs4, Arg("ucs4"))
+            .define_method("leading", &QFontMetricsF::leading)
+            .define_method("left_bearing", &QFontMetricsF::leftBearing, Arg("char"))
+            .define_method("line_spacing", &QFontMetricsF::lineSpacing)
+            .define_method("line_width", &QFontMetricsF::lineWidth)
+            .define_method("max_width", &QFontMetricsF::maxWidth)
+            .define_method("min_left_bearing", &QFontMetricsF::minLeftBearing)
+            .define_method("min_right_bearing", &QFontMetricsF::minRightBearing)
+            .define_method("overline_pos", &QFontMetricsF::overlinePos)
+            .define_method("right_bearing", &QFontMetricsF::rightBearing, Arg("char"))
+            .define_method("size", &QFontMetricsF::size, Arg("flags"), Arg("str"), Arg("tabstops") = static_cast<int>(0), Arg("tabarray") = static_cast<int *>(nullptr))
+            .define_method("strike_out_pos", &QFontMetricsF::strikeOutPos)
+            .define_method<QRectF (QFontMetricsF::*)(const QString &) const>("tight_bounding_rect", &QFontMetricsF::tightBoundingRect, Arg("text"))
+            .define_method<QRectF (QFontMetricsF::*)(const QString &, const QTextOption &) const>("tight_bounding_rect", &QFontMetricsF::tightBoundingRect, Arg("text"), Arg("text_option"))
+            .define_method("underline_pos", &QFontMetricsF::underlinePos)
+            .define_method("x_height", &QFontMetricsF::xHeight);
+}

data/ext/qt6/qtgui/qfontmetrics-rb.hpp

@@ -0,0 +1,4 @@
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+void Init_qfontmetrics(Rice::Module rb_mQt6QtGui);