ruby-qt6-qtcore 1.0.0

data/lib/qt6/qtcore/qline.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtCore
+    # @see https://doc.qt.io/qt-6/qline.html
+    class QLine
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @return [QLine]
+      #
+      # @overload initialize
+      #
+      # @overload initialize(x1, y1, x2, y2)
+      #   @param x1 [Integer]
+      #   @param y1 [Integer]
+      #   @param x2 [Integer]
+      #   @param y2 [Integer]
+      #
+      # @overload initialize(p1, p2)
+      #   @param p1 [QPoint]
+      #   @param p2 [QPoint]
+      def initialize(*args)
+        case args.size
+        when 4 then _initialize(*args.map(&:to_i))
+        else _initialize(*args)
+        end
+      end
+
+      # @!visibility private
+      def ==(other)
+        return false unless other.is_a?(QtCore::QLine) || other.is_a?(QtCore::QLineF)
+        self.class._operator_equal(self, other)
+      end
+
+      # @!visibility private
+      def inspect
+        T.inspect_struct(self, x1:, y1:, x2:, y2:)
+      end
+    end
+  end
+end

data/lib/qt6/qtcore/qlinef.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtCore
+    # @see https://doc.qt.io/qt-6/qlinef.html
+    class QLineF
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @return [QLineF]
+      #
+      # @overload initialize
+      #
+      # @overload initialize(x1, y1, x2, y2)
+      #   @param x1 [Float]
+      #   @param y1 [Float]
+      #   @param x2 [Float]
+      #   @param y2 [Float]
+      #
+      # @overload initialize(p1, p2)
+      #   @param p1 [QPointF]
+      #   @param p2 [QPointF]
+      #
+      # @overload initialize(line)
+      #   @param line [QLine]
+      def initialize(*args)
+        _initialize(*args)
+      end
+
+      # @!visibility private
+      def ==(other)
+        return false unless other.is_a?(QtCore::QLine) || other.is_a?(QtCore::QLineF)
+        self.class._operator_equal(self, other)
+      end
+
+      # @!visibility private
+      def inspect
+        T.inspect_struct(self, x1:, y1:, x2:, y2:)
+      end
+    end
+  end
+end

data/lib/qt6/qtcore/qlocale.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtCore
+    # @see https://doc.qt.io/qt-6/qlocale.html
+    class QLocale
+      # @!parse class Language                    ; end
+      # @!parse class Script                      ; end
+      # @!parse class Country                     ; end
+      # @!parse class MeasurementSystem           ; end
+      # @!parse class FormatType                  ; end
+      # @!parse class NumberOption                ; end
+      # @!parse class NumberOptions               ; end
+      # @!parse class FloatingPointPrecisionOption; end
+      # @!parse class TagSeparator                ; end
+      # @!parse class CurrencySymbolFormat        ; end
+      # @!parse class DataSizeFormat              ; end
+      # @!parse class DataSizeFormats             ; end
+      # @!parse class LanguageCodeType            ; end
+      # @!parse class LanguageCodeTypes           ; end
+      # @!parse class QuotationStyle              ; end
+      rubyqt6_declare_enum_under QLocale, QLocale::Language
+      rubyqt6_declare_enum_under QLocale, QLocale::Script
+      rubyqt6_declare_enum_under QLocale, QLocale::Country
+      rubyqt6_declare_enum_under QLocale, QLocale::MeasurementSystem
+      rubyqt6_declare_enum_under QLocale, QLocale::FormatType
+      rubyqt6_declare_enum_under QLocale, QLocale::NumberOption
+      rubyqt6_declare_enum_under QLocale, QLocale::FloatingPointPrecisionOption
+      rubyqt6_declare_enum_under QLocale, QLocale::TagSeparator
+      rubyqt6_declare_enum_under QLocale, QLocale::CurrencySymbolFormat
+      rubyqt6_declare_enum_under QLocale, QLocale::DataSizeFormat
+      rubyqt6_declare_enum_under QLocale, QLocale::LanguageCodeType
+      rubyqt6_declare_enum_under QLocale, QLocale::QuotationStyle
+      rubyqt6_declare_qflags QLocale::NumberOptions, QLocale::NumberOption
+      rubyqt6_declare_qflags QLocale::DataSizeFormats, QLocale::DataSizeFormat
+      rubyqt6_declare_qflags QLocale::LanguageCodeTypes, QLocale::LanguageCodeType
+
+      # @!visibility private
+      def inspect
+        T.inspect_struct(self, name: name.to_s)
+      end
+    end
+  end
+end

data/lib/qt6/qtcore/qmargins.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtCore
+    # @see https://doc.qt.io/qt-6/qmargins.html
+    class QMargins
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @return [QMargins]
+      #
+      # @overload initialize
+      #
+      # @overload initialize(left, top, right, bottom)
+      #   @param left [Integer]
+      #   @param top [Integer]
+      #   @param right [Integer]
+      #   @param bottom [Integer]
+      def initialize(*args)
+        case args.size
+        when 4 then _initialize(*args.map(&:to_i))
+        else _initialize(*args)
+        end
+      end
+
+      # @!visibility private
+      def ==(other)
+        return false unless other.is_a?(QtCore::QMargins) || other.is_a?(QtCore::QMarginsF)
+        self.class._operator_equal(self, other)
+      end
+
+      # @!visibility private
+      def inspect
+        T.inspect_struct(self, left:, top:, right:, bottom:)
+      end
+    end
+  end
+end

data/lib/qt6/qtcore/qmarginsf.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtCore
+    # @see https://doc.qt.io/qt-6/qmarginsf.html
+    class QMarginsF
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @return [QMarginsF]
+      #
+      # @overload initialize
+      #
+      # @overload initialize(left, top, right, bottom)
+      #   @param left [Float]
+      #   @param top [Float]
+      #   @param right [Float]
+      #   @param bottom [Float]
+      #
+      # @overload initialize(margins)
+      #   @param margins [QMargins]
+      def initialize(*args)
+        _initialize(*args)
+      end
+
+      # @!visibility private
+      def ==(other)
+        return false unless other.is_a?(QtCore::QMargins) || other.is_a?(QtCore::QMarginsF)
+        self.class._operator_equal(self, other)
+      end
+
+      # @!visibility private
+      def inspect
+        T.inspect_struct(self, left:, top:, right:, bottom:)
+      end
+    end
+  end
+end

data/lib/qt6/qtcore/qmetaclassinfo.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtCore
+    # @see https://doc.qt.io/qt-6/qmetaclassinfo.html
+    class QMetaClassInfo
+      # @!visibility private
+      def inspect
+        T.inspect_struct(self, name: name.to_s, value: value.to_s)
+      end
+    end
+  end
+end

data/lib/qt6/qtcore/qmetamethod.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtCore
+    # @see https://doc.qt.io/qt-6/qmetamethod.html
+    class QMetaMethod
+      # @!parse class Access    ; end
+      # @!parse class Attributes; end
+      # @!parse class MethodType; end
+      rubyqt6_declare_enum_under QMetaMethod, QMetaMethod::Access
+      rubyqt6_declare_enum_under QMetaMethod, QMetaMethod::Attributes
+      rubyqt6_declare_enum_under QMetaMethod, QMetaMethod::MethodType
+
+      # @!visibility private
+      def inspect
+        T.inspect_struct(self, type: method_type.to_s, signature: method_signature.to_s)
+      end
+    end
+  end
+end

data/lib/qt6/qtcore/qmetamethodbuilder.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtCore
+    # @!visibility private
+    class QMetaMethodBuilder
+      def set_return_type(value)
+        _set_return_type(T.to_qbytearray(value))
+      end
+    end
+  end
+end

data/lib/qt6/qtcore/qmetaobject.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtCore
+    # @see https://doc.qt.io/qt-6/qmetaobject.html
+    class QMetaObject
+      # @see https://doc.qt.io/qt-6/qmetaobject-connection.html
+      class Connection
+      end
+    end
+  end
+end

data/lib/qt6/qtcore/qmetaobjectbuilder.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtCore
+    # @!visibility private
+    class QMetaObjectBuilder
+      alias_method :_initialize, :initialize
+
+      def initialize
+        _initialize
+      end
+
+      def add_class_info(name, value)
+        _add_class_info(T.to_qbytearray(name), T.to_qbytearray(value))
+      end
+
+      def add_signal(signature)
+        _add_signal(T.to_qbytearray(signature))
+      end
+
+      def add_slot(signature)
+        _add_slot(T.to_qbytearray(signature))
+      end
+
+      def set_class_name(name)
+        _set_class_name(T.to_qbytearray(name))
+      end
+    end
+  end
+end

data/lib/qt6/qtcore/qmetatype.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtCore
+    # @see https://doc.qt.io/qt-6/qmetatype.html
+    class QMetaType
+      # @!parse class Type; end
+      rubyqt6_declare_enum_under QMetaType, QMetaType::Type
+
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @!visibility private
+      def self.infer(o)
+        k = o.class
+        k.respond_to?(:default_qmetatype) ? k.default_qmetatype : raise("Could not infer qmetatype")
+      end
+
+      # @param type_id [Integer]
+      # @return [QMetaType]
+      def initialize(type_id)
+        _initialize(type_id)
+      end
+
+      # @!visibility private
+      def inspect
+        T.inspect_struct(self, id:, name:)
+      end
+    end
+  end
+end

data/lib/qt6/qtcore/qmodelindex.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtCore
+    # @see https://doc.qt.io/qt-6/qmodelindex.html
+    class QModelIndex
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @return [QModelIndex]
+      def initialize
+        _initialize
+      end
+    end
+  end
+end

data/lib/qt6/qtcore/qobject.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtCore
+    # @see https://doc.qt.io/qt-6/qobject.html
+    class QObject
+      # @!visibility private
+      def self.q_object(&blk)
+        if !name.start_with?("RubyQt6::")
+          if !superclass.name.start_with?("RubyQt6::Bando::")
+            raise "Invalid superclass: macro `q_object` only available for subclass of RubyQt6::Bando::<...>"
+          end
+        end
+
+        mo = QtCore::Private::MetaObject.new(self)
+        mo.instance_exec(&blk)
+
+        metamethods = mo.metamethods.sort_by { |meth| [meth.name, meth.parameters.size] }
+        metamethods.each do |meth|
+          if meth.signal?
+            define_method(meth.name) do
+              QtCore::Private::Signal.new(self, meth)
+            end
+          elsif meth.slot? && mo.ruby?
+            define_method(meth.qsignature_name) do |*args|
+              r = __send__(meth.name, *args.map(&:value))
+              next if meth.return_type.nil?
+
+              qmetatype = QtCore::QMetaType.from_name(meth.return_type)
+              QtCore::QVariant.new(r, qmetatype)
+            end
+          end
+        end
+
+        @_rubyqt6_metaobject = mo
+        define_singleton_method("_rubyqt6_metaobject") do
+          @_rubyqt6_metaobject
+        end
+
+        @_qmetaobject = mo.to_qmetaobject
+        define_singleton_method("_qmetaobject") do
+          @_qmetaobject
+        end
+
+        nil
+      end
+
+      # @!parse
+      q_object do
+        signal "destroyed(QObject*)"
+        signal "destroyed()"
+        signal "objectNameChanged(QString)"
+        slot "deleteLater()"
+      end
+
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @param parent [QObject]
+      # @return [QObject]
+      def initialize(parent = nil)
+        _initialize(parent)
+        _take_ownership_from_ruby(self)
+      end
+
+      # @!visibility private
+      def children
+        _children.map { |child| T.bando_qobject_cast(child) }
+      end
+
+      # @!visibility private
+      def find_child(name, options = nil)
+        options ||= QtCore::Qt::FindChildrenRecursively
+        child = _find_child(T.to_qanystringview(name), T.to_qflags(options))
+        T.bando_qobject_cast(child)
+      end
+
+      # @!visibility private
+      def find_children(name, options = nil)
+        options ||= QtCore::Qt::FindChildrenRecursively
+        children = _find_children(T.to_qanystringview(name), T.to_qflags(options))
+        children.map { |child| T.bando_qobject_cast(child) }
+      end
+
+      # @!visibility private
+      def parent
+        T.bando_qobject_cast(_parent)
+      end
+
+      # @!visibility private
+      def tr(source_text, disambiguation = "", n = -1)
+        context = self.class.name
+        QtCore::QCoreApplication.translate(context, source_text, disambiguation, n)
+      end
+
+      private
+
+      def _take_ownership_from_ruby(object)
+        self.class._take_ownership_from_ruby(object)
+      end
+    end
+  end
+end

data/lib/qt6/qtcore/qpoint.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtCore
+    # @see https://doc.qt.io/qt-6/qpoint.html
+    class QPoint
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @return [QPoint]
+      #
+      # @overload initialize
+      #
+      # @overload initialize(xpos, ypos)
+      #   @param xpos [Integer]
+      #   @param ypos [Integer]
+      def initialize(*args)
+        case args.size
+        when 2 then _initialize(*args.map(&:to_i))
+        else _initialize(*args)
+        end
+      end
+
+      # @!visibility private
+      def ==(other)
+        return false unless other.is_a?(QtCore::QPoint) || other.is_a?(QtCore::QPointF)
+        self.class._operator_equal(self, other)
+      end
+
+      # @!visibility private
+      def inspect
+        T.inspect_struct(self, x:, y:)
+      end
+    end
+  end
+end

data/lib/qt6/qtcore/qpointf.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtCore
+    # @see https://doc.qt.io/qt-6/qpointf.html
+    class QPointF
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @return [QPointF]
+      #
+      # @overload initialize
+      #
+      # @overload initialize(xpos, ypos)
+      #   @param xpos [Float]
+      #   @param ypos [Float]
+      #
+      # @overload initialize(point)
+      #   @param point [QPoint]
+      def initialize(*args)
+        _initialize(*args)
+      end
+
+      # @!visibility private
+      def ==(other)
+        return false unless other.is_a?(QtCore::QPoint) || other.is_a?(QtCore::QPointF)
+        self.class._operator_equal(self, other)
+      end
+
+      # @!visibility private
+      def inspect
+        T.inspect_struct(self, x:, y:)
+      end
+    end
+  end
+end

data/lib/qt6/qtcore/qrect.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtCore
+    # @see https://doc.qt.io/qt-6/qrect.html
+    class QRect
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @return [QRect]
+      #
+      # @overload initialize
+      #
+      # @overload initialize(x, y, width, height)
+      #   @param x [Integer]
+      #   @param y [Integer]
+      #   @param width [Integer]
+      #   @param height [Integer]
+      #
+      # @overload initialize(top_left, bottom_right)
+      #   @param top_left [QPoint]
+      #   @param bottom_right [QPoint]
+      #
+      # @overload initialize(top_left, size)
+      #   @param top_left [QPoint]
+      #   @param size [QSize]
+      def initialize(*args)
+        case args.size
+        when 4 then _initialize(*args.map(&:to_i))
+        else _initialize(*args)
+        end
+      end
+
+      # @!visibility private
+      def ==(other)
+        return false unless other.is_a?(QtCore::QRect) || other.is_a?(QtCore::QRectF)
+        self.class._operator_equal(self, other)
+      end
+
+      # @!visibility private
+      def inspect
+        T.inspect_struct(self, x:, y:, width:, height:)
+      end
+    end
+  end
+end

data/lib/qt6/qtcore/qrectf.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtCore
+    # @see https://doc.qt.io/qt-6/qrectf.html
+    class QRectF
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @return [QRectF]
+      #
+      # @overload initialize
+      #
+      # @overload initialize(x, y, width, height)
+      #   @param x [Float]
+      #   @param y [Float]
+      #   @param width [Float]
+      #   @param height [Float]
+      #
+      # @overload initialize(top_left, bottom_right)
+      #   @param top_left [QPointF]
+      #   @param bottom_right [QPointF]
+      #
+      # @overload initialize(top_left, size)
+      #   @param top_left [QPointF]
+      #   @param size [QSizeF]
+      #
+      # @overload initialize(rect)
+      #   @param rect [QRect]
+      def initialize(*args)
+        _initialize(*args)
+      end
+
+      # @!visibility private
+      def ==(other)
+        return false unless other.is_a?(QtCore::QRect) || other.is_a?(QtCore::QRectF)
+        self.class._operator_equal(self, other)
+      end
+
+      # @!visibility private
+      def inspect
+        T.inspect_struct(self, x:, y:, width:, height:)
+      end
+    end
+  end
+end

data/lib/qt6/qtcore/qregularexpression.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtCore
+    # @see https://doc.qt.io/qt-6/qregularexpression.html
+    class QRegularExpression
+      # @!parse class PatternOption            ; end
+      # @!parse class MatchType                ; end
+      # @!parse class MatchOption              ; end
+      # @!parse class WildcardConversionOption ; end
+      # @!parse class PatternOptions           ; end
+      # @!parse class MatchOptions             ; end
+      # @!parse class WildcardConversionOptions; end
+      rubyqt6_declare_enum_under QRegularExpression, QRegularExpression::PatternOption
+      rubyqt6_declare_enum_under QRegularExpression, QRegularExpression::MatchType
+      rubyqt6_declare_enum_under QRegularExpression, QRegularExpression::MatchOption
+      rubyqt6_declare_enum_under QRegularExpression, QRegularExpression::WildcardConversionOption
+      rubyqt6_declare_qflags QRegularExpression::PatternOptions, QRegularExpression::PatternOption
+      rubyqt6_declare_qflags QRegularExpression::MatchOptions, QRegularExpression::MatchOption
+      rubyqt6_declare_qflags QRegularExpression::WildcardConversionOptions, QRegularExpression::WildcardConversionOption
+
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @param pattern [String, QString]
+      # @param options [QRegularExpression::PatternOptions]
+      # @return [QRegularExpression]
+      def initialize(pattern = "", options = nil)
+        options ||= QRegularExpression::PatternOption::NoPatternOption
+        _initialize(T.to_qstr(pattern), T.to_qflags(options))
+      end
+    end
+  end
+end

data/lib/qt6/qtcore/qregularexpressionmatch.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RubyQt6
+  module QtCore
+    # @see https://doc.qt.io/qt-6/qregularexpressionmatch.html
+    class QRegularExpressionMatch
+      # @!visibility private
+      alias_method :_initialize, :initialize
+
+      # @return [QRegularExpressionMatch]
+      def initialize
+        _initialize
+      end
+    end
+  end
+end