ruby-qt6-qtcore 1.0.0

data/ext/qt6/qtcore/qfile-rb.cpp

@@ -0,0 +1,52 @@
+#include "qfile-rb.hpp"
+#include <qfile.h>
+
+using namespace Rice;
+
+Rice::Class rb_cQFile;
+
+void Init_qfile(Rice::Module rb_mQt6QtCore)
+{
+    rb_cQFile =
+        // RubyQt6::QtCore::QFile
+        define_class_under<QFile, QFileDevice>(rb_mQt6QtCore, "QFile")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QFile::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QFile, const QString &>(), Arg("name"))
+            // Public Functions
+            .define_method<bool (QFile::*)(const QString &)>("copy", &QFile::copy, Arg("new_name"))
+            .define_method<bool (QFile::*)() const>("exists", &QFile::exists)
+            .define_method("file_name", &QFile::fileName)
+            .define_method("filesystem_file_name", &QFile::filesystemFileName)
+            // .define_method("filesystem_sym_link_target", &QFile::filesystemSymLinkTarget)
+            .define_method<bool (QFile::*)(const QString &)>("link", &QFile::link, Arg("new_name"))
+            .define_method<bool (QFile::*)()>("move_to_trash", &QFile::moveToTrash)
+            .define_method<bool (QFile::*)(FILE *, QIODeviceBase::OpenMode, QFileDevice::FileHandleFlags)>("open", &QFile::open, Arg("f"), Arg("io_flags"), Arg("handle_flags") = static_cast<QFileDevice::FileHandleFlags>(QFileDevice::FileHandleFlag::DontCloseHandle))
+            .define_method<bool (QFile::*)(QIODeviceBase::OpenMode)>("open", &QFile::open, Arg("flags"))
+            .define_method<bool (QFile::*)(QIODeviceBase::OpenMode, QFileDevice::Permissions)>("open", &QFile::open, Arg("flags"), Arg("permissions"))
+            .define_method<bool (QFile::*)(int, QIODeviceBase::OpenMode, QFileDevice::FileHandleFlags)>("open", &QFile::open, Arg("fd"), Arg("io_flags"), Arg("handle_flags") = static_cast<QFileDevice::FileHandleFlags>(QFileDevice::FileHandleFlag::DontCloseHandle))
+            .define_method<QFileDevice::Permissions (QFile::*)() const>("permissions", &QFile::permissions)
+            .define_method<bool (QFile::*)()>("remove", &QFile::remove)
+            .define_method<bool (QFile::*)(const QString &)>("rename", &QFile::rename, Arg("new_name"))
+            .define_method<bool (QFile::*)(qint64)>("resize", &QFile::resize, Arg("sz"))
+            .define_method<void (QFile::*)(const QString &)>("set_file_name", &QFile::setFileName, Arg("name"))
+            .define_method<bool (QFile::*)(QFileDevice::Permissions)>("set_permissions", &QFile::setPermissions, Arg("permission_spec"))
+            .define_method("size", &QFile::size)
+            .define_method<QString (QFile::*)() const>("sym_link_target", &QFile::symLinkTarget)
+            // Static Public Members
+            .define_singleton_function<bool (*)(const QString &, const QString &)>("copy", &QFile::copy, Arg("file_name"), Arg("new_name"))
+            .define_singleton_function<QString (*)(const QByteArray &)>("decode_name", &QFile::decodeName, Arg("local_file_name"))
+            .define_singleton_function<QString (*)(const char *)>("decode_name", &QFile::decodeName, Arg("local_file_name"))
+            .define_singleton_function("encode_name", &QFile::encodeName, Arg("file_name"))
+            .define_singleton_function<bool (*)(const QString &)>("exists", &QFile::exists, Arg("file_name"))
+            .define_singleton_function<bool (*)(const QString &, const QString &)>("link", &QFile::link, Arg("file_name"), Arg("new_name"))
+            .define_singleton_function<bool (*)(const QString &, QString *)>("move_to_trash", &QFile::moveToTrash, Arg("file_name"), Arg("path_in_trash") = static_cast<QString *>(nullptr))
+            .define_singleton_function<QFileDevice::Permissions (*)(const QString &)>("permissions", &QFile::permissions, Arg("filename"))
+            .define_singleton_function<bool (*)(const QString &)>("remove", &QFile::remove, Arg("file_name"))
+            .define_singleton_function<bool (*)(const QString &, const QString &)>("rename", &QFile::rename, Arg("old_name"), Arg("new_name"))
+            .define_singleton_function<bool (*)(const QString &, qint64)>("resize", &QFile::resize, Arg("filename"), Arg("sz"))
+            .define_singleton_function<bool (*)(const QString &, QFileDevice::Permissions)>("set_permissions", &QFile::setPermissions, Arg("filename"), Arg("permission_spec"))
+            .define_singleton_function("supports_move_to_trash", &QFile::supportsMoveToTrash)
+            .define_singleton_function<QString (*)(const QString &)>("sym_link_target", &QFile::symLinkTarget, Arg("file_name"));
+}

data/ext/qt6/qtcore/qfile-rb.hpp

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

data/ext/qt6/qtcore/qfiledevice-rb.cpp

@@ -0,0 +1,105 @@
+#include "qfiledevice-rb.hpp"
+#include <qfiledevice.h>
+#include <rice/qt6/qenum.hpp>
+#include <rice/qt6/qflags.hpp>
+
+#include <QDateTime>
+
+using namespace Rice;
+
+Rice::Class rb_cQFileDevice;
+
+void Init_qfiledevice(Rice::Module rb_mQt6QtCore)
+{
+    rb_cQFileDevice =
+        // RubyQt6::QtCore::QFileDevice
+        define_class_under<QFileDevice, QIODevice>(rb_mQt6QtCore, "QFileDevice")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QFileDevice::staticMetaObject; })
+            // Public Functions
+            .define_method("at_end", &QFileDevice::atEnd)
+            .define_method("close", &QFileDevice::close)
+            .define_method("error", &QFileDevice::error)
+            .define_method("file_name", &QFileDevice::fileName)
+            .define_method("file_time", &QFileDevice::fileTime, Arg("time"))
+            .define_method("flush", &QFileDevice::flush)
+            .define_method("handle", &QFileDevice::handle)
+            .define_method("sequential?", &QFileDevice::isSequential)
+            .define_method("map", &QFileDevice::map, Arg("offset"), Arg("size"), Arg("flags") = static_cast<QFileDevice::MemoryMapFlags>(QFileDevice::MemoryMapFlag::NoOptions))
+            .define_method("permissions", &QFileDevice::permissions)
+            .define_method("pos", &QFileDevice::pos)
+            .define_method("resize", &QFileDevice::resize, Arg("sz"))
+            .define_method("seek", &QFileDevice::seek, Arg("offset"))
+            .define_method("set_file_time", &QFileDevice::setFileTime, Arg("new_date"), Arg("file_time"))
+            .define_method("set_permissions", &QFileDevice::setPermissions, Arg("permission_spec"))
+            .define_method("size", &QFileDevice::size)
+            .define_method("unmap", &QFileDevice::unmap, Arg("address"))
+            .define_method("unset_error", &QFileDevice::unsetError);
+
+    Data_Type<QFileDevice::FileError> rb_cQFileDeviceFileError =
+        // RubyQt6::QtCore::QFileDevice::FileError
+        define_qenum_under<QFileDevice::FileError>(rb_cQFileDevice, "FileError");
+        define_qenum_value_under(rb_cQFileDeviceFileError, "NoError", QFileDevice::FileError::NoError);
+        define_qenum_value_under(rb_cQFileDeviceFileError, "ReadError", QFileDevice::FileError::ReadError);
+        define_qenum_value_under(rb_cQFileDeviceFileError, "WriteError", QFileDevice::FileError::WriteError);
+        define_qenum_value_under(rb_cQFileDeviceFileError, "FatalError", QFileDevice::FileError::FatalError);
+        define_qenum_value_under(rb_cQFileDeviceFileError, "ResourceError", QFileDevice::FileError::ResourceError);
+        define_qenum_value_under(rb_cQFileDeviceFileError, "OpenError", QFileDevice::FileError::OpenError);
+        define_qenum_value_under(rb_cQFileDeviceFileError, "AbortError", QFileDevice::FileError::AbortError);
+        define_qenum_value_under(rb_cQFileDeviceFileError, "TimeOutError", QFileDevice::FileError::TimeOutError);
+        define_qenum_value_under(rb_cQFileDeviceFileError, "UnspecifiedError", QFileDevice::FileError::UnspecifiedError);
+        define_qenum_value_under(rb_cQFileDeviceFileError, "RemoveError", QFileDevice::FileError::RemoveError);
+        define_qenum_value_under(rb_cQFileDeviceFileError, "RenameError", QFileDevice::FileError::RenameError);
+        define_qenum_value_under(rb_cQFileDeviceFileError, "PositionError", QFileDevice::FileError::PositionError);
+        define_qenum_value_under(rb_cQFileDeviceFileError, "ResizeError", QFileDevice::FileError::ResizeError);
+        define_qenum_value_under(rb_cQFileDeviceFileError, "PermissionsError", QFileDevice::FileError::PermissionsError);
+        define_qenum_value_under(rb_cQFileDeviceFileError, "CopyError", QFileDevice::FileError::CopyError);
+
+    Data_Type<QFileDevice::FileHandleFlag> rb_cQFileDeviceFileHandleFlag =
+        // RubyQt6::QtCore::QFileDevice::FileHandleFlag
+        define_qenum_under<QFileDevice::FileHandleFlag>(rb_cQFileDevice, "FileHandleFlag");
+        define_qenum_value_under(rb_cQFileDeviceFileHandleFlag, "AutoCloseHandle", QFileDevice::FileHandleFlag::AutoCloseHandle);
+        define_qenum_value_under(rb_cQFileDeviceFileHandleFlag, "DontCloseHandle", QFileDevice::FileHandleFlag::DontCloseHandle);
+
+    Data_Type<QFileDevice::FileTime> rb_cQFileDeviceFileTime =
+        // RubyQt6::QtCore::QFileDevice::FileTime
+        define_qenum_under<QFileDevice::FileTime>(rb_cQFileDevice, "FileTime");
+        define_qenum_value_under(rb_cQFileDeviceFileTime, "FileAccessTime", QFileDevice::FileTime::FileAccessTime);
+        define_qenum_value_under(rb_cQFileDeviceFileTime, "FileBirthTime", QFileDevice::FileTime::FileBirthTime);
+        define_qenum_value_under(rb_cQFileDeviceFileTime, "FileMetadataChangeTime", QFileDevice::FileTime::FileMetadataChangeTime);
+        define_qenum_value_under(rb_cQFileDeviceFileTime, "FileModificationTime", QFileDevice::FileTime::FileModificationTime);
+
+    Data_Type<QFileDevice::MemoryMapFlag> rb_cQFileDeviceMemoryMapFlag =
+        // RubyQt6::QtCore::QFileDevice::MemoryMapFlag
+        define_qenum_under<QFileDevice::MemoryMapFlag>(rb_cQFileDevice, "MemoryMapFlag");
+        define_qenum_value_under(rb_cQFileDeviceMemoryMapFlag, "NoOptions", QFileDevice::MemoryMapFlag::NoOptions);
+        define_qenum_value_under(rb_cQFileDeviceMemoryMapFlag, "MapPrivateOption", QFileDevice::MemoryMapFlag::MapPrivateOption);
+
+    Data_Type<QFileDevice::Permission> rb_cQFileDevicePermission =
+        // RubyQt6::QtCore::QFileDevice::Permission
+        define_qenum_under<QFileDevice::Permission>(rb_cQFileDevice, "Permission");
+        define_qenum_value_under(rb_cQFileDevicePermission, "ReadOwner", QFileDevice::Permission::ReadOwner);
+        define_qenum_value_under(rb_cQFileDevicePermission, "WriteOwner", QFileDevice::Permission::WriteOwner);
+        define_qenum_value_under(rb_cQFileDevicePermission, "ExeOwner", QFileDevice::Permission::ExeOwner);
+        define_qenum_value_under(rb_cQFileDevicePermission, "ReadUser", QFileDevice::Permission::ReadUser);
+        define_qenum_value_under(rb_cQFileDevicePermission, "WriteUser", QFileDevice::Permission::WriteUser);
+        define_qenum_value_under(rb_cQFileDevicePermission, "ExeUser", QFileDevice::Permission::ExeUser);
+        define_qenum_value_under(rb_cQFileDevicePermission, "ReadGroup", QFileDevice::Permission::ReadGroup);
+        define_qenum_value_under(rb_cQFileDevicePermission, "WriteGroup", QFileDevice::Permission::WriteGroup);
+        define_qenum_value_under(rb_cQFileDevicePermission, "ExeGroup", QFileDevice::Permission::ExeGroup);
+        define_qenum_value_under(rb_cQFileDevicePermission, "ReadOther", QFileDevice::Permission::ReadOther);
+        define_qenum_value_under(rb_cQFileDevicePermission, "WriteOther", QFileDevice::Permission::WriteOther);
+        define_qenum_value_under(rb_cQFileDevicePermission, "ExeOther", QFileDevice::Permission::ExeOther);
+
+    Data_Type<QFlags<QFileDevice::FileHandleFlag>> rb_cQFileDeviceFileHandleFlags =
+        // RubyQt6::QtCore::QFileDevice::FileHandleFlags
+        define_qflags_under<QFileDevice::FileHandleFlag>(rb_cQFileDevice, "FileHandleFlags");
+
+    Data_Type<QFlags<QFileDevice::MemoryMapFlag>> rb_cQFileDeviceMemoryMapFlags =
+        // RubyQt6::QtCore::QFileDevice::MemoryMapFlags
+        define_qflags_under<QFileDevice::MemoryMapFlag>(rb_cQFileDevice, "MemoryMapFlags");
+
+    Data_Type<QFlags<QFileDevice::Permission>> rb_cQFileDevicePermissions =
+        // RubyQt6::QtCore::QFileDevice::Permissions
+        define_qflags_under<QFileDevice::Permission>(rb_cQFileDevice, "Permissions");
+}

data/ext/qt6/qtcore/qfiledevice-rb.hpp

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

data/ext/qt6/qtcore/qfileinfo-rb.cpp

@@ -0,0 +1,92 @@
+#include "qfileinfo-rb.hpp"
+#include <qfileinfo.h>
+
+#include <QDir>
+#include <QFileDevice>
+
+using namespace Rice;
+
+Rice::Class rb_cQFileInfo;
+
+void Init_qfileinfo(Rice::Module rb_mQt6QtCore)
+{
+    rb_cQFileInfo =
+        // RubyQt6::QtCore::QFileInfo
+        define_class_under<QFileInfo>(rb_mQt6QtCore, "QFileInfo")
+            // Constructor
+            .define_constructor(Constructor<QFileInfo>())
+            .define_constructor(Constructor<QFileInfo, const QString &>(), Arg("file"))
+            .define_constructor(Constructor<QFileInfo, const QFileDevice &>(), Arg("file"))
+            .define_constructor(Constructor<QFileInfo, const QDir &, const QString &>(), Arg("dir"), Arg("file"))
+            // Public Functions
+            .define_method("absolute_dir", &QFileInfo::absoluteDir)
+            .define_method("absolute_file_path", &QFileInfo::absoluteFilePath)
+            .define_method("absolute_path", &QFileInfo::absolutePath)
+            .define_method("base_name", &QFileInfo::baseName)
+            .define_method<QDateTime (QFileInfo::*)() const>("birth_time", &QFileInfo::birthTime)
+            .define_method<QDateTime (QFileInfo::*)(const QTimeZone &) const>("birth_time", &QFileInfo::birthTime, Arg("tz"))
+            .define_method("bundle_name", &QFileInfo::bundleName)
+            .define_method("caching", &QFileInfo::caching)
+            .define_method("canonical_file_path", &QFileInfo::canonicalFilePath)
+            .define_method("canonical_path", &QFileInfo::canonicalPath)
+            .define_method("complete_base_name", &QFileInfo::completeBaseName)
+            .define_method("complete_suffix", &QFileInfo::completeSuffix)
+            .define_method("dir", &QFileInfo::dir)
+            .define_method<bool (QFileInfo::*)() const>("exists", &QFileInfo::exists)
+            .define_method("file_name", &QFileInfo::fileName)
+            .define_method("file_path", &QFileInfo::filePath)
+            .define_method<QDateTime (QFileInfo::*)(QFileDevice::FileTime) const>("file_time", &QFileInfo::fileTime, Arg("time"))
+            .define_method<QDateTime (QFileInfo::*)(QFileDevice::FileTime, const QTimeZone &) const>("file_time", &QFileInfo::fileTime, Arg("time"), Arg("tz"))
+            .define_method("filesystem_absolute_file_path", &QFileInfo::filesystemAbsoluteFilePath)
+            .define_method("filesystem_absolute_path", &QFileInfo::filesystemAbsolutePath)
+            .define_method("filesystem_canonical_file_path", &QFileInfo::filesystemCanonicalFilePath)
+            .define_method("filesystem_canonical_path", &QFileInfo::filesystemCanonicalPath)
+            .define_method("filesystem_file_path", &QFileInfo::filesystemFilePath)
+            .define_method("filesystem_junction_target", &QFileInfo::filesystemJunctionTarget)
+            .define_method("filesystem_path", &QFileInfo::filesystemPath)
+            .define_method("filesystem_read_sym_link", &QFileInfo::filesystemReadSymLink)
+            .define_method("filesystem_sym_link_target", &QFileInfo::filesystemSymLinkTarget)
+            .define_method("group", &QFileInfo::group)
+            .define_method("group_id", &QFileInfo::groupId)
+            .define_method("absolute?", &QFileInfo::isAbsolute)
+            .define_method("alias?", &QFileInfo::isAlias)
+            .define_method("bundle?", &QFileInfo::isBundle)
+            .define_method("dir?", &QFileInfo::isDir)
+            .define_method("executable?", &QFileInfo::isExecutable)
+            .define_method("file?", &QFileInfo::isFile)
+            .define_method("hidden?", &QFileInfo::isHidden)
+            .define_method("junction?", &QFileInfo::isJunction)
+            .define_method("native_path?", &QFileInfo::isNativePath)
+            .define_method("readable?", &QFileInfo::isReadable)
+            .define_method("relative?", &QFileInfo::isRelative)
+            .define_method("root?", &QFileInfo::isRoot)
+            .define_method("shortcut?", &QFileInfo::isShortcut)
+            .define_method("sym_link?", &QFileInfo::isSymLink)
+            .define_method("symbolic_link?", &QFileInfo::isSymbolicLink)
+            .define_method("writable?", &QFileInfo::isWritable)
+            .define_method("junction_target", &QFileInfo::junctionTarget)
+            .define_method<QDateTime (QFileInfo::*)() const>("last_modified", &QFileInfo::lastModified)
+            .define_method<QDateTime (QFileInfo::*)(const QTimeZone &) const>("last_modified", &QFileInfo::lastModified, Arg("tz"))
+            .define_method<QDateTime (QFileInfo::*)() const>("last_read", &QFileInfo::lastRead)
+            .define_method<QDateTime (QFileInfo::*)(const QTimeZone &) const>("last_read", &QFileInfo::lastRead, Arg("tz"))
+            .define_method("make_absolute", &QFileInfo::makeAbsolute)
+            .define_method<QDateTime (QFileInfo::*)() const>("metadata_change_time", &QFileInfo::metadataChangeTime)
+            .define_method<QDateTime (QFileInfo::*)(const QTimeZone &) const>("metadata_change_time", &QFileInfo::metadataChangeTime, Arg("tz"))
+            .define_method("owner", &QFileInfo::owner)
+            .define_method("owner_id", &QFileInfo::ownerId)
+            .define_method("path", &QFileInfo::path)
+            .define_method("permission", &QFileInfo::permission, Arg("permissions"))
+            .define_method("permissions", &QFileInfo::permissions)
+            .define_method("read_sym_link", &QFileInfo::readSymLink)
+            .define_method("refresh", &QFileInfo::refresh)
+            .define_method("set_caching", &QFileInfo::setCaching, Arg("on"))
+            .define_method<void (QFileInfo::*)(const QDir &, const QString &)>("set_file", &QFileInfo::setFile, Arg("dir"), Arg("file"))
+            .define_method<void (QFileInfo::*)(const QFileDevice &)>("set_file", &QFileInfo::setFile, Arg("file"))
+            .define_method<void (QFileInfo::*)(const QString &)>("set_file", &QFileInfo::setFile, Arg("file"))
+            .define_method("size", &QFileInfo::size)
+            .define_method("stat", &QFileInfo::stat)
+            .define_method("suffix", &QFileInfo::suffix)
+            .define_method("sym_link_target", &QFileInfo::symLinkTarget)
+            // Static Public Members
+            .define_singleton_function<bool (*)(const QString &)>("exists", &QFileInfo::exists, Arg("file"));
+}

data/ext/qt6/qtcore/qfileinfo-rb.hpp

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

data/ext/qt6/qtcore/qiodevice-rb.cpp

@@ -0,0 +1,71 @@
+#include "qiodevice-rb.hpp"
+#include <qiodevice.h>
+
+using namespace Rice;
+
+Rice::Class rb_cQIODevice;
+
+void Init_qiodevice(Rice::Module rb_mQt6QtCore)
+{
+    rb_cQIODevice =
+        // RubyQt6::QtCore::QIODevice
+        define_class_under<QIODevice, QObject>(rb_mQt6QtCore, "QIODevice")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QIODevice::staticMetaObject; })
+            // Public Functions
+            .define_method("at_end", &QIODevice::atEnd)
+            .define_method("bytes_available", &QIODevice::bytesAvailable)
+            .define_method("bytes_to_write", &QIODevice::bytesToWrite)
+            .define_method("can_read_line", &QIODevice::canReadLine)
+            .define_method("close", &QIODevice::close)
+            .define_method("commit_transaction", &QIODevice::commitTransaction)
+            .define_method("current_read_channel", &QIODevice::currentReadChannel)
+            .define_method("current_write_channel", &QIODevice::currentWriteChannel)
+            .define_method("error_string", &QIODevice::errorString)
+            .define_method("get_char", &QIODevice::getChar, Arg("c"))
+            .define_method("open?", &QIODevice::isOpen)
+            .define_method("readable?", &QIODevice::isReadable)
+            .define_method("sequential?", &QIODevice::isSequential)
+            .define_method("text_mode_enabled?", &QIODevice::isTextModeEnabled)
+            .define_method("transaction_started?", &QIODevice::isTransactionStarted)
+            .define_method("writable?", &QIODevice::isWritable)
+            .define_method("open", &QIODevice::open, Arg("mode"))
+            .define_method("open_mode", &QIODevice::openMode)
+            .define_method<QByteArray (QIODevice::*)(qint64)>("peek", &QIODevice::peek, Arg("maxlen"))
+            .define_method<qint64 (QIODevice::*)(char *, qint64)>("peek", &QIODevice::peek, Arg("data"), Arg("maxlen"))
+            .define_method("pos", &QIODevice::pos)
+            .define_method("put_char", &QIODevice::putChar, Arg("c"))
+            .define_method<QByteArray (QIODevice::*)(qint64)>("read", &QIODevice::read, Arg("maxlen"))
+            .define_method<qint64 (QIODevice::*)(char *, qint64)>("read", &QIODevice::read, Arg("data"), Arg("maxlen"))
+            .define_method("read_all", &QIODevice::readAll)
+            .define_method("read_channel_count", &QIODevice::readChannelCount)
+            .define_method<QByteArray (QIODevice::*)(qint64)>("read_line", &QIODevice::readLine, Arg("maxlen") = static_cast<qint64>(0))
+            .define_method<qint64 (QIODevice::*)(char *, qint64)>("read_line", &QIODevice::readLine, Arg("data"), Arg("maxlen"))
+            .define_method<QByteArrayView (QIODevice::*)(QSpan<char>)>("read_line_into", &QIODevice::readLineInto, Arg("buffer"))
+            .define_method<QByteArrayView (QIODevice::*)(QSpan<std::byte>)>("read_line_into", &QIODevice::readLineInto, Arg("buffer"))
+            .define_method<QByteArrayView (QIODevice::*)(QSpan<uchar>)>("read_line_into", &QIODevice::readLineInto, Arg("buffer"))
+            .define_method<bool (QIODevice::*)(QByteArray *, qint64)>("read_line_into", &QIODevice::readLineInto, Arg("result"), Arg("maxlen") = static_cast<qint64>(0))
+            .define_method("reset", &QIODevice::reset)
+            .define_method("rollback_transaction", &QIODevice::rollbackTransaction)
+            .define_method("seek", &QIODevice::seek, Arg("pos"))
+            .define_method("set_current_read_channel", &QIODevice::setCurrentReadChannel, Arg("channel"))
+            .define_method("set_current_write_channel", &QIODevice::setCurrentWriteChannel, Arg("channel"))
+            .define_method("set_text_mode_enabled", &QIODevice::setTextModeEnabled, Arg("enabled"))
+            .define_method("size", &QIODevice::size)
+            .define_method("skip", &QIODevice::skip, Arg("max_size"))
+            .define_method("start_transaction", &QIODevice::startTransaction)
+            .define_method("unget_char", &QIODevice::ungetChar, Arg("c"))
+            .define_method("wait_for_bytes_written", &QIODevice::waitForBytesWritten, Arg("msecs"))
+            .define_method("wait_for_ready_read", &QIODevice::waitForReadyRead, Arg("msecs"))
+            .define_method<qint64 (QIODevice::*)(const QByteArray &)>("write", &QIODevice::write, Arg("data"))
+            .define_method<qint64 (QIODevice::*)(const char *)>("write", &QIODevice::write, Arg("data"))
+            .define_method<qint64 (QIODevice::*)(const char *, qint64)>("write", &QIODevice::write, Arg("data"), Arg("len"))
+            .define_method("write_channel_count", &QIODevice::writeChannelCount)
+            // Signals
+            .define_method("about_to_close", &QIODevice::aboutToClose)
+            .define_method("bytes_written", &QIODevice::bytesWritten, Arg("bytes"))
+            .define_method("channel_bytes_written", &QIODevice::channelBytesWritten, Arg("channel"), Arg("bytes"))
+            .define_method("channel_ready_read", &QIODevice::channelReadyRead, Arg("channel"))
+            .define_method("read_channel_finished", &QIODevice::readChannelFinished)
+            .define_method("ready_read", &QIODevice::readyRead);
+}

data/ext/qt6/qtcore/qiodevice-rb.hpp

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

data/ext/qt6/qtcore/qiodevicebase-rb.cpp

@@ -0,0 +1,33 @@
+#include "qiodevicebase-rb.hpp"
+#include <qiodevicebase.h>
+#include <rice/qt6/qenum.hpp>
+#include <rice/qt6/qflags.hpp>
+
+using namespace Rice;
+
+Rice::Class rb_cQIODeviceBase;
+
+void Init_qiodevicebase(Rice::Module rb_mQt6QtCore)
+{
+    rb_cQIODeviceBase =
+        // RubyQt6::QtCore::QIODeviceBase
+        define_class_under<QIODeviceBase>(rb_mQt6QtCore, "QIODeviceBase");
+
+    Data_Type<QIODeviceBase::OpenModeFlag> rb_cQIODeviceBaseOpenModeFlag =
+        // RubyQt6::QtCore::QIODeviceBase::OpenModeFlag
+        define_qenum_under<QIODeviceBase::OpenModeFlag>(rb_cQIODeviceBase, "OpenModeFlag");
+        define_qenum_value_under(rb_cQIODeviceBaseOpenModeFlag, "NotOpen", QIODeviceBase::OpenModeFlag::NotOpen);
+        define_qenum_value_under(rb_cQIODeviceBaseOpenModeFlag, "ReadOnly", QIODeviceBase::OpenModeFlag::ReadOnly);
+        define_qenum_value_under(rb_cQIODeviceBaseOpenModeFlag, "WriteOnly", QIODeviceBase::OpenModeFlag::WriteOnly);
+        define_qenum_value_under(rb_cQIODeviceBaseOpenModeFlag, "ReadWrite", QIODeviceBase::OpenModeFlag::ReadWrite);
+        define_qenum_value_under(rb_cQIODeviceBaseOpenModeFlag, "Append", QIODeviceBase::OpenModeFlag::Append);
+        define_qenum_value_under(rb_cQIODeviceBaseOpenModeFlag, "Truncate", QIODeviceBase::OpenModeFlag::Truncate);
+        define_qenum_value_under(rb_cQIODeviceBaseOpenModeFlag, "Text", QIODeviceBase::OpenModeFlag::Text);
+        define_qenum_value_under(rb_cQIODeviceBaseOpenModeFlag, "Unbuffered", QIODeviceBase::OpenModeFlag::Unbuffered);
+        define_qenum_value_under(rb_cQIODeviceBaseOpenModeFlag, "NewOnly", QIODeviceBase::OpenModeFlag::NewOnly);
+        define_qenum_value_under(rb_cQIODeviceBaseOpenModeFlag, "ExistingOnly", QIODeviceBase::OpenModeFlag::ExistingOnly);
+
+    Data_Type<QFlags<QIODeviceBase::OpenModeFlag>> rb_cQIODeviceBaseOpenMode =
+        // RubyQt6::QtCore::QIODeviceBase::OpenMode
+        define_qflags_under<QIODeviceBase::OpenModeFlag>(rb_cQIODeviceBase, "OpenMode");
+}

data/ext/qt6/qtcore/qiodevicebase-rb.hpp

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

data/ext/qt6/qtcore/qitemselection-rb.cpp

@@ -0,0 +1,51 @@
+#include "qitemselection-rb.hpp"
+#include <qitemselectionmodel.h>
+
+using namespace Rice;
+
+Rice::Class rb_cQItemSelectionRange;
+Rice::Class rb_cQItemSelection;
+
+void Init_qitemselection(Rice::Module rb_mQt6QtCore)
+{
+    rb_cQItemSelectionRange =
+        // RubyQt6::QtCore::QItemSelectionRange
+        define_class_under<QItemSelectionRange>(rb_mQt6QtCore, "QItemSelectionRange")
+            // Constructor
+            .define_constructor(Constructor<QItemSelectionRange>())
+            .define_constructor(Constructor<QItemSelectionRange, const QModelIndex &>(), Arg("index"))
+            .define_constructor(Constructor<QItemSelectionRange, const QModelIndex &, const QModelIndex &>(), Arg("top_left"), Arg("bottom_right"))
+            // Public Functions
+            .define_method("bottom", &QItemSelectionRange::bottom)
+            .define_method("bottom_right", &QItemSelectionRange::bottomRight)
+            .define_method<bool (QItemSelectionRange::*)(const QModelIndex &) const>("contains", &QItemSelectionRange::contains, Arg("index"))
+            .define_method<bool (QItemSelectionRange::*)(int, int, const QModelIndex &) const>("contains", &QItemSelectionRange::contains, Arg("row"), Arg("column"), Arg("parent_index"))
+            .define_method("height", &QItemSelectionRange::height)
+            .define_method("indexes", &QItemSelectionRange::indexes)
+            .define_method("intersected", &QItemSelectionRange::intersected, Arg("other"))
+            .define_method("intersects", &QItemSelectionRange::intersects, Arg("other"))
+            .define_method("empty?", &QItemSelectionRange::isEmpty)
+            .define_method("valid?", &QItemSelectionRange::isValid)
+            .define_method("left", &QItemSelectionRange::left)
+            .define_method("model", &QItemSelectionRange::model)
+            .define_method("parent", &QItemSelectionRange::parent)
+            .define_method("right", &QItemSelectionRange::right)
+            .define_method("top", &QItemSelectionRange::top)
+            .define_method("top_left", &QItemSelectionRange::topLeft)
+            .define_method("width", &QItemSelectionRange::width);
+
+    rb_cQItemSelection =
+        // RubyQt6::QtCore::QItemSelection
+        define_class_under<QItemSelection, QList<QItemSelectionRange>>(rb_mQt6QtCore, "QItemSelection")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_qvariant_register_metatype", []() -> int { return qRegisterMetaType<QItemSelection>(); })
+            .define_singleton_function("_qvariant_from_value", [](const QItemSelection &value) -> QVariant { return QVariant::fromValue(value); })
+            .define_singleton_function("_qvariant_to_value", [](const QVariant &qvariant) -> QItemSelection { return qvariant.value<QItemSelection>(); })
+            // Public Functions
+            .define_method("contains", &QItemSelection::contains, Arg("index"))
+            .define_method("indexes", &QItemSelection::indexes)
+            .define_method("merge", &QItemSelection::merge, Arg("other"), Arg("command"))
+            .define_method("select", &QItemSelection::select, Arg("top_left"), Arg("bottom_right"))
+            // Static Public Members
+            .define_singleton_function("split", &QItemSelection::split, Arg("range"), Arg("other"), Arg("result"));
+ }

data/ext/qt6/qtcore/qitemselection-rb.hpp

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

data/ext/qt6/qtcore/qitemselectionmodel-rb.cpp

@@ -0,0 +1,70 @@
+#include "qitemselectionmodel-rb.hpp"
+#include <qitemselectionmodel.h>
+#include <rice/qt6/qenum.hpp>
+#include <rice/qt6/qflags.hpp>
+
+#include <QBindable>
+
+using namespace Rice;
+
+Rice::Class rb_cQItemSelectionModel;
+
+void Init_qitemselectionmodel(Rice::Module rb_mQt6QtCore)
+{
+    rb_cQItemSelectionModel =
+        // RubyQt6::QtCore::QItemSelectionModel
+        define_class_under<QItemSelectionModel, QObject>(rb_mQt6QtCore, "QItemSelectionModel")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QItemSelectionModel::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QItemSelectionModel, QAbstractItemModel *, QObject *>(), Arg("model"), Arg("parent"))
+            // Public Functions
+            .define_method("bindable_model", &QItemSelectionModel::bindableModel)
+            .define_method("column_intersects_selection", &QItemSelectionModel::columnIntersectsSelection, Arg("column"), Arg("parent") = static_cast<const QModelIndex &>(QModelIndex()))
+            .define_method("current_index", &QItemSelectionModel::currentIndex)
+            .define_method("has_selection", &QItemSelectionModel::hasSelection)
+            .define_method("column_selected?", &QItemSelectionModel::isColumnSelected, Arg("column"), Arg("parent") = static_cast<const QModelIndex &>(QModelIndex()))
+            .define_method("row_selected?", &QItemSelectionModel::isRowSelected, Arg("row"), Arg("parent") = static_cast<const QModelIndex &>(QModelIndex()))
+            .define_method("selected?", &QItemSelectionModel::isSelected, Arg("index"))
+            .define_method<QAbstractItemModel *(QItemSelectionModel::*)()>("model", &QItemSelectionModel::model)
+            .define_method<const QAbstractItemModel *(QItemSelectionModel::*)() const>("model", &QItemSelectionModel::model)
+            .define_method("row_intersects_selection", &QItemSelectionModel::rowIntersectsSelection, Arg("row"), Arg("parent") = static_cast<const QModelIndex &>(QModelIndex()))
+            .define_method("selected_columns", &QItemSelectionModel::selectedColumns, Arg("row") = static_cast<int>(0))
+            .define_method("selected_indexes", &QItemSelectionModel::selectedIndexes)
+            .define_method("selected_rows", &QItemSelectionModel::selectedRows, Arg("column") = static_cast<int>(0))
+            .define_method("selection", &QItemSelectionModel::selection)
+            .define_method("set_model", &QItemSelectionModel::setModel, Arg("model"))
+            // Public Slots
+            .define_method("clear", &QItemSelectionModel::clear)
+            .define_method("clear_current_index", &QItemSelectionModel::clearCurrentIndex)
+            .define_method("clear_selection", &QItemSelectionModel::clearSelection)
+            .define_method("reset", &QItemSelectionModel::reset)
+            .define_method<void (QItemSelectionModel::*)(const QItemSelection &, QItemSelectionModel::SelectionFlags)>("select", &QItemSelectionModel::select, Arg("selection"), Arg("command"))
+            .define_method<void (QItemSelectionModel::*)(const QModelIndex &, QItemSelectionModel::SelectionFlags)>("select", &QItemSelectionModel::select, Arg("index"), Arg("command"))
+            .define_method("set_current_index", &QItemSelectionModel::setCurrentIndex, Arg("index"), Arg("command"))
+            // Signals
+            .define_method("current_changed", &QItemSelectionModel::currentChanged, Arg("current"), Arg("previous"))
+            .define_method("current_column_changed", &QItemSelectionModel::currentColumnChanged, Arg("current"), Arg("previous"))
+            .define_method("current_row_changed", &QItemSelectionModel::currentRowChanged, Arg("current"), Arg("previous"))
+            .define_method("model_changed", &QItemSelectionModel::modelChanged, Arg("model"))
+            .define_method("selection_changed", &QItemSelectionModel::selectionChanged, Arg("selected"), Arg("deselected"));
+
+    Data_Type<QItemSelectionModel::SelectionFlag> rb_cQItemSelectionModelSelectionFlag =
+        // RubyQt6::QtCore::QItemSelectionModel::SelectionFlag
+        define_qenum_under<QItemSelectionModel::SelectionFlag>(rb_cQItemSelectionModel, "SelectionFlag");
+        define_qenum_value_under(rb_cQItemSelectionModelSelectionFlag, "NoUpdate", QItemSelectionModel::SelectionFlag::NoUpdate);
+        define_qenum_value_under(rb_cQItemSelectionModelSelectionFlag, "Clear", QItemSelectionModel::SelectionFlag::Clear);
+        define_qenum_value_under(rb_cQItemSelectionModelSelectionFlag, "Select", QItemSelectionModel::SelectionFlag::Select);
+        define_qenum_value_under(rb_cQItemSelectionModelSelectionFlag, "Deselect", QItemSelectionModel::SelectionFlag::Deselect);
+        define_qenum_value_under(rb_cQItemSelectionModelSelectionFlag, "Toggle", QItemSelectionModel::SelectionFlag::Toggle);
+        define_qenum_value_under(rb_cQItemSelectionModelSelectionFlag, "Current", QItemSelectionModel::SelectionFlag::Current);
+        define_qenum_value_under(rb_cQItemSelectionModelSelectionFlag, "Rows", QItemSelectionModel::SelectionFlag::Rows);
+        define_qenum_value_under(rb_cQItemSelectionModelSelectionFlag, "Columns", QItemSelectionModel::SelectionFlag::Columns);
+        define_qenum_value_under(rb_cQItemSelectionModelSelectionFlag, "SelectCurrent", QItemSelectionModel::SelectionFlag::SelectCurrent);
+        define_qenum_value_under(rb_cQItemSelectionModelSelectionFlag, "ToggleCurrent", QItemSelectionModel::SelectionFlag::ToggleCurrent);
+        define_qenum_value_under(rb_cQItemSelectionModelSelectionFlag, "ClearAndSelect", QItemSelectionModel::SelectionFlag::ClearAndSelect);
+
+    Data_Type<QFlags<QItemSelectionModel::SelectionFlag>> rb_cQItemSelectionModelSelectionFlags =
+        // RubyQt6::QtCore::QItemSelectionModel::SelectionFlags
+        define_qflags_under<QItemSelectionModel::SelectionFlag>(rb_cQItemSelectionModel, "SelectionFlags");
+ }

data/ext/qt6/qtcore/qitemselectionmodel-rb.hpp

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

data/ext/qt6/qtcore/qlibraryinfo-rb.cpp

@@ -0,0 +1,36 @@
+#include "qlibraryinfo-rb.hpp"
+#include <qlibraryinfo.h>
+#include <rice/qt6/qenum.hpp>
+
+using namespace Rice;
+
+Rice::Class rb_cQLibraryInfo;
+
+void Init_qlibraryinfo(Rice::Module rb_mQt6QtCore)
+{
+    rb_cQLibraryInfo =
+        // RubyQt6::QtCore::QLibraryInfo
+        define_class_under<QLibraryInfo>(rb_mQt6QtCore, "QLibraryInfo")
+            // Static Public Members
+            .define_singleton_function("path", &QLibraryInfo::path, Arg("p"))
+            .define_singleton_function("paths", &QLibraryInfo::paths, Arg("p"));
+
+    Data_Type<QLibraryInfo::LibraryPath> rb_cQLibraryInfoLibraryPath =
+        // RubyQt6::QtCore::QLibraryInfo::LibraryPath
+        define_qenum_under<QLibraryInfo::LibraryPath>(rb_cQLibraryInfo, "LibraryPath");
+        define_qenum_value_under(rb_cQLibraryInfoLibraryPath, "PrefixPath", QLibraryInfo::LibraryPath::PrefixPath);
+        define_qenum_value_under(rb_cQLibraryInfoLibraryPath, "DocumentationPath", QLibraryInfo::LibraryPath::DocumentationPath);
+        define_qenum_value_under(rb_cQLibraryInfoLibraryPath, "HeadersPath", QLibraryInfo::LibraryPath::HeadersPath);
+        define_qenum_value_under(rb_cQLibraryInfoLibraryPath, "LibrariesPath", QLibraryInfo::LibraryPath::LibrariesPath);
+        define_qenum_value_under(rb_cQLibraryInfoLibraryPath, "LibraryExecutablesPath", QLibraryInfo::LibraryPath::LibraryExecutablesPath);
+        define_qenum_value_under(rb_cQLibraryInfoLibraryPath, "BinariesPath", QLibraryInfo::LibraryPath::BinariesPath);
+        define_qenum_value_under(rb_cQLibraryInfoLibraryPath, "PluginsPath", QLibraryInfo::LibraryPath::PluginsPath);
+        define_qenum_value_under(rb_cQLibraryInfoLibraryPath, "QmlImportsPath", QLibraryInfo::LibraryPath::QmlImportsPath);
+        define_qenum_value_under(rb_cQLibraryInfoLibraryPath, "Qml2ImportsPath", QLibraryInfo::LibraryPath::Qml2ImportsPath);
+        define_qenum_value_under(rb_cQLibraryInfoLibraryPath, "ArchDataPath", QLibraryInfo::LibraryPath::ArchDataPath);
+        define_qenum_value_under(rb_cQLibraryInfoLibraryPath, "DataPath", QLibraryInfo::LibraryPath::DataPath);
+        define_qenum_value_under(rb_cQLibraryInfoLibraryPath, "TranslationsPath", QLibraryInfo::LibraryPath::TranslationsPath);
+        define_qenum_value_under(rb_cQLibraryInfoLibraryPath, "ExamplesPath", QLibraryInfo::LibraryPath::ExamplesPath);
+        define_qenum_value_under(rb_cQLibraryInfoLibraryPath, "TestsPath", QLibraryInfo::LibraryPath::TestsPath);
+        define_qenum_value_under(rb_cQLibraryInfoLibraryPath, "SettingsPath", QLibraryInfo::LibraryPath::SettingsPath);
+}

data/ext/qt6/qtcore/qlibraryinfo-rb.hpp

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