ruby-qt6-qtgui 1.0.0

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

@@ -0,0 +1,179 @@
+#include "qwindow-rb.hpp"
+#include <qwindow.h>
+#include <rice/qt6/qenum.hpp>
+
+#include <QAccessible>
+#include <QScreen>
+#include <QVulkanInstance>
+
+using namespace Rice;
+
+Rice::Class rb_cQWindow;
+
+void Init_qwindow(Rice::Module rb_mQt6QtGui)
+{
+    rb_cQWindow =
+        // RubyQt6::QtGui::QWindow
+        define_class_under<QWindow, QObject>(rb_mQt6QtGui, "QWindow")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QWindow::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QWindow, QWindow *>(), Arg("parent"))
+            // Inherits QSurface
+            .define_method("supports_open_gl", &QWindow::supportsOpenGL)
+            .define_method("surface_class", &QWindow::surfaceClass)
+            // .define_method("surface_handle", &QWindow::surfaceHandle)
+            // Public Functions
+            .define_method("accessible_root", &QWindow::accessibleRoot)
+            .define_method("base_size", &QWindow::baseSize)
+            .define_method("content_orientation", &QWindow::contentOrientation)
+            .define_method("create", &QWindow::create)
+            .define_method("cursor", &QWindow::cursor)
+            .define_method("destroy", &QWindow::destroy)
+            .define_method("device_pixel_ratio", &QWindow::devicePixelRatio)
+            .define_method("file_path", &QWindow::filePath)
+            .define_method("flags", &QWindow::flags)
+            .define_method("focus_object", &QWindow::focusObject)
+            .define_method("format", &QWindow::format)
+            .define_method("frame_geometry", &QWindow::frameGeometry)
+            .define_method("frame_margins", &QWindow::frameMargins)
+            .define_method("frame_position", &QWindow::framePosition)
+            .define_method("geometry", &QWindow::geometry)
+            // .define_method("handle", &QWindow::handle)
+            .define_method("height", &QWindow::height)
+            .define_method("icon", &QWindow::icon)
+            .define_method("active?", &QWindow::isActive)
+            .define_method("ancestor_of?", &QWindow::isAncestorOf, Arg("child"), Arg("mode") = static_cast<QWindow::AncestorMode>(QWindow::AncestorMode::IncludeTransients))
+            .define_method("exposed?", &QWindow::isExposed)
+            .define_method("modal?", &QWindow::isModal)
+            .define_method("top_level?", &QWindow::isTopLevel)
+            .define_method("visible?", &QWindow::isVisible)
+            .define_method<QPoint (QWindow::*)(const QPoint &) const>("map_from_global", &QWindow::mapFromGlobal, Arg("pos"))
+            .define_method<QPointF (QWindow::*)(const QPointF &) const>("map_from_global", &QWindow::mapFromGlobal, Arg("pos"))
+            .define_method<QPoint (QWindow::*)(const QPoint &) const>("map_to_global", &QWindow::mapToGlobal, Arg("pos"))
+            .define_method<QPointF (QWindow::*)(const QPointF &) const>("map_to_global", &QWindow::mapToGlobal, Arg("pos"))
+            .define_method("mask", &QWindow::mask)
+            .define_method("maximum_height", &QWindow::maximumHeight)
+            .define_method("maximum_size", &QWindow::maximumSize)
+            .define_method("maximum_width", &QWindow::maximumWidth)
+            .define_method("minimum_height", &QWindow::minimumHeight)
+            .define_method("minimum_size", &QWindow::minimumSize)
+            .define_method("minimum_width", &QWindow::minimumWidth)
+            .define_method("modality", &QWindow::modality)
+            .define_method("opacity", &QWindow::opacity)
+            .define_method("parent", &QWindow::parent, Arg("mode") = static_cast<QWindow::AncestorMode>(QWindow::AncestorMode::ExcludeTransients))
+            .define_method("position", &QWindow::position)
+            .define_method("report_content_orientation_change", &QWindow::reportContentOrientationChange, Arg("orientation"))
+            .define_method("requested_format", &QWindow::requestedFormat)
+            .define_method<void (QWindow::*)(const QSize &)>("resize", &QWindow::resize, Arg("new_size"))
+            .define_method<void (QWindow::*)(int, int)>("resize", &QWindow::resize, Arg("w"), Arg("h"))
+            .define_method("safe_area_margins", &QWindow::safeAreaMargins)
+            .define_method("screen", &QWindow::screen)
+            .define_method("set_base_size", &QWindow::setBaseSize, Arg("size"))
+            .define_method("set_cursor", &QWindow::setCursor, Arg("cursor"))
+            .define_method("set_file_path", &QWindow::setFilePath, Arg("file_path"))
+            .define_method("set_flag", &QWindow::setFlag, Arg("flag"), Arg("on") = static_cast<bool>(true))
+            .define_method("set_flags", &QWindow::setFlags, Arg("flags"))
+            .define_method("set_format", &QWindow::setFormat, Arg("format"))
+            .define_method("set_frame_position", &QWindow::setFramePosition, Arg("point"))
+            .define_method("set_icon", &QWindow::setIcon, Arg("icon"))
+            .define_method("set_keyboard_grab_enabled", &QWindow::setKeyboardGrabEnabled, Arg("grab"))
+            .define_method("set_mask", &QWindow::setMask, Arg("region"))
+            .define_method("set_maximum_size", &QWindow::setMaximumSize, Arg("size"))
+            .define_method("set_minimum_size", &QWindow::setMinimumSize, Arg("size"))
+            .define_method("set_modality", &QWindow::setModality, Arg("modality"))
+            .define_method("set_mouse_grab_enabled", &QWindow::setMouseGrabEnabled, Arg("grab"))
+            .define_method("set_opacity", &QWindow::setOpacity, Arg("level"))
+            .define_method("set_parent", &QWindow::setParent, Arg("parent"))
+            .define_method<void (QWindow::*)(const QPoint &)>("set_position", &QWindow::setPosition, Arg("pt"))
+            .define_method<void (QWindow::*)(int, int)>("set_position", &QWindow::setPosition, Arg("posx"), Arg("posy"))
+            .define_method("set_screen", &QWindow::setScreen, Arg("screen"))
+            .define_method("set_size_increment", &QWindow::setSizeIncrement, Arg("size"))
+            .define_method("set_surface_type", &QWindow::setSurfaceType, Arg("surface_type"))
+            .define_method("set_transient_parent", &QWindow::setTransientParent, Arg("parent"))
+            .define_method("set_visibility", &QWindow::setVisibility, Arg("v"))
+            .define_method("set_vulkan_instance", &QWindow::setVulkanInstance, Arg("instance"))
+            .define_method("set_window_state", &QWindow::setWindowState, Arg("state"))
+            .define_method("set_window_states", &QWindow::setWindowStates, Arg("states"))
+            .define_method("size", &QWindow::size)
+            .define_method("size_increment", &QWindow::sizeIncrement)
+            .define_method("surface_type", &QWindow::surfaceType)
+            .define_method("title", &QWindow::title)
+            .define_method("transient_parent", &QWindow::transientParent)
+            .define_method("type", &QWindow::type)
+            .define_method("unset_cursor", &QWindow::unsetCursor)
+            .define_method("visibility", &QWindow::visibility)
+            .define_method("vulkan_instance", &QWindow::vulkanInstance)
+            .define_method("width", &QWindow::width)
+            .define_method("win_id", &QWindow::winId)
+            .define_method("window_state", &QWindow::windowState)
+            .define_method("window_states", &QWindow::windowStates)
+            .define_method("x", &QWindow::x)
+            .define_method("y", &QWindow::y)
+            // Public Slots
+            .define_method("alert", &QWindow::alert, Arg("msec"))
+            .define_method("close", &QWindow::close)
+            .define_method("hide", &QWindow::hide)
+            .define_method("lower", &QWindow::lower)
+            .define_method("_raise", &QWindow::raise)
+            .define_method("request_activate", &QWindow::requestActivate)
+            .define_method("request_update", &QWindow::requestUpdate)
+            .define_method<void (QWindow::*)(const QRect &)>("set_geometry", &QWindow::setGeometry, Arg("rect"))
+            .define_method<void (QWindow::*)(int, int, int, int)>("set_geometry", &QWindow::setGeometry, Arg("posx"), Arg("posy"), Arg("w"), Arg("h"))
+            .define_method("set_height", &QWindow::setHeight, Arg("arg"))
+            .define_method("set_maximum_height", &QWindow::setMaximumHeight, Arg("h"))
+            .define_method("set_maximum_width", &QWindow::setMaximumWidth, Arg("w"))
+            .define_method("set_minimum_height", &QWindow::setMinimumHeight, Arg("h"))
+            .define_method("set_minimum_width", &QWindow::setMinimumWidth, Arg("w"))
+            .define_method("set_title", &QWindow::setTitle, Arg("title"))
+            .define_method("set_visible", &QWindow::setVisible, Arg("visible"))
+            .define_method("set_width", &QWindow::setWidth, Arg("arg"))
+            .define_method("set_x", &QWindow::setX, Arg("arg"))
+            .define_method("set_y", &QWindow::setY, Arg("arg"))
+            .define_method("show", &QWindow::show)
+            .define_method("show_full_screen", &QWindow::showFullScreen)
+            .define_method("show_maximized", &QWindow::showMaximized)
+            .define_method("show_minimized", &QWindow::showMinimized)
+            .define_method("show_normal", &QWindow::showNormal)
+            .define_method("start_system_move", &QWindow::startSystemMove)
+            .define_method("start_system_resize", &QWindow::startSystemResize, Arg("edges"))
+            // Signals
+            .define_method("active_changed", &QWindow::activeChanged)
+            .define_method("content_orientation_changed", &QWindow::contentOrientationChanged, Arg("orientation"))
+            .define_method("focus_object_changed", &QWindow::focusObjectChanged, Arg("object"))
+            .define_method("height_changed", &QWindow::heightChanged, Arg("arg"))
+            .define_method("maximum_height_changed", &QWindow::maximumHeightChanged, Arg("arg"))
+            .define_method("maximum_width_changed", &QWindow::maximumWidthChanged, Arg("arg"))
+            .define_method("minimum_height_changed", &QWindow::minimumHeightChanged, Arg("arg"))
+            .define_method("minimum_width_changed", &QWindow::minimumWidthChanged, Arg("arg"))
+            .define_method("modality_changed", &QWindow::modalityChanged, Arg("modality"))
+            .define_method("opacity_changed", &QWindow::opacityChanged, Arg("opacity"))
+            .define_method("safe_area_margins_changed", &QWindow::safeAreaMarginsChanged, Arg("arg"))
+            .define_method("screen_changed", &QWindow::screenChanged, Arg("screen"))
+            .define_method("transient_parent_changed", &QWindow::transientParentChanged, Arg("transient_parent"))
+            .define_method("visibility_changed", &QWindow::visibilityChanged, Arg("visibility"))
+            .define_method("visible_changed", &QWindow::visibleChanged, Arg("arg"))
+            .define_method("width_changed", &QWindow::widthChanged, Arg("arg"))
+            .define_method("window_state_changed", &QWindow::windowStateChanged, Arg("window_state"))
+            .define_method("window_title_changed", &QWindow::windowTitleChanged, Arg("title"))
+            .define_method("x_changed", &QWindow::xChanged, Arg("arg"))
+            .define_method("y_changed", &QWindow::yChanged, Arg("arg"))
+            // Static Public Members
+            .define_singleton_function("from_win_id", &QWindow::fromWinId, Arg("id"));
+
+    Data_Type<QWindow::AncestorMode> rb_cQWindowAncestorMode =
+        // RubyQt6::QtGui::QWindow::AncestorMode
+        define_qenum_under<QWindow::AncestorMode>(rb_cQWindow, "AncestorMode");
+        define_qenum_value_under(rb_cQWindowAncestorMode, "ExcludeTransients", QWindow::AncestorMode::ExcludeTransients);
+        define_qenum_value_under(rb_cQWindowAncestorMode, "IncludeTransients", QWindow::AncestorMode::IncludeTransients);
+
+    Data_Type<QWindow::Visibility> rb_cQWindowVisibility =
+        // RubyQt6::QtGui::QWindow::Visibility
+        define_qenum_under<QWindow::Visibility>(rb_cQWindow, "Visibility");
+        define_qenum_value_under(rb_cQWindowVisibility, "Hidden", QWindow::Visibility::Hidden);
+        define_qenum_value_under(rb_cQWindowVisibility, "AutomaticVisibility", QWindow::Visibility::AutomaticVisibility);
+        define_qenum_value_under(rb_cQWindowVisibility, "Windowed", QWindow::Visibility::Windowed);
+        define_qenum_value_under(rb_cQWindowVisibility, "Minimized", QWindow::Visibility::Minimized);
+        define_qenum_value_under(rb_cQWindowVisibility, "Maximized", QWindow::Visibility::Maximized);
+        define_qenum_value_under(rb_cQWindowVisibility, "FullScreen", QWindow::Visibility::FullScreen);
+}

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

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

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

@@ -0,0 +1,20 @@
+#include "t-qtgui-rb.hpp"
+#include <rice/qt6/qlist.hpp>
+
+#include <QPoint>
+#include <QPointF>
+#include <QScreen>
+
+using namespace Rice;
+
+void Init_t_qtgui(Rice::Module rb_mQt6T)
+{
+    // QList<QPoint> -> QPolygon
+    define_qlist_under<QPoint>(rb_mQt6T);
+
+    // QList<QPointF> -> QPolygonF
+    define_qlist_under<QPointF>(rb_mQt6T);
+
+    // QList<QScreen *>
+    define_qlist_under<QScreen *>(rb_mQt6T);
+}

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

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

data/lib/qt6/qtgui/qaction.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtGui
+    # @see https://doc.qt.io/qt-6/qaction.html
+    class QAction < RubyQt6::QtCore::QObject
+      INITIALIZE_ARG_ERROR_MESSAGE =
+        "Could not resolve method call for #{name}#initialize\n" \
+        "  3 overload(s) were evaluated based on the types of Ruby parameters provided:\n" \
+        "    initialize(QObject)\n" \
+        "    initialize(QString, QObject)\n" \
+        "    initialize(QIcon, QString, QObject)\n"
+
+      # @!parse class MenuRole   ; end
+      # @!parse class Priority   ; end
+      # @!parse class ActionEvent; end
+      rubyqt6_declare_enum_under QAction, QAction::MenuRole
+      rubyqt6_declare_enum_under QAction, QAction::Priority
+      rubyqt6_declare_enum_under QAction, QAction::ActionEvent
+
+      # @!parse
+      q_object do
+        signal "changed()"
+        signal "checkableChanged(bool)"
+        signal "enabledChanged(bool)"
+        signal "hovered()"
+        signal "toggled(bool)"
+        signal "triggered(bool)"
+        signal "triggered()"
+        signal "visibleChanged()"
+        slot "hover()"
+        slot "resetEnabled()"
+        slot "setChecked(bool)"
+        slot "setDisabled(bool)"
+        slot "setEnabled(bool)"
+        slot "setVisible(bool)"
+        slot "toggle()"
+        slot "trigger()"
+      end
+
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @return [QAction]
+      #
+      # @overload initialize(parent = nil)
+      #   @param parent [QObject]
+      #
+      # @overload initialize(text, parent = nil)
+      #   @param text [String, QString]
+      #   @param parent [QObject]
+      #
+      # @overload initialize(icon, text, parent = nil)
+      #   @param icon [QIcon]
+      #   @param text [String, QString]
+      #   @param parent [QObject]
+      def initialize(*args)
+        parent = T.args_nth_delete_qobject(args, -1)
+        case args.size
+        when 0 then _initialize(QtGui::QIcon.new, T.to_qstr(""), parent)
+        when 1 then _initialize(QtGui::QIcon.new, T.to_qstr(args[-1]), parent)
+        when 2 then _initialize(args[-2], T.to_qstr(args[-1]), parent)
+        else raise ArgumentError, INITIALIZE_ARG_ERROR_MESSAGE
+        end
+        _take_ownership_from_ruby(self)
+      end
+    end
+  end
+end

data/lib/qt6/qtgui/qactiongroup.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtGui
+    # @see https://doc.qt.io/qt-6/qactiongroup.html
+    class QActionGroup < RubyQt6::QtCore::QObject
+      # @!parse class ExclusionPolicy; end
+      rubyqt6_declare_enum_under QActionGroup, QActionGroup::ExclusionPolicy
+
+      # @!parse
+      q_object do
+        signal "hovered(QAction*)"
+        signal "triggered(QAction*)"
+        slot "setDisabled(bool)"
+        slot "setEnabled(bool)"
+        slot "setExclusionPolicy(ExclusionPolicy)"
+        slot "setExclusive(bool)"
+        slot "setVisible(bool)"
+      end
+
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @param parent [QObject]
+      # @return [QActionGroup]
+      def initialize(parent)
+        _initialize(parent)
+        _take_ownership_from_ruby(self)
+      end
+    end
+  end
+end

data/lib/qt6/qtgui/qbrush.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtGui
+    # @see https://doc.qt.io/qt-6/qbrush.html
+    class QBrush
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @return [QBrush]
+      #
+      # @overload initialize
+      #
+      # @overload initialize(bs)
+      #   @param bs [Qt::BrushStyle]
+      #
+      # @overload initialize(color)
+      #   @param color [Qt::GlobalColor]
+      #
+      # @overload initialize(color, bs)
+      #   @param color [Qt::GlobalColor]
+      #   @param bs [Qt::BrushStyle]
+      #
+      # @overload initialize(color, pixmap)
+      #   @param color [Qt::GlobalColor]
+      #   @param pixmap [QPixmap]
+      #
+      # @overload initialize(color)
+      #   @param color [QColor]
+      #
+      # @overload initialize(color, bs)
+      #   @param color [QColor]
+      #   @param bs [Qt::BrushStyle]
+      #
+      # @overload initialize(color, pixmap)
+      #   @param color [QColor]
+      #   @param pixmap [QPixmap]
+      #
+      # @overload initialize(image)
+      #   @param image [QImage]
+      #
+      # @overload initialize(pixmap)
+      #   @param image [QPixmap]
+      def initialize(*args)
+        _initialize(*args)
+      end
+    end
+  end
+end

data/lib/qt6/qtgui/qclipboard.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtGui
+    # @see https://doc.qt.io/qt-6/qclipboard.html
+    class QClipboard < RubyQt6::QtCore::QObject
+      # @!parse class Mode; end
+      rubyqt6_declare_enum_under QClipboard, QClipboard::Mode
+
+      # @!parse
+      q_object do
+        signal "changed(QClipboard::Mode)"
+        signal "dataChanged()"
+        signal "findBufferChanged()"
+        signal "selectionChanged()"
+      end
+    end
+  end
+end

data/lib/qt6/qtgui/qcolor.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtGui
+    # @see https://doc.qt.io/qt-6/qcolor.html
+    class QColor
+      # @!parse class NameFormat; end
+      # @!parse class Spec      ; end
+      rubyqt6_declare_enum_under QColor, QColor::NameFormat
+      rubyqt6_declare_enum_under QColor, QColor::Spec
+
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @return [QColor]
+      #
+      # @overload initialize
+      #
+      # @overload initialize(r, g, b)
+      #   @param r [Integer]
+      #   @param g [Integer]
+      #   @param b [Integer]
+      #
+      # @overload initialize(r, g, b, a)
+      #   @param r [Integer]
+      #   @param g [Integer]
+      #   @param b [Integer]
+      #   @param a [Integer]
+      #
+      # @overload initialize(color)
+      #   @param color [Qt::GlobalColor]
+      #
+      # @overload initialize(color)
+      #   @param color [String]
+      #
+      # @overload initialize(color)
+      #   @param color [QString]
+      def initialize(*args)
+        _initialize(*args)
+      end
+
+      # @!visibility private
+      def inspect
+        rgb = name(QtGui::QColor::NameFormat::HexRgb).to_s
+        T.inspect_struct(self, rgb:)
+      end
+    end
+  end
+end

data/lib/qt6/qtgui/qcursor.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtGui
+    # @see https://doc.qt.io/qt-6/qcursor.html
+    class QCursor
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @return [QCursor]
+      #
+      # @overload initialize
+      #
+      # @overload initialize(shape)
+      #   @param shape [Qt::CursorShape]
+      def initialize(*args)
+        _initialize(*args)
+      end
+    end
+  end
+end

data/lib/qt6/qtgui/qdoublevalidator.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtGui
+    # @see https://doc.qt.io/qt-6/qdoublevalidator.html
+    class QDoubleValidator < RubyQt6::QtGui::QValidator
+      INITIALIZE_ARG_ERROR_MESSAGE =
+        "Could not resolve method call for #{name}#initialize\n" \
+        "  2 overload(s) were evaluated based on the types of Ruby parameters provided:\n" \
+        "    initialize(QObject)\n" \
+        "    initialize(Float, Float, Integer, QObject)\n"
+
+      # @!parse class Notation; end
+      rubyqt6_declare_enum_under QDoubleValidator, QDoubleValidator::Notation
+
+      # @!parse
+      q_object do
+        signal "bottomChanged(double)"
+        signal "decimalsChanged(int)"
+        signal "notationChanged(QDoubleValidator::Notation)"
+        signal "topChanged(double)"
+      end
+
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @return [QDoubleValidator]
+      #
+      # @overload initialize(parent = nil)
+      #   @param parent [QObject]
+      #
+      # @overload initialize(bottom, top, decimals, parent = nil)
+      #   @param bottom [Float]
+      #   @param top [Float]
+      #   @param decimals [Integer]
+      #   @param parent [QObject]
+      def initialize(*args)
+        parent = T.args_nth_delete_qobject(args, -1)
+        case args.size
+        when 0 then _initialize(parent)
+        when 3 then _initialize_p(args[-3], args[-2], args[-1], parent)
+        else raise ArgumentError, INITIALIZE_ARG_ERROR_MESSAGE
+        end
+        _take_ownership_from_ruby(self)
+      end
+
+      private
+
+      def _initialize_p(bottom, top, decimals, parent)
+        _initialize(parent)
+        set_bottom(bottom)
+        set_top(top)
+        set_decimals(decimals)
+      end
+    end
+  end
+end

data/lib/qt6/qtgui/qfilesystemmodel.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtGui
+    # @see https://doc.qt.io/qt-6/qfilesystemmodel.html
+    class QFileSystemModel < RubyQt6::QtCore::QAbstractItemModel
+      # @!parse class Roles  ; end
+      # @!parse class Option ; end
+      # @!parse class Options; end
+      rubyqt6_declare_enum_under QFileSystemModel, QFileSystemModel::Roles
+      rubyqt6_declare_enum_under QFileSystemModel, QFileSystemModel::Option
+      rubyqt6_declare_qflags QFileSystemModel::Options, QFileSystemModel::Option
+
+      # @!parse
+      q_object do
+        signal "directoryLoaded(QString)"
+        signal "fileRenamed(QString,QString,QString)"
+        signal "rootPathChanged(QString)"
+      end
+
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @param parent [QObject]
+      # @return [QFileSystemModel]
+      def initialize(parent = nil)
+        _initialize(parent)
+        _take_ownership_from_ruby(self)
+      end
+    end
+  end
+end

data/lib/qt6/qtgui/qfont.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtGui
+    # @see https://doc.qt.io/qt-6/qfont.html
+    class QFont
+      # @!parse class Capitalization   ; end
+      # @!parse class HintingPreference; end
+      # @!parse class SpacingType      ; end
+      # @!parse class Stretch          ; end
+      # @!parse class Style            ; end
+      # @!parse class StyleHint        ; end
+      # @!parse class StyleStrategy    ; end
+      # @!parse class Weight           ; end
+      rubyqt6_declare_enum_under QFont, QFont::Capitalization
+      rubyqt6_declare_enum_under QFont, QFont::HintingPreference
+      rubyqt6_declare_enum_under QFont, QFont::SpacingType
+      rubyqt6_declare_enum_under QFont, QFont::Stretch
+      rubyqt6_declare_enum_under QFont, QFont::Style
+      rubyqt6_declare_enum_under QFont, QFont::StyleHint
+      rubyqt6_declare_enum_under QFont, QFont::StyleStrategy
+      rubyqt6_declare_enum_under QFont, QFont::Weight
+
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @return [QFont]
+      #
+      # @overload initialize
+      #
+      # @overload initialize(family)
+      #   @param family [String, QString]
+      #
+      # @overload initialize(family, point_size)
+      #   @param family [String, QString]
+      #   @param point_size [Integer]
+      #
+      # @overload initialize(family, point_size, weight)
+      #   @param family [String, QString]
+      #   @param point_size [Integer]
+      #   @param weight [QFont::Weight]
+      #
+      # @overload initialize(families)
+      #   @param families [QStringList]
+      #
+      # @overload initialize(families, point_size)
+      #   @param families [QStringList]
+      #   @param point_size [Integer]
+      #
+      # @overload initialize(families, point_size, weight)
+      #   @param families [QStringList]
+      #   @param point_size [Integer]
+      #   @param weight [QFont::Weight]
+      def initialize(*args)
+        T.args_nth_to_qstr(args, 0)
+        _initialize(*args)
+      end
+
+      # @!visibility private
+      def to_s
+        to_string.to_s
+      end
+
+      # @!visibility private
+      def inspect
+        T.inspect_struct(self, str: to_s)
+      end
+    end
+  end
+end

data/lib/qt6/qtgui/qfontdatabase.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtGui
+    # @see https://doc.qt.io/qt-6/qfontdatabase.html
+    class QFontDatabase
+      # @!parse class WritingSystem; end
+      # @!parse class SystemFont   ; end
+      rubyqt6_declare_enum_under QFontDatabase, QFontDatabase::WritingSystem
+      rubyqt6_declare_enum_under QFontDatabase, QFontDatabase::SystemFont
+    end
+  end
+end

data/lib/qt6/qtgui/qfontinfo.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtGui
+    # @see https://doc.qt.io/qt-6/qfontinfo.html
+    class QFontInfo
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @param font [QFont]
+      # @return [QFontInfo]
+      def initialize(font)
+        _initialize(font)
+      end
+    end
+  end
+end

data/lib/qt6/qtgui/qfontmetrics.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtGui
+    # @see https://doc.qt.io/qt-6/qfontmetrics.html
+    class QFontMetrics
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @return [QFontMetrics]
+      #
+      # @overload initialize(font)
+      #   @param font [QFont]
+      def initialize(*args)
+        _initialize(*args)
+      end
+    end
+  end
+end