ruby-qt6-qtgui 1.0.0

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

@@ -0,0 +1,94 @@
+#include "qguiapplication-rb.hpp"
+#include <qguiapplication.h>
+
+#include <QClipboard>
+#include <QCursor>
+#include <QFont>
+#include <QIcon>
+#include <QPalette>
+#include <QScreen>
+#include <QSessionManager>
+#include <QStyleHints>
+#include <QWindow>
+
+using namespace Rice;
+
+Rice::Class rb_cQGuiApplication;
+
+void Init_qguiapplication(Rice::Module rb_mQt6QtGui)
+{
+    rb_cQGuiApplication =
+        // RubyQt6::QtGui::QGuiApplication
+        define_class_under<QGuiApplication, QCoreApplication>(rb_mQt6QtGui, "QGuiApplication")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QGuiApplication::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QGuiApplication, int &, char **>(), Arg("argc"), Arg("argv").setBuffer())
+            // Public Functions
+            .define_method("device_pixel_ratio", &QGuiApplication::devicePixelRatio)
+            .define_method("notify", &QGuiApplication::notify, Arg("receiver"), Arg("event"))
+            .define_method("saving_session?", &QGuiApplication::isSavingSession)
+            .define_method("session_restored?", &QGuiApplication::isSessionRestored)
+            .define_method("session_id", &QGuiApplication::sessionId)
+            .define_method("session_key", &QGuiApplication::sessionKey)
+            // Public Slots
+            .define_method("set_badge_number", &QGuiApplication::setBadgeNumber, Arg("number"))
+            // Signals
+            .define_method("application_display_name_changed", &QGuiApplication::applicationDisplayNameChanged)
+            .define_method("application_state_changed", &QGuiApplication::applicationStateChanged, Arg("state"))
+            .define_method("commit_data_request", &QGuiApplication::commitDataRequest, Arg("session_manager"))
+            .define_method("focus_object_changed", &QGuiApplication::focusObjectChanged, Arg("focus_object"))
+            .define_method("focus_window_changed", &QGuiApplication::focusWindowChanged, Arg("focus_window"))
+            .define_method("font_database_changed", &QGuiApplication::fontDatabaseChanged)
+            .define_method("last_window_closed", &QGuiApplication::lastWindowClosed)
+            .define_method("layout_direction_changed", &QGuiApplication::layoutDirectionChanged, Arg("direction"))
+            .define_method("primary_screen_changed", &QGuiApplication::primaryScreenChanged, Arg("screen"))
+            .define_method("save_state_request", &QGuiApplication::saveStateRequest, Arg("session_manager"))
+            .define_method("screen_added", &QGuiApplication::screenAdded, Arg("screen"))
+            .define_method("screen_removed", &QGuiApplication::screenRemoved, Arg("screen"))
+            // Static Public Members
+            .define_singleton_function("all_windows", &QGuiApplication::allWindows)
+            .define_singleton_function("application_display_name", &QGuiApplication::applicationDisplayName)
+            .define_singleton_function("application_state", &QGuiApplication::applicationState)
+            .define_singleton_function("change_override_cursor", &QGuiApplication::changeOverrideCursor, Arg("cursor"))
+            .define_singleton_function("clipboard", &QGuiApplication::clipboard)
+            .define_singleton_function("desktop_file_name", &QGuiApplication::desktopFileName)
+            .define_singleton_function("desktop_settings_aware", &QGuiApplication::desktopSettingsAware)
+            .define_singleton_function("exec", &QGuiApplication::exec)
+            .define_singleton_function("focus_object", &QGuiApplication::focusObject)
+            .define_singleton_function("focus_window", &QGuiApplication::focusWindow)
+            .define_singleton_function("font", &QGuiApplication::font)
+            .define_singleton_function("high_dpi_scale_factor_rounding_policy", &QGuiApplication::highDpiScaleFactorRoundingPolicy)
+            .define_singleton_function("input_method", &QGuiApplication::inputMethod)
+            .define_singleton_function("left_to_right?", &QGuiApplication::isLeftToRight)
+            .define_singleton_function("right_to_left?", &QGuiApplication::isRightToLeft)
+            .define_singleton_function("keyboard_modifiers", &QGuiApplication::keyboardModifiers)
+            .define_singleton_function("layout_direction", &QGuiApplication::layoutDirection)
+            .define_singleton_function("modal_window", &QGuiApplication::modalWindow)
+            .define_singleton_function("mouse_buttons", &QGuiApplication::mouseButtons)
+            .define_singleton_function("override_cursor", &QGuiApplication::overrideCursor)
+            .define_singleton_function("platform_function", &QGuiApplication::platformFunction, Arg("function"))
+            .define_singleton_function("platform_name", &QGuiApplication::platformName)
+            // .define_singleton_function("platform_native_interface", &QGuiApplication::platformNativeInterface)
+            .define_singleton_function("primary_screen", &QGuiApplication::primaryScreen)
+            .define_singleton_function("query_keyboard_modifiers", &QGuiApplication::queryKeyboardModifiers)
+            .define_singleton_function("quit_on_last_window_closed", &QGuiApplication::quitOnLastWindowClosed)
+            .define_singleton_function("restore_override_cursor", &QGuiApplication::restoreOverrideCursor)
+            .define_singleton_function("screen_at", &QGuiApplication::screenAt, Arg("point"))
+            .define_singleton_function("screens", &QGuiApplication::screens)
+            .define_singleton_function("set_application_display_name", &QGuiApplication::setApplicationDisplayName, Arg("name"))
+            .define_singleton_function("set_desktop_file_name", &QGuiApplication::setDesktopFileName, Arg("name"))
+            .define_singleton_function("set_desktop_settings_aware", &QGuiApplication::setDesktopSettingsAware, Arg("on"))
+            .define_singleton_function("set_font", &QGuiApplication::setFont, Arg("font"))
+            .define_singleton_function("set_high_dpi_scale_factor_rounding_policy", &QGuiApplication::setHighDpiScaleFactorRoundingPolicy, Arg("policy"))
+            .define_singleton_function("set_layout_direction", &QGuiApplication::setLayoutDirection, Arg("direction"))
+            .define_singleton_function("set_override_cursor", &QGuiApplication::setOverrideCursor, Arg("cursor"))
+            .define_singleton_function("set_palette", &QGuiApplication::setPalette, Arg("pal"))
+            .define_singleton_function("set_quit_on_last_window_closed", &QGuiApplication::setQuitOnLastWindowClosed, Arg("quit"))
+            .define_singleton_function("set_window_icon", &QGuiApplication::setWindowIcon, Arg("icon"))
+            .define_singleton_function("style_hints", &QGuiApplication::styleHints)
+            .define_singleton_function("sync", &QGuiApplication::sync)
+            .define_singleton_function("top_level_at", &QGuiApplication::topLevelAt, Arg("pos"))
+            .define_singleton_function("top_level_windows", &QGuiApplication::topLevelWindows)
+            .define_singleton_function("window_icon", &QGuiApplication::windowIcon);
+}

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

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

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

@@ -0,0 +1,223 @@
+#include "qicon-rb.hpp"
+#include <qicon.h>
+#include <rice/qt6/qenum.hpp>
+
+#include <QPainter>
+#include <QWindow>
+
+using namespace Rice;
+
+Rice::Class rb_cQIcon;
+
+void Init_qicon(Rice::Module rb_mQt6QtGui)
+{
+    rb_cQIcon =
+        // RubyQt6::QtGui::QIcon
+        define_class_under<QIcon>(rb_mQt6QtGui, "QIcon")
+            // Constructor
+            .define_constructor(Constructor<QIcon>())
+            .define_constructor(Constructor<QIcon, const QString &>(), Arg("file_name"))
+            .define_constructor(Constructor<QIcon, const QPixmap &>(), Arg("pixmap"))
+            // Public Functions
+            .define_method<QSize (QIcon::*)(const QSize &, QIcon::Mode, QIcon::State) const>("actual_size", &QIcon::actualSize, Arg("size"), Arg("mode") = static_cast<QIcon::Mode>(QIcon::Mode::Normal), Arg("state") = static_cast<QIcon::State>(QIcon::State::Off))
+            .define_method("add_file", &QIcon::addFile, Arg("file_name"), Arg("size") = static_cast<const QSize &>(QSize()), Arg("mode") = static_cast<QIcon::Mode>(QIcon::Mode::Normal), Arg("state") = static_cast<QIcon::State>(QIcon::State::Off))
+            .define_method("add_pixmap", &QIcon::addPixmap, Arg("pixmap"), Arg("mode") = static_cast<QIcon::Mode>(QIcon::Mode::Normal), Arg("state") = static_cast<QIcon::State>(QIcon::State::Off))
+            .define_method("available_sizes", &QIcon::availableSizes, Arg("mode") = static_cast<QIcon::Mode>(QIcon::Mode::Normal), Arg("state") = static_cast<QIcon::State>(QIcon::State::Off))
+            .define_method("cache_key", &QIcon::cacheKey)
+            .define_method("detach", &QIcon::detach)
+            .define_method("detached?", &QIcon::isDetached)
+            .define_method("mask?", &QIcon::isMask)
+            .define_method("null?", &QIcon::isNull)
+            .define_method("name", &QIcon::name)
+            .define_method<void (QIcon::*)(QPainter *, const QRect &, Qt::Alignment, QIcon::Mode, QIcon::State) const>("paint", &QIcon::paint, Arg("painter"), Arg("rect"), Arg("alignment") = static_cast<Qt::Alignment>(Qt::AlignCenter), Arg("mode") = static_cast<QIcon::Mode>(QIcon::Mode::Normal), Arg("state") = static_cast<QIcon::State>(QIcon::State::Off))
+            .define_method<void (QIcon::*)(QPainter *, int, int, int, int, Qt::Alignment, QIcon::Mode, QIcon::State) const>("paint", &QIcon::paint, Arg("painter"), Arg("x"), Arg("y"), Arg("w"), Arg("h"), Arg("alignment") = static_cast<Qt::Alignment>(Qt::AlignCenter), Arg("mode") = static_cast<QIcon::Mode>(QIcon::Mode::Normal), Arg("state") = static_cast<QIcon::State>(QIcon::State::Off))
+            .define_method<QPixmap (QIcon::*)(const QSize &, QIcon::Mode, QIcon::State) const>("pixmap", &QIcon::pixmap, Arg("size"), Arg("mode") = static_cast<QIcon::Mode>(QIcon::Mode::Normal), Arg("state") = static_cast<QIcon::State>(QIcon::State::Off))
+            .define_method<QPixmap (QIcon::*)(const QSize &, qreal, QIcon::Mode, QIcon::State) const>("pixmap", &QIcon::pixmap, Arg("size"), Arg("device_pixel_ratio"), Arg("mode") = static_cast<QIcon::Mode>(QIcon::Mode::Normal), Arg("state") = static_cast<QIcon::State>(QIcon::State::Off))
+            .define_method<QPixmap (QIcon::*)(int, QIcon::Mode, QIcon::State) const>("pixmap", &QIcon::pixmap, Arg("extent"), Arg("mode") = static_cast<QIcon::Mode>(QIcon::Mode::Normal), Arg("state") = static_cast<QIcon::State>(QIcon::State::Off))
+            .define_method<QPixmap (QIcon::*)(int, int, QIcon::Mode, QIcon::State) const>("pixmap", &QIcon::pixmap, Arg("w"), Arg("h"), Arg("mode") = static_cast<QIcon::Mode>(QIcon::Mode::Normal), Arg("state") = static_cast<QIcon::State>(QIcon::State::Off))
+            .define_method("set_is_mask", &QIcon::setIsMask, Arg("is_mask"))
+            // Static Public Members
+            .define_singleton_function("fallback_search_paths", &QIcon::fallbackSearchPaths)
+            .define_singleton_function("fallback_theme_name", &QIcon::fallbackThemeName)
+            .define_singleton_function<QIcon (*)(QIcon::ThemeIcon)>("from_theme", &QIcon::fromTheme, Arg("icon"))
+            .define_singleton_function<QIcon (*)(QIcon::ThemeIcon, const QIcon &)>("from_theme", &QIcon::fromTheme, Arg("icon"), Arg("fallback"))
+            .define_singleton_function<QIcon (*)(const QString &)>("from_theme", &QIcon::fromTheme, Arg("name"))
+            .define_singleton_function<QIcon (*)(const QString &, const QIcon &)>("from_theme", &QIcon::fromTheme, Arg("name"), Arg("fallback"))
+            .define_singleton_function<bool (*)(QIcon::ThemeIcon)>("has_theme_icon", &QIcon::hasThemeIcon, Arg("icon"))
+            .define_singleton_function<bool (*)(const QString &)>("has_theme_icon", &QIcon::hasThemeIcon, Arg("name"))
+            .define_singleton_function("set_fallback_search_paths", &QIcon::setFallbackSearchPaths, Arg("paths"))
+            .define_singleton_function("set_fallback_theme_name", &QIcon::setFallbackThemeName, Arg("name"))
+            .define_singleton_function("set_theme_name", &QIcon::setThemeName, Arg("path"))
+            .define_singleton_function("set_theme_search_paths", &QIcon::setThemeSearchPaths, Arg("searchpath"))
+            .define_singleton_function("theme_name", &QIcon::themeName)
+            .define_singleton_function("theme_search_paths", &QIcon::themeSearchPaths);
+
+    Data_Type<QIcon::Mode> rb_cQIconMode =
+        // RubyQt6::QtGui::QIcon::Mode
+        define_qenum_under<QIcon::Mode>(rb_cQIcon, "Mode");
+        define_qenum_value_under(rb_cQIconMode, "Normal", QIcon::Mode::Normal);
+        define_qenum_value_under(rb_cQIconMode, "Disabled", QIcon::Mode::Disabled);
+        define_qenum_value_under(rb_cQIconMode, "Active", QIcon::Mode::Active);
+        define_qenum_value_under(rb_cQIconMode, "Selected", QIcon::Mode::Selected);
+
+    Data_Type<QIcon::State> rb_cQIconState =
+        // RubyQt6::QtGui::QIcon::State
+        define_qenum_under<QIcon::State>(rb_cQIcon, "State");
+        define_qenum_value_under(rb_cQIconState, "On", QIcon::State::On);
+        define_qenum_value_under(rb_cQIconState, "Off", QIcon::State::Off);
+
+    Data_Type<QIcon::ThemeIcon> rb_cQIconThemeIcon =
+        // RubyQt6::QtGui::QIcon::ThemeIcon
+        define_qenum_under<QIcon::ThemeIcon>(rb_cQIcon, "ThemeIcon");
+        define_qenum_value_under(rb_cQIconThemeIcon, "AddressBookNew", QIcon::ThemeIcon::AddressBookNew);
+        define_qenum_value_under(rb_cQIconThemeIcon, "ApplicationExit", QIcon::ThemeIcon::ApplicationExit);
+        define_qenum_value_under(rb_cQIconThemeIcon, "AppointmentNew", QIcon::ThemeIcon::AppointmentNew);
+        define_qenum_value_under(rb_cQIconThemeIcon, "CallStart", QIcon::ThemeIcon::CallStart);
+        define_qenum_value_under(rb_cQIconThemeIcon, "CallStop", QIcon::ThemeIcon::CallStop);
+        define_qenum_value_under(rb_cQIconThemeIcon, "ContactNew", QIcon::ThemeIcon::ContactNew);
+        define_qenum_value_under(rb_cQIconThemeIcon, "DocumentNew", QIcon::ThemeIcon::DocumentNew);
+        define_qenum_value_under(rb_cQIconThemeIcon, "DocumentOpen", QIcon::ThemeIcon::DocumentOpen);
+        define_qenum_value_under(rb_cQIconThemeIcon, "DocumentOpenRecent", QIcon::ThemeIcon::DocumentOpenRecent);
+        define_qenum_value_under(rb_cQIconThemeIcon, "DocumentPageSetup", QIcon::ThemeIcon::DocumentPageSetup);
+        define_qenum_value_under(rb_cQIconThemeIcon, "DocumentPrint", QIcon::ThemeIcon::DocumentPrint);
+        define_qenum_value_under(rb_cQIconThemeIcon, "DocumentPrintPreview", QIcon::ThemeIcon::DocumentPrintPreview);
+        define_qenum_value_under(rb_cQIconThemeIcon, "DocumentProperties", QIcon::ThemeIcon::DocumentProperties);
+        define_qenum_value_under(rb_cQIconThemeIcon, "DocumentRevert", QIcon::ThemeIcon::DocumentRevert);
+        define_qenum_value_under(rb_cQIconThemeIcon, "DocumentSave", QIcon::ThemeIcon::DocumentSave);
+        define_qenum_value_under(rb_cQIconThemeIcon, "DocumentSaveAs", QIcon::ThemeIcon::DocumentSaveAs);
+        define_qenum_value_under(rb_cQIconThemeIcon, "DocumentSend", QIcon::ThemeIcon::DocumentSend);
+        define_qenum_value_under(rb_cQIconThemeIcon, "EditClear", QIcon::ThemeIcon::EditClear);
+        define_qenum_value_under(rb_cQIconThemeIcon, "EditCopy", QIcon::ThemeIcon::EditCopy);
+        define_qenum_value_under(rb_cQIconThemeIcon, "EditCut", QIcon::ThemeIcon::EditCut);
+        define_qenum_value_under(rb_cQIconThemeIcon, "EditDelete", QIcon::ThemeIcon::EditDelete);
+        define_qenum_value_under(rb_cQIconThemeIcon, "EditFind", QIcon::ThemeIcon::EditFind);
+        define_qenum_value_under(rb_cQIconThemeIcon, "EditPaste", QIcon::ThemeIcon::EditPaste);
+        define_qenum_value_under(rb_cQIconThemeIcon, "EditRedo", QIcon::ThemeIcon::EditRedo);
+        define_qenum_value_under(rb_cQIconThemeIcon, "EditSelectAll", QIcon::ThemeIcon::EditSelectAll);
+        define_qenum_value_under(rb_cQIconThemeIcon, "EditUndo", QIcon::ThemeIcon::EditUndo);
+        define_qenum_value_under(rb_cQIconThemeIcon, "FolderNew", QIcon::ThemeIcon::FolderNew);
+        define_qenum_value_under(rb_cQIconThemeIcon, "FormatIndentLess", QIcon::ThemeIcon::FormatIndentLess);
+        define_qenum_value_under(rb_cQIconThemeIcon, "FormatIndentMore", QIcon::ThemeIcon::FormatIndentMore);
+        define_qenum_value_under(rb_cQIconThemeIcon, "FormatJustifyCenter", QIcon::ThemeIcon::FormatJustifyCenter);
+        define_qenum_value_under(rb_cQIconThemeIcon, "FormatJustifyFill", QIcon::ThemeIcon::FormatJustifyFill);
+        define_qenum_value_under(rb_cQIconThemeIcon, "FormatJustifyLeft", QIcon::ThemeIcon::FormatJustifyLeft);
+        define_qenum_value_under(rb_cQIconThemeIcon, "FormatJustifyRight", QIcon::ThemeIcon::FormatJustifyRight);
+        define_qenum_value_under(rb_cQIconThemeIcon, "FormatTextDirectionLtr", QIcon::ThemeIcon::FormatTextDirectionLtr);
+        define_qenum_value_under(rb_cQIconThemeIcon, "FormatTextDirectionRtl", QIcon::ThemeIcon::FormatTextDirectionRtl);
+        define_qenum_value_under(rb_cQIconThemeIcon, "FormatTextBold", QIcon::ThemeIcon::FormatTextBold);
+        define_qenum_value_under(rb_cQIconThemeIcon, "FormatTextItalic", QIcon::ThemeIcon::FormatTextItalic);
+        define_qenum_value_under(rb_cQIconThemeIcon, "FormatTextUnderline", QIcon::ThemeIcon::FormatTextUnderline);
+        define_qenum_value_under(rb_cQIconThemeIcon, "FormatTextStrikethrough", QIcon::ThemeIcon::FormatTextStrikethrough);
+        define_qenum_value_under(rb_cQIconThemeIcon, "GoDown", QIcon::ThemeIcon::GoDown);
+        define_qenum_value_under(rb_cQIconThemeIcon, "GoHome", QIcon::ThemeIcon::GoHome);
+        define_qenum_value_under(rb_cQIconThemeIcon, "GoNext", QIcon::ThemeIcon::GoNext);
+        define_qenum_value_under(rb_cQIconThemeIcon, "GoPrevious", QIcon::ThemeIcon::GoPrevious);
+        define_qenum_value_under(rb_cQIconThemeIcon, "GoUp", QIcon::ThemeIcon::GoUp);
+        define_qenum_value_under(rb_cQIconThemeIcon, "HelpAbout", QIcon::ThemeIcon::HelpAbout);
+        define_qenum_value_under(rb_cQIconThemeIcon, "HelpFaq", QIcon::ThemeIcon::HelpFaq);
+        define_qenum_value_under(rb_cQIconThemeIcon, "InsertImage", QIcon::ThemeIcon::InsertImage);
+        define_qenum_value_under(rb_cQIconThemeIcon, "InsertLink", QIcon::ThemeIcon::InsertLink);
+        define_qenum_value_under(rb_cQIconThemeIcon, "InsertText", QIcon::ThemeIcon::InsertText);
+        define_qenum_value_under(rb_cQIconThemeIcon, "ListAdd", QIcon::ThemeIcon::ListAdd);
+        define_qenum_value_under(rb_cQIconThemeIcon, "ListRemove", QIcon::ThemeIcon::ListRemove);
+        define_qenum_value_under(rb_cQIconThemeIcon, "MailForward", QIcon::ThemeIcon::MailForward);
+        define_qenum_value_under(rb_cQIconThemeIcon, "MailMarkImportant", QIcon::ThemeIcon::MailMarkImportant);
+        define_qenum_value_under(rb_cQIconThemeIcon, "MailMarkRead", QIcon::ThemeIcon::MailMarkRead);
+        define_qenum_value_under(rb_cQIconThemeIcon, "MailMarkUnread", QIcon::ThemeIcon::MailMarkUnread);
+        define_qenum_value_under(rb_cQIconThemeIcon, "MailMessageNew", QIcon::ThemeIcon::MailMessageNew);
+        define_qenum_value_under(rb_cQIconThemeIcon, "MailReplyAll", QIcon::ThemeIcon::MailReplyAll);
+        define_qenum_value_under(rb_cQIconThemeIcon, "MailReplySender", QIcon::ThemeIcon::MailReplySender);
+        define_qenum_value_under(rb_cQIconThemeIcon, "MailSend", QIcon::ThemeIcon::MailSend);
+        define_qenum_value_under(rb_cQIconThemeIcon, "MediaEject", QIcon::ThemeIcon::MediaEject);
+        define_qenum_value_under(rb_cQIconThemeIcon, "MediaPlaybackPause", QIcon::ThemeIcon::MediaPlaybackPause);
+        define_qenum_value_under(rb_cQIconThemeIcon, "MediaPlaybackStart", QIcon::ThemeIcon::MediaPlaybackStart);
+        define_qenum_value_under(rb_cQIconThemeIcon, "MediaPlaybackStop", QIcon::ThemeIcon::MediaPlaybackStop);
+        define_qenum_value_under(rb_cQIconThemeIcon, "MediaRecord", QIcon::ThemeIcon::MediaRecord);
+        define_qenum_value_under(rb_cQIconThemeIcon, "MediaSeekBackward", QIcon::ThemeIcon::MediaSeekBackward);
+        define_qenum_value_under(rb_cQIconThemeIcon, "MediaSeekForward", QIcon::ThemeIcon::MediaSeekForward);
+        define_qenum_value_under(rb_cQIconThemeIcon, "MediaSkipBackward", QIcon::ThemeIcon::MediaSkipBackward);
+        define_qenum_value_under(rb_cQIconThemeIcon, "MediaSkipForward", QIcon::ThemeIcon::MediaSkipForward);
+        define_qenum_value_under(rb_cQIconThemeIcon, "ObjectRotateLeft", QIcon::ThemeIcon::ObjectRotateLeft);
+        define_qenum_value_under(rb_cQIconThemeIcon, "ObjectRotateRight", QIcon::ThemeIcon::ObjectRotateRight);
+        define_qenum_value_under(rb_cQIconThemeIcon, "ProcessStop", QIcon::ThemeIcon::ProcessStop);
+        define_qenum_value_under(rb_cQIconThemeIcon, "SystemLockScreen", QIcon::ThemeIcon::SystemLockScreen);
+        define_qenum_value_under(rb_cQIconThemeIcon, "SystemLogOut", QIcon::ThemeIcon::SystemLogOut);
+        define_qenum_value_under(rb_cQIconThemeIcon, "SystemSearch", QIcon::ThemeIcon::SystemSearch);
+        define_qenum_value_under(rb_cQIconThemeIcon, "SystemReboot", QIcon::ThemeIcon::SystemReboot);
+        define_qenum_value_under(rb_cQIconThemeIcon, "SystemShutdown", QIcon::ThemeIcon::SystemShutdown);
+        define_qenum_value_under(rb_cQIconThemeIcon, "ToolsCheckSpelling", QIcon::ThemeIcon::ToolsCheckSpelling);
+        define_qenum_value_under(rb_cQIconThemeIcon, "ViewFullscreen", QIcon::ThemeIcon::ViewFullscreen);
+        define_qenum_value_under(rb_cQIconThemeIcon, "ViewRefresh", QIcon::ThemeIcon::ViewRefresh);
+        define_qenum_value_under(rb_cQIconThemeIcon, "ViewRestore", QIcon::ThemeIcon::ViewRestore);
+        define_qenum_value_under(rb_cQIconThemeIcon, "WindowClose", QIcon::ThemeIcon::WindowClose);
+        define_qenum_value_under(rb_cQIconThemeIcon, "WindowNew", QIcon::ThemeIcon::WindowNew);
+        define_qenum_value_under(rb_cQIconThemeIcon, "ZoomFitBest", QIcon::ThemeIcon::ZoomFitBest);
+        define_qenum_value_under(rb_cQIconThemeIcon, "ZoomIn", QIcon::ThemeIcon::ZoomIn);
+        define_qenum_value_under(rb_cQIconThemeIcon, "ZoomOut", QIcon::ThemeIcon::ZoomOut);
+        define_qenum_value_under(rb_cQIconThemeIcon, "AudioCard", QIcon::ThemeIcon::AudioCard);
+        define_qenum_value_under(rb_cQIconThemeIcon, "AudioInputMicrophone", QIcon::ThemeIcon::AudioInputMicrophone);
+        define_qenum_value_under(rb_cQIconThemeIcon, "Battery", QIcon::ThemeIcon::Battery);
+        define_qenum_value_under(rb_cQIconThemeIcon, "CameraPhoto", QIcon::ThemeIcon::CameraPhoto);
+        define_qenum_value_under(rb_cQIconThemeIcon, "CameraVideo", QIcon::ThemeIcon::CameraVideo);
+        define_qenum_value_under(rb_cQIconThemeIcon, "CameraWeb", QIcon::ThemeIcon::CameraWeb);
+        define_qenum_value_under(rb_cQIconThemeIcon, "Computer", QIcon::ThemeIcon::Computer);
+        define_qenum_value_under(rb_cQIconThemeIcon, "DriveHarddisk", QIcon::ThemeIcon::DriveHarddisk);
+        define_qenum_value_under(rb_cQIconThemeIcon, "DriveOptical", QIcon::ThemeIcon::DriveOptical);
+        define_qenum_value_under(rb_cQIconThemeIcon, "InputGaming", QIcon::ThemeIcon::InputGaming);
+        define_qenum_value_under(rb_cQIconThemeIcon, "InputKeyboard", QIcon::ThemeIcon::InputKeyboard);
+        define_qenum_value_under(rb_cQIconThemeIcon, "InputMouse", QIcon::ThemeIcon::InputMouse);
+        define_qenum_value_under(rb_cQIconThemeIcon, "InputTablet", QIcon::ThemeIcon::InputTablet);
+        define_qenum_value_under(rb_cQIconThemeIcon, "MediaFlash", QIcon::ThemeIcon::MediaFlash);
+        define_qenum_value_under(rb_cQIconThemeIcon, "MediaOptical", QIcon::ThemeIcon::MediaOptical);
+        define_qenum_value_under(rb_cQIconThemeIcon, "MediaTape", QIcon::ThemeIcon::MediaTape);
+        define_qenum_value_under(rb_cQIconThemeIcon, "MultimediaPlayer", QIcon::ThemeIcon::MultimediaPlayer);
+        define_qenum_value_under(rb_cQIconThemeIcon, "NetworkWired", QIcon::ThemeIcon::NetworkWired);
+        define_qenum_value_under(rb_cQIconThemeIcon, "NetworkWireless", QIcon::ThemeIcon::NetworkWireless);
+        define_qenum_value_under(rb_cQIconThemeIcon, "Phone", QIcon::ThemeIcon::Phone);
+        define_qenum_value_under(rb_cQIconThemeIcon, "Printer", QIcon::ThemeIcon::Printer);
+        define_qenum_value_under(rb_cQIconThemeIcon, "Scanner", QIcon::ThemeIcon::Scanner);
+        define_qenum_value_under(rb_cQIconThemeIcon, "VideoDisplay", QIcon::ThemeIcon::VideoDisplay);
+        define_qenum_value_under(rb_cQIconThemeIcon, "AppointmentMissed", QIcon::ThemeIcon::AppointmentMissed);
+        define_qenum_value_under(rb_cQIconThemeIcon, "AppointmentSoon", QIcon::ThemeIcon::AppointmentSoon);
+        define_qenum_value_under(rb_cQIconThemeIcon, "AudioVolumeHigh", QIcon::ThemeIcon::AudioVolumeHigh);
+        define_qenum_value_under(rb_cQIconThemeIcon, "AudioVolumeLow", QIcon::ThemeIcon::AudioVolumeLow);
+        define_qenum_value_under(rb_cQIconThemeIcon, "AudioVolumeMedium", QIcon::ThemeIcon::AudioVolumeMedium);
+        define_qenum_value_under(rb_cQIconThemeIcon, "AudioVolumeMuted", QIcon::ThemeIcon::AudioVolumeMuted);
+        define_qenum_value_under(rb_cQIconThemeIcon, "BatteryCaution", QIcon::ThemeIcon::BatteryCaution);
+        define_qenum_value_under(rb_cQIconThemeIcon, "BatteryLow", QIcon::ThemeIcon::BatteryLow);
+        define_qenum_value_under(rb_cQIconThemeIcon, "DialogError", QIcon::ThemeIcon::DialogError);
+        define_qenum_value_under(rb_cQIconThemeIcon, "DialogInformation", QIcon::ThemeIcon::DialogInformation);
+        define_qenum_value_under(rb_cQIconThemeIcon, "DialogPassword", QIcon::ThemeIcon::DialogPassword);
+        define_qenum_value_under(rb_cQIconThemeIcon, "DialogQuestion", QIcon::ThemeIcon::DialogQuestion);
+        define_qenum_value_under(rb_cQIconThemeIcon, "DialogWarning", QIcon::ThemeIcon::DialogWarning);
+        define_qenum_value_under(rb_cQIconThemeIcon, "FolderDragAccept", QIcon::ThemeIcon::FolderDragAccept);
+        define_qenum_value_under(rb_cQIconThemeIcon, "FolderOpen", QIcon::ThemeIcon::FolderOpen);
+        define_qenum_value_under(rb_cQIconThemeIcon, "FolderVisiting", QIcon::ThemeIcon::FolderVisiting);
+        define_qenum_value_under(rb_cQIconThemeIcon, "ImageLoading", QIcon::ThemeIcon::ImageLoading);
+        define_qenum_value_under(rb_cQIconThemeIcon, "ImageMissing", QIcon::ThemeIcon::ImageMissing);
+        define_qenum_value_under(rb_cQIconThemeIcon, "MailAttachment", QIcon::ThemeIcon::MailAttachment);
+        define_qenum_value_under(rb_cQIconThemeIcon, "MailUnread", QIcon::ThemeIcon::MailUnread);
+        define_qenum_value_under(rb_cQIconThemeIcon, "MailRead", QIcon::ThemeIcon::MailRead);
+        define_qenum_value_under(rb_cQIconThemeIcon, "MailReplied", QIcon::ThemeIcon::MailReplied);
+        define_qenum_value_under(rb_cQIconThemeIcon, "MediaPlaylistRepeat", QIcon::ThemeIcon::MediaPlaylistRepeat);
+        define_qenum_value_under(rb_cQIconThemeIcon, "MediaPlaylistShuffle", QIcon::ThemeIcon::MediaPlaylistShuffle);
+        define_qenum_value_under(rb_cQIconThemeIcon, "NetworkOffline", QIcon::ThemeIcon::NetworkOffline);
+        define_qenum_value_under(rb_cQIconThemeIcon, "PrinterPrinting", QIcon::ThemeIcon::PrinterPrinting);
+        define_qenum_value_under(rb_cQIconThemeIcon, "SecurityHigh", QIcon::ThemeIcon::SecurityHigh);
+        define_qenum_value_under(rb_cQIconThemeIcon, "SecurityLow", QIcon::ThemeIcon::SecurityLow);
+        define_qenum_value_under(rb_cQIconThemeIcon, "SoftwareUpdateAvailable", QIcon::ThemeIcon::SoftwareUpdateAvailable);
+        define_qenum_value_under(rb_cQIconThemeIcon, "SoftwareUpdateUrgent", QIcon::ThemeIcon::SoftwareUpdateUrgent);
+        define_qenum_value_under(rb_cQIconThemeIcon, "SyncError", QIcon::ThemeIcon::SyncError);
+        define_qenum_value_under(rb_cQIconThemeIcon, "SyncSynchronizing", QIcon::ThemeIcon::SyncSynchronizing);
+        define_qenum_value_under(rb_cQIconThemeIcon, "UserAvailable", QIcon::ThemeIcon::UserAvailable);
+        define_qenum_value_under(rb_cQIconThemeIcon, "UserOffline", QIcon::ThemeIcon::UserOffline);
+        define_qenum_value_under(rb_cQIconThemeIcon, "WeatherClear", QIcon::ThemeIcon::WeatherClear);
+        define_qenum_value_under(rb_cQIconThemeIcon, "WeatherClearNight", QIcon::ThemeIcon::WeatherClearNight);
+        define_qenum_value_under(rb_cQIconThemeIcon, "WeatherFewClouds", QIcon::ThemeIcon::WeatherFewClouds);
+        define_qenum_value_under(rb_cQIconThemeIcon, "WeatherFewCloudsNight", QIcon::ThemeIcon::WeatherFewCloudsNight);
+        define_qenum_value_under(rb_cQIconThemeIcon, "WeatherFog", QIcon::ThemeIcon::WeatherFog);
+        define_qenum_value_under(rb_cQIconThemeIcon, "WeatherShowers", QIcon::ThemeIcon::WeatherShowers);
+        define_qenum_value_under(rb_cQIconThemeIcon, "WeatherSnow", QIcon::ThemeIcon::WeatherSnow);
+        define_qenum_value_under(rb_cQIconThemeIcon, "WeatherStorm", QIcon::ThemeIcon::WeatherStorm);
+        define_qenum_value_under(rb_cQIconThemeIcon, "NThemeIcons", QIcon::ThemeIcon::NThemeIcons);
+}

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

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

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

@@ -0,0 +1,181 @@
+#include "qimage-rb.hpp"
+#include <qimage.h>
+#include <rice/qt6/qenum.hpp>
+
+#include <QColorTransform>
+#include <QColorSpace>
+#include <QIODevice>
+#include <QPaintEngine>
+
+using namespace Rice;
+
+Rice::Class rb_cQImage;
+
+void Init_qimage(Rice::Module rb_mQt6QtGui)
+{
+    rb_cQImage =
+        // RubyQt6::QtGui::QImage
+        define_class_under<QImage, QPaintDevice>(rb_mQt6QtGui, "QImage")
+            // Constructor
+            .define_constructor(Constructor<QImage>())
+            .define_constructor(Constructor<QImage, const QString &>(), Arg("file_name"))
+            .define_constructor(Constructor<QImage, const QSize &, QImage::Format>(), Arg("size"), Arg("format"))
+            // Public Functions
+            .define_method("all_gray", &QImage::allGray)
+            .define_method<void (QImage::*)(const QColorTransform &)>("apply_color_transform", &QImage::applyColorTransform, Arg("transform"))
+            .define_method<void (QImage::*)(const QColorTransform &, QImage::Format, Qt::ImageConversionFlags)>("apply_color_transform", &QImage::applyColorTransform, Arg("transform"), Arg("format"), Arg("flags") = static_cast<Qt::ImageConversionFlags>(Qt::AutoColor))
+            .define_method("bit_plane_count", &QImage::bitPlaneCount)
+            .define_method<const uchar *(QImage::*)() const>("bits", &QImage::bits)
+            .define_method<uchar *(QImage::*)()>("bits", &QImage::bits)
+            .define_method("bytes_per_line", &QImage::bytesPerLine)
+            .define_method("cache_key", &QImage::cacheKey)
+            .define_method("color", &QImage::color, Arg("i"))
+            .define_method("color_count", &QImage::colorCount)
+            .define_method("color_space", &QImage::colorSpace)
+            .define_method("color_table", &QImage::colorTable)
+            // .define_method<QImage (QImage::*)(const QColorTransform &) const>("color_transformed", &QImage::colorTransformed, Arg("transform"))
+            // .define_method<QImage (QImage::*)(const QColorTransform &)>("color_transformed", &QImage::colorTransformed, Arg("transform"))
+            // .define_method<QImage (QImage::*)(const QColorTransform &, QImage::Format, Qt::ImageConversionFlags) const>("color_transformed", &QImage::colorTransformed, Arg("transform"), Arg("format"), Arg("flags") = static_cast<Qt::ImageConversionFlags>(Qt::AutoColor))
+            // .define_method<QImage (QImage::*)(const QColorTransform &, QImage::Format, Qt::ImageConversionFlags)>("color_transformed", &QImage::colorTransformed, Arg("transform"), Arg("format"), Arg("flags") = static_cast<Qt::ImageConversionFlags>(Qt::AutoColor))
+            .define_method("const_bits", &QImage::constBits)
+            .define_method("const_scan_line", &QImage::constScanLine, Arg("i"))
+            .define_method("convert_to", &QImage::convertTo, Arg("f"), Arg("flags") = static_cast<Qt::ImageConversionFlags>(Qt::AutoColor))
+            .define_method<void (QImage::*)(const QColorSpace &)>("convert_to_color_space", &QImage::convertToColorSpace, Arg("color_space"))
+            .define_method<void (QImage::*)(const QColorSpace &, QImage::Format, Qt::ImageConversionFlags)>("convert_to_color_space", &QImage::convertToColorSpace, Arg("color_space"), Arg("format"), Arg("flags") = static_cast<Qt::ImageConversionFlags>(Qt::AutoColor))
+            // .define_method<QImage (QImage::*)(QImage::Format, Qt::ImageConversionFlags) const>("convert_to_format", &QImage::convertToFormat, Arg("f"), Arg("flags") = static_cast<Qt::ImageConversionFlags>(Qt::AutoColor))
+            // .define_method<QImage (QImage::*)(QImage::Format, Qt::ImageConversionFlags)>("convert_to_format", &QImage::convertToFormat, Arg("f"), Arg("flags") = static_cast<Qt::ImageConversionFlags>(Qt::AutoColor))
+            // .define_method<QImage (QImage::*)(QImage::Format, const QList &, Qt::ImageConversionFlags) const>("convert_to_format", &QImage::convertToFormat, Arg("f"), Arg("color_table"), Arg("flags") = static_cast<Qt::ImageConversionFlags>(Qt::AutoColor))
+            // .define_method<QImage (QImage::*)(QImage::Format, Qt::ImageConversionFlags) const>("converted_to", &QImage::convertedTo, Arg("f"), Arg("flags") = static_cast<Qt::ImageConversionFlags>(Qt::AutoColor))
+            // .define_method<QImage (QImage::*)(QImage::Format, Qt::ImageConversionFlags)>("converted_to", &QImage::convertedTo, Arg("f"), Arg("flags") = static_cast<Qt::ImageConversionFlags>(Qt::AutoColor))
+            // .define_method<QImage (QImage::*)(const QColorSpace &) const>("converted_to_color_space", &QImage::convertedToColorSpace, Arg("color_space"))
+            // .define_method<QImage (QImage::*)(const QColorSpace &, QImage::Format, Qt::ImageConversionFlags) const>("converted_to_color_space", &QImage::convertedToColorSpace, Arg("color_space"), Arg("format"), Arg("flags") = static_cast<Qt::ImageConversionFlags>(Qt::AutoColor))
+            // .define_method<QImage (QImage::*)(const QColorSpace &, QImage::Format, Qt::ImageConversionFlags)>("converted_to_color_space", &QImage::convertedToColorSpace, Arg("color_space"), Arg("format"), Arg("flags") = static_cast<Qt::ImageConversionFlags>(Qt::AutoColor))
+            .define_method<QImage (QImage::*)(const QRect &) const>("copy", &QImage::copy, Arg("rect") = static_cast<const QRect &>(QRect()))
+            .define_method<QImage (QImage::*)(int, int, int, int) const>("copy", &QImage::copy, Arg("x"), Arg("y"), Arg("w"), Arg("h"))
+            .define_method("create_alpha_mask", &QImage::createAlphaMask, Arg("flags") = static_cast<Qt::ImageConversionFlags>(Qt::AutoColor))
+            .define_method("create_heuristic_mask", &QImage::createHeuristicMask, Arg("clip_tight") = static_cast<bool>(true))
+            .define_method("create_mask_from_color", &QImage::createMaskFromColor, Arg("color"), Arg("mode") = static_cast<Qt::MaskMode>(Qt::MaskInColor))
+            .define_method("depth", &QImage::depth)
+            .define_method("detach", &QImage::detach)
+            .define_method("dev_type", &QImage::devType)
+            .define_method("device_independent_size", &QImage::deviceIndependentSize)
+            .define_method("device_pixel_ratio", &QImage::devicePixelRatio)
+            .define_method("dots_per_meter_x", &QImage::dotsPerMeterX)
+            .define_method("dots_per_meter_y", &QImage::dotsPerMeterY)
+            .define_method<void (QImage::*)(uint)>("fill", &QImage::fill, Arg("pixel"))
+            .define_method<void (QImage::*)(Qt::GlobalColor)>("fill", &QImage::fill, Arg("color"))
+            .define_method<void (QImage::*)(const QColor &)>("fill", &QImage::fill, Arg("color"))
+            .define_method("flip", &QImage::flip, Arg("orient") = static_cast<Qt::Orientations>(Qt::Vertical))
+            // .define_method<QImage (QImage::*)(Qt::Orientations) const>("flipped", &QImage::flipped, Arg("orient") = static_cast<Qt::Orientations>(Qt::Vertical))
+            // .define_method<QImage (QImage::*)(Qt::Orientations)>("flipped", &QImage::flipped, Arg("orient") = static_cast<Qt::Orientations>(Qt::Vertical))
+            .define_method("format", &QImage::format)
+            .define_method("has_alpha_channel", &QImage::hasAlphaChannel)
+            .define_method("height", &QImage::height)
+            .define_method("invert_pixels", &QImage::invertPixels, Arg("mode") = static_cast<QImage::InvertMode>(QImage::InvertMode::InvertRgb))
+            .define_method("detached?", &QImage::isDetached)
+            .define_method("grayscale?", &QImage::isGrayscale)
+            .define_method("null?", &QImage::isNull)
+            .define_method<bool (QImage::*)(QIODevice *, const char *)>("load", &QImage::load, Arg("device"), Arg("format"))
+            .define_method<bool (QImage::*)(const QString &, const char *)>("load", &QImage::load, Arg("file_name"), Arg("format") = static_cast<const char *>(nullptr))
+            .define_method<bool (QImage::*)(QByteArrayView, const char *)>("load_from_data", &QImage::loadFromData, Arg("data"), Arg("format") = static_cast<const char *>(nullptr))
+            .define_method<bool (QImage::*)(const QByteArray &, const char *)>("load_from_data", &QImage::loadFromData, Arg("data"), Arg("format") = static_cast<const char *>(nullptr))
+            .define_method<bool (QImage::*)(const uchar *, int, const char *)>("load_from_data", &QImage::loadFromData, Arg("buf"), Arg("len"), Arg("format") = static_cast<const char *>(nullptr))
+            // .define_method("mirror", &QImage::mirror, Arg("horizontally") = static_cast<bool>(false), Arg("vertically") = static_cast<bool>(true))
+            // .define_method<QImage (QImage::*)(bool, bool) const>("mirrored", &QImage::mirrored, Arg("horizontally") = static_cast<bool>(false), Arg("vertically") = static_cast<bool>(true))
+            // .define_method<QImage (QImage::*)(bool, bool)>("mirrored", &QImage::mirrored, Arg("horizontally") = static_cast<bool>(false), Arg("vertically") = static_cast<bool>(true))
+            .define_method("offset", &QImage::offset)
+            .define_method<QRgb (QImage::*)(const QPoint &) const>("pixel", &QImage::pixel, Arg("pt"))
+            .define_method<QRgb (QImage::*)(int, int) const>("pixel", &QImage::pixel, Arg("x"), Arg("y"))
+            .define_method<QColor (QImage::*)(const QPoint &) const>("pixel_color", &QImage::pixelColor, Arg("pt"))
+            .define_method<QColor (QImage::*)(int, int) const>("pixel_color", &QImage::pixelColor, Arg("x"), Arg("y"))
+            .define_method("pixel_format", &QImage::pixelFormat)
+            .define_method<int (QImage::*)(const QPoint &) const>("pixel_index", &QImage::pixelIndex, Arg("pt"))
+            .define_method<int (QImage::*)(int, int) const>("pixel_index", &QImage::pixelIndex, Arg("x"), Arg("y"))
+            .define_method("rect", &QImage::rect)
+            .define_method("reinterpret_as_format", &QImage::reinterpretAsFormat, Arg("f"))
+            .define_method<bool (QImage::*)(QIODevice *, const char *, int) const>("save", &QImage::save, Arg("device"), Arg("format") = static_cast<const char *>(nullptr), Arg("quality") = static_cast<int>(-1))
+            .define_method<bool (QImage::*)(const QString &, const char *, int) const>("save", &QImage::save, Arg("file_name"), Arg("format") = static_cast<const char *>(nullptr), Arg("quality") = static_cast<int>(-1))
+            .define_method<QImage (QImage::*)(const QSize &, Qt::AspectRatioMode, Qt::TransformationMode) const>("scaled", &QImage::scaled, Arg("s"), Arg("aspect_mode") = static_cast<Qt::AspectRatioMode>(Qt::IgnoreAspectRatio), Arg("mode") = static_cast<Qt::TransformationMode>(Qt::FastTransformation))
+            .define_method<QImage (QImage::*)(int, int, Qt::AspectRatioMode, Qt::TransformationMode) const>("scaled", &QImage::scaled, Arg("w"), Arg("h"), Arg("aspect_mode") = static_cast<Qt::AspectRatioMode>(Qt::IgnoreAspectRatio), Arg("mode") = static_cast<Qt::TransformationMode>(Qt::FastTransformation))
+            .define_method("scaled_to_height", &QImage::scaledToHeight, Arg("h"), Arg("mode") = static_cast<Qt::TransformationMode>(Qt::FastTransformation))
+            .define_method("scaled_to_width", &QImage::scaledToWidth, Arg("w"), Arg("mode") = static_cast<Qt::TransformationMode>(Qt::FastTransformation))
+            .define_method<const uchar *(QImage::*)(int) const>("scan_line", &QImage::scanLine, Arg("i"))
+            .define_method<uchar *(QImage::*)(int)>("scan_line", &QImage::scanLine, Arg("i"))
+            .define_method("set_alpha_channel", &QImage::setAlphaChannel, Arg("alpha_channel"))
+            .define_method("set_color", &QImage::setColor, Arg("i"), Arg("c"))
+            .define_method("set_color_count", &QImage::setColorCount, Arg("color_count"))
+            .define_method("set_color_space", &QImage::setColorSpace, Arg("color_space"))
+            .define_method("set_color_table", &QImage::setColorTable, Arg("colors"))
+            .define_method("set_device_pixel_ratio", &QImage::setDevicePixelRatio, Arg("scale_factor"))
+            .define_method("set_dots_per_meter_x", &QImage::setDotsPerMeterX, Arg("x"))
+            .define_method("set_dots_per_meter_y", &QImage::setDotsPerMeterY, Arg("y"))
+            .define_method("set_offset", &QImage::setOffset, Arg("offset"))
+            .define_method<void (QImage::*)(const QPoint &, uint)>("set_pixel", &QImage::setPixel, Arg("pt"), Arg("index_or_rgb"))
+            .define_method<void (QImage::*)(int, int, uint)>("set_pixel", &QImage::setPixel, Arg("x"), Arg("y"), Arg("index_or_rgb"))
+            .define_method<void (QImage::*)(const QPoint &, const QColor &)>("set_pixel_color", &QImage::setPixelColor, Arg("pt"), Arg("c"))
+            .define_method<void (QImage::*)(int, int, const QColor &)>("set_pixel_color", &QImage::setPixelColor, Arg("x"), Arg("y"), Arg("c"))
+            .define_method("set_text", &QImage::setText, Arg("key"), Arg("value"))
+            .define_method("size", &QImage::size)
+            .define_method("size_in_bytes", &QImage::sizeInBytes)
+            .define_method("text", &QImage::text, Arg("key") = static_cast<const QString &>(QString()))
+            .define_method("text_keys", &QImage::textKeys)
+            .define_method("transformed", &QImage::transformed, Arg("matrix"), Arg("mode") = static_cast<Qt::TransformationMode>(Qt::FastTransformation))
+            .define_method<bool (QImage::*)(const QPoint &) const>("valid", &QImage::valid, Arg("pt"))
+            .define_method<bool (QImage::*)(int, int) const>("valid", &QImage::valid, Arg("x"), Arg("y"))
+            .define_method("width", &QImage::width)
+            // Static Public Members
+            .define_singleton_function<QImage (*)(QByteArrayView, const char *)>("from_data", &QImage::fromData, Arg("data"), Arg("format") = static_cast<const char *>(nullptr))
+            .define_singleton_function<QImage (*)(const QByteArray &, const char *)>("from_data", &QImage::fromData, Arg("data"), Arg("format") = static_cast<const char *>(nullptr))
+            .define_singleton_function<QImage (*)(const uchar *, int, const char *)>("from_data", &QImage::fromData, Arg("data"), Arg("size"), Arg("format") = static_cast<const char *>(nullptr))
+            // .define_singleton_function("to_image_format", &QImage::toImageFormat, Arg("format"))
+            // .define_singleton_function("to_pixel_format", &QImage::toPixelFormat, Arg("format"))
+            .define_singleton_function("true_matrix", &QImage::trueMatrix, Arg("matrix"), Arg("w"), Arg("h"));
+
+    Data_Type<QImage::Format> rb_cQImageFormat =
+        // RubyQt6::QtGui::QImage::Format
+        define_qenum_under<QImage::Format>(rb_cQImage, "Format");
+        define_qenum_value_under(rb_cQImageFormat, "Format_Invalid", QImage::Format::Format_Invalid);
+        define_qenum_value_under(rb_cQImageFormat, "Format_Mono", QImage::Format::Format_Mono);
+        define_qenum_value_under(rb_cQImageFormat, "Format_MonoLSB", QImage::Format::Format_MonoLSB);
+        define_qenum_value_under(rb_cQImageFormat, "Format_Indexed8", QImage::Format::Format_Indexed8);
+        define_qenum_value_under(rb_cQImageFormat, "Format_RGB32", QImage::Format::Format_RGB32);
+        define_qenum_value_under(rb_cQImageFormat, "Format_ARGB32", QImage::Format::Format_ARGB32);
+        define_qenum_value_under(rb_cQImageFormat, "Format_ARGB32_Premultiplied", QImage::Format::Format_ARGB32_Premultiplied);
+        define_qenum_value_under(rb_cQImageFormat, "Format_RGB16", QImage::Format::Format_RGB16);
+        define_qenum_value_under(rb_cQImageFormat, "Format_ARGB8565_Premultiplied", QImage::Format::Format_ARGB8565_Premultiplied);
+        define_qenum_value_under(rb_cQImageFormat, "Format_RGB666", QImage::Format::Format_RGB666);
+        define_qenum_value_under(rb_cQImageFormat, "Format_ARGB6666_Premultiplied", QImage::Format::Format_ARGB6666_Premultiplied);
+        define_qenum_value_under(rb_cQImageFormat, "Format_RGB555", QImage::Format::Format_RGB555);
+        define_qenum_value_under(rb_cQImageFormat, "Format_ARGB8555_Premultiplied", QImage::Format::Format_ARGB8555_Premultiplied);
+        define_qenum_value_under(rb_cQImageFormat, "Format_RGB888", QImage::Format::Format_RGB888);
+        define_qenum_value_under(rb_cQImageFormat, "Format_RGB444", QImage::Format::Format_RGB444);
+        define_qenum_value_under(rb_cQImageFormat, "Format_ARGB4444_Premultiplied", QImage::Format::Format_ARGB4444_Premultiplied);
+        define_qenum_value_under(rb_cQImageFormat, "Format_RGBX8888", QImage::Format::Format_RGBX8888);
+        define_qenum_value_under(rb_cQImageFormat, "Format_RGBA8888", QImage::Format::Format_RGBA8888);
+        define_qenum_value_under(rb_cQImageFormat, "Format_RGBA8888_Premultiplied", QImage::Format::Format_RGBA8888_Premultiplied);
+        define_qenum_value_under(rb_cQImageFormat, "Format_BGR30", QImage::Format::Format_BGR30);
+        define_qenum_value_under(rb_cQImageFormat, "Format_A2BGR30_Premultiplied", QImage::Format::Format_A2BGR30_Premultiplied);
+        define_qenum_value_under(rb_cQImageFormat, "Format_RGB30", QImage::Format::Format_RGB30);
+        define_qenum_value_under(rb_cQImageFormat, "Format_A2RGB30_Premultiplied", QImage::Format::Format_A2RGB30_Premultiplied);
+        define_qenum_value_under(rb_cQImageFormat, "Format_Alpha8", QImage::Format::Format_Alpha8);
+        define_qenum_value_under(rb_cQImageFormat, "Format_Grayscale8", QImage::Format::Format_Grayscale8);
+        define_qenum_value_under(rb_cQImageFormat, "Format_RGBX64", QImage::Format::Format_RGBX64);
+        define_qenum_value_under(rb_cQImageFormat, "Format_RGBA64", QImage::Format::Format_RGBA64);
+        define_qenum_value_under(rb_cQImageFormat, "Format_RGBA64_Premultiplied", QImage::Format::Format_RGBA64_Premultiplied);
+        define_qenum_value_under(rb_cQImageFormat, "Format_Grayscale16", QImage::Format::Format_Grayscale16);
+        define_qenum_value_under(rb_cQImageFormat, "Format_BGR888", QImage::Format::Format_BGR888);
+        define_qenum_value_under(rb_cQImageFormat, "Format_RGBX16FPx4", QImage::Format::Format_RGBX16FPx4);
+        define_qenum_value_under(rb_cQImageFormat, "Format_RGBA16FPx4", QImage::Format::Format_RGBA16FPx4);
+        define_qenum_value_under(rb_cQImageFormat, "Format_RGBA16FPx4_Premultiplied", QImage::Format::Format_RGBA16FPx4_Premultiplied);
+        define_qenum_value_under(rb_cQImageFormat, "Format_RGBX32FPx4", QImage::Format::Format_RGBX32FPx4);
+        define_qenum_value_under(rb_cQImageFormat, "Format_RGBA32FPx4", QImage::Format::Format_RGBA32FPx4);
+        define_qenum_value_under(rb_cQImageFormat, "Format_RGBA32FPx4_Premultiplied", QImage::Format::Format_RGBA32FPx4_Premultiplied);
+        define_qenum_value_under(rb_cQImageFormat, "Format_CMYK8888", QImage::Format::Format_CMYK8888);
+        define_qenum_value_under(rb_cQImageFormat, "NImageFormats", QImage::Format::NImageFormats);
+
+    Data_Type<QImage::InvertMode> rb_cQImageInvertMode =
+        // RubyQt6::QtGui::QImage::InvertMode
+        define_qenum_under<QImage::InvertMode>(rb_cQImage, "InvertMode");
+        define_qenum_value_under(rb_cQImageInvertMode, "InvertRgb", QImage::InvertMode::InvertRgb);
+        define_qenum_value_under(rb_cQImageInvertMode, "InvertRgba", QImage::InvertMode::InvertRgba);
+}

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

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

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

@@ -0,0 +1,56 @@
+#include "qimagewriter-rb.hpp"
+#include <qimagewriter.h>
+#include <rice/qt6/qenum.hpp>
+
+using namespace Rice;
+
+Rice::Class rb_cQImageWriter;
+
+void Init_qimagewriter(Rice::Module rb_mQt6QtGui)
+{
+    rb_cQImageWriter =
+        // RubyQt6::QtGui::QImageWriter
+        define_class_under<QImageWriter>(rb_mQt6QtGui, "QImageWriter")
+            // Constructor
+            .define_constructor(Constructor<QImageWriter>())
+            .define_constructor(Constructor<QImageWriter, QIODevice *, const QByteArray &>(), Arg("device"), Arg("format"))
+            .define_constructor(Constructor<QImageWriter, const QString &, const QByteArray &>(), Arg("file_name"), Arg("format"))
+            // Public Functions
+            .define_method("can_write", &QImageWriter::canWrite)
+            .define_method("compression", &QImageWriter::compression)
+            .define_method("device", &QImageWriter::device)
+            .define_method("error", &QImageWriter::error)
+            .define_method("error_string", &QImageWriter::errorString)
+            .define_method("file_name", &QImageWriter::fileName)
+            .define_method("format", &QImageWriter::format)
+            .define_method("optimized_write", &QImageWriter::optimizedWrite)
+            .define_method("progressive_scan_write", &QImageWriter::progressiveScanWrite)
+            .define_method("quality", &QImageWriter::quality)
+            .define_method("set_compression", &QImageWriter::setCompression, Arg("compression"))
+            .define_method("set_device", &QImageWriter::setDevice, Arg("device"))
+            .define_method("set_file_name", &QImageWriter::setFileName, Arg("file_name"))
+            .define_method("set_format", &QImageWriter::setFormat, Arg("format"))
+            .define_method("set_optimized_write", &QImageWriter::setOptimizedWrite, Arg("optimize"))
+            .define_method("set_progressive_scan_write", &QImageWriter::setProgressiveScanWrite, Arg("progressive"))
+            .define_method("set_quality", &QImageWriter::setQuality, Arg("quality"))
+            .define_method("set_sub_type", &QImageWriter::setSubType, Arg("type"))
+            .define_method("set_text", &QImageWriter::setText, Arg("key"), Arg("text"))
+            .define_method("set_transformation", &QImageWriter::setTransformation, Arg("orientation"))
+            .define_method("sub_type", &QImageWriter::subType)
+            .define_method("supported_sub_types", &QImageWriter::supportedSubTypes)
+            .define_method("supports_option", &QImageWriter::supportsOption, Arg("option"))
+            .define_method("transformation", &QImageWriter::transformation)
+            .define_method("write", &QImageWriter::write, Arg("image"))
+            // Static Public Members
+            .define_singleton_function("image_formats_for_mime_type", &QImageWriter::imageFormatsForMimeType, Arg("mime_type"))
+            .define_singleton_function("supported_image_formats", &QImageWriter::supportedImageFormats)
+            .define_singleton_function("supported_mime_types", &QImageWriter::supportedMimeTypes);
+
+    Data_Type<QImageWriter::ImageWriterError> rb_cQImageWriterImageWriterError =
+        // RubyQt6::QtGui::QImageWriter::ImageWriterError
+        define_qenum_under<QImageWriter::ImageWriterError>(rb_cQImageWriter, "ImageWriterError");
+        define_qenum_value_under(rb_cQImageWriterImageWriterError, "UnknownError", QImageWriter::ImageWriterError::UnknownError);
+        define_qenum_value_under(rb_cQImageWriterImageWriterError, "DeviceError", QImageWriter::ImageWriterError::DeviceError);
+        define_qenum_value_under(rb_cQImageWriterImageWriterError, "UnsupportedFormatError", QImageWriter::ImageWriterError::UnsupportedFormatError);
+        define_qenum_value_under(rb_cQImageWriterImageWriterError, "InvalidImageError", QImageWriter::ImageWriterError::InvalidImageError);
+}

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

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