From c7ec242b8b5b2c140864770712f41770ecac5757 Mon Sep 17 00:00:00 2001 From: Matthias Koefferlein Date: Sat, 19 Oct 2024 20:32:45 +0200 Subject: [PATCH 1/4] C++ parser for Qt binding generation now recognizes global operators inlined as friends --- scripts/mkqtdecl_common/c++.treetop | 8 ++--- scripts/mkqtdecl_common/cpp_classes.rb | 6 ++-- scripts/mkqtdecl_common/cpp_parser_classes.rb | 5 ++- scripts/mkqtdecl_common/produce.rb | 31 ++++++++++++++++--- 4 files changed, 37 insertions(+), 13 deletions(-) diff --git a/scripts/mkqtdecl_common/c++.treetop b/scripts/mkqtdecl_common/c++.treetop index 2ae2335e52..cbb6aaa4cb 100644 --- a/scripts/mkqtdecl_common/c++.treetop +++ b/scripts/mkqtdecl_common/c++.treetop @@ -183,7 +183,7 @@ grammar CPP ( ":" s block_wo_curly_braces s )? ( trailing_return_type )? a - ( + blk:( "{" s block s "}" / ";"? ) @@ -200,7 +200,7 @@ grammar CPP ( ":" s block_wo_curly_braces s )? ( trailing_return_type )? a - ( + blk:( "{" s block s "}" / ";" ) @@ -436,7 +436,7 @@ grammar CPP s ( ":" s block_wo_curly_braces s )? ( trailing_return_type )? a - ( + blk:( "{" s block s "}" / ";" ) @@ -452,7 +452,7 @@ grammar CPP s ( ":" s block_wo_curly_braces s )? ( trailing_return_type )? a - ( + blk:( "{" s block s "}" / ";"? ) diff --git a/scripts/mkqtdecl_common/cpp_classes.rb b/scripts/mkqtdecl_common/cpp_classes.rb index 05dc3f5433..ad2361137f 100644 --- a/scripts/mkqtdecl_common/cpp_classes.rb +++ b/scripts/mkqtdecl_common/cpp_classes.rb @@ -26,7 +26,7 @@ def initialize_copy(other) # TODO: is there a better way to check whether dup can be used? # Implement Hash? #{args.map { |arg| "a = other.#{arg}\n"+ - "if a.is_a?(TrueClass) || a.is_a?(FalseClass) || a.is_a?(NilClass) || a.is_a?(Fixnum) || a.is_a?(Float) || a.is_a?(Symbol)\n"+ + "if a.is_a?(TrueClass) || a.is_a?(FalseClass) || a.is_a?(NilClass) || a.is_a?(1.class) || a.is_a?(1.0.class) || a.is_a?(Symbol)\n"+ " @#{arg} = a\n"+ "elsif a.is_a?(Array)\n"+ " @#{arg} = a.collect { |aa| aa.dup }\n"+ @@ -550,8 +550,8 @@ def dump(i) # @attribute inline Is true for inline declarations class CPPDeclaration < CPPObject - attr_accessor :type, :template_decl, :visibility, :storage_class, :virtual, :inline - def_initializer :type, :template_decl, :visibility, :storage_class, :virtual, :inline + attr_accessor :type, :template_decl, :visibility, :storage_class, :virtual, :inline, :is_definition + def_initializer :type, :template_decl, :visibility, :storage_class, :virtual, :inline, :is_definition def dump(i) l = i diff --git a/scripts/mkqtdecl_common/cpp_parser_classes.rb b/scripts/mkqtdecl_common/cpp_parser_classes.rb index 31631e235f..167c5edd2a 100644 --- a/scripts/mkqtdecl_common/cpp_parser_classes.rb +++ b/scripts/mkqtdecl_common/cpp_parser_classes.rb @@ -409,6 +409,9 @@ def cpp end module PDeclaration + def is_definition + blk.text_value =~ /^\{/ + end def cpp td = nil if template.nonterminal? @@ -438,7 +441,7 @@ def cpp elsif d.is_a?(CPPEnum) CPPEnumDeclaration::new(d, :default) else - CPPDeclaration::new(d, td, :default, storage_class, virtual, inline) + CPPDeclaration::new(d, td, :default, storage_class, virtual, inline, self.is_definition) end end end diff --git a/scripts/mkqtdecl_common/produce.rb b/scripts/mkqtdecl_common/produce.rb index bf62d4c244..895042c798 100755 --- a/scripts/mkqtdecl_common/produce.rb +++ b/scripts/mkqtdecl_common/produce.rb @@ -424,6 +424,24 @@ def get_dtor end + def collect_friend_definitions + + friend_decl = [] + + (self.body_decl || []).each do |bd| + if bd.is_a?(CPPFriendDecl) + bd.decl.each do |decl| + if ! decl.template_decl && decl.respond_to?(:is_definition) && decl.is_definition + friend_decl << decl + end + end + end + end + + friend_decl + + end + def collect_ctors ctors = [] @@ -1202,7 +1220,7 @@ def target_name(cls, bd, mid, mm = nil, decl = nil) # we also test for the parent of bd which may be different from cls if # the method is imported from a base class or through "using" - cls2 = bd.parent.myself || "" + cls2 = (bd.parent && bd.parent.myself) || "" sig2 = bd.sig(cls2) # the drop test includes the static attribute so we can distinguish between @@ -1977,7 +1995,7 @@ def produce_class(conf, decl_obj, ofile, index) if ctors.empty? && conf.has_default_ctor?(cls) func = CPPFunc::new(CPPQualifiedId::new(false, [ CPPId::new(decl_obj.myself, nil) ]), [], nil, nil) type = CPPType::new(nil, func, nil) - def_ctor = CPPDeclaration::new(type, nil, :public, nil, false, false) + def_ctor = CPPDeclaration::new(type, nil, :public, nil, false, false, false) def_ctor.parent = decl_obj ctors << def_ctor end @@ -1989,7 +2007,9 @@ def produce_class(conf, decl_obj, ofile, index) global_operators = [] # collect global operators with the given class as the first argument - @root.decls.each do |bd| + # Note that operators can also implicitly be declared as friends + (@root.decls + struct.collect_friend_definitions).each do |bd| + if bd.is_a?(CPPDeclaration) && bd.type.func && bd.type.name =~ /^operator/ op_func = bd.type.func if op_func.args.size >= 1 @@ -1999,6 +2019,7 @@ def produce_class(conf, decl_obj, ofile, index) end end end + end native_impl = conf.native_impl(cls) @@ -2359,9 +2380,9 @@ def produce_class(conf, decl_obj, ofile, index) ofile.puts("static #{rt.gsi_decl_return(decl_obj)} op_#{clsn}_#{mn}_#{hk}(#{args}) {") if !rt.is_void? - ofile.puts(" return " + rt.access_gsi_return(decl_obj, "::#{mid}(*#{qt_alist.join(', ')});")) + ofile.puts(" return " + rt.access_gsi_return(decl_obj, "#{mid}(*#{qt_alist.join(', ')});")) else - ofile.puts(" ::#{mid}(*#{qt_alist.join(', ')});") + ofile.puts(" #{mid}(*#{qt_alist.join(', ')});") end ofile.puts("}") From 0328c7e9bd1c247025f4eb1c8b6de538e99f674a Mon Sep 17 00:00:00 2001 From: Matthias Koefferlein Date: Sat, 19 Oct 2024 20:35:43 +0200 Subject: [PATCH 2/4] Updating Qt binding files --- src/gsiqt/qt6/QtCore/gsiDeclQAnyStringView.cc | 36 +++++++++++ .../qt6/QtCore/gsiDeclQCollatorSortKey.cc | 6 ++ src/gsiqt/qt6/QtCore/gsiDeclQDate.cc | 36 +++++++++++ src/gsiqt/qt6/QtCore/gsiDeclQDateTime.cc | 36 +++++++++++ src/gsiqt/qt6/QtCore/gsiDeclQDeadlineTimer.cc | 48 +++++++++++++++ src/gsiqt/qt6/QtCore/gsiDeclQElapsedTimer.cc | 12 ++++ .../qt6/QtCore/gsiDeclQKeyCombination.cc | 12 ++++ src/gsiqt/qt6/QtCore/gsiDeclQLocale.cc | 12 ++++ src/gsiqt/qt6/QtCore/gsiDeclQMargins.cc | 36 +++++++---- src/gsiqt/qt6/QtCore/gsiDeclQMarginsF.cc | 32 ++++++---- .../qt6/QtCore/gsiDeclQMetaAssociation.cc | 12 ++++ src/gsiqt/qt6/QtCore/gsiDeclQMetaMethod.cc | 12 ++++ src/gsiqt/qt6/QtCore/gsiDeclQMetaSequence.cc | 12 ++++ src/gsiqt/qt6/QtCore/gsiDeclQMetaType.cc | 12 ++++ .../QtCore/gsiDeclQOperatingSystemVersion.cc | 24 ++++++++ .../qt6/QtCore/gsiDeclQPartialOrdering.cc | 12 ++++ src/gsiqt/qt6/QtCore/gsiDeclQPoint.cc | 60 +++++++++++++++++++ src/gsiqt/qt6/QtCore/gsiDeclQPointF.cc | 48 +++++++++++++++ .../qt6/QtCore/gsiDeclQRandomGenerator.cc | 6 ++ src/gsiqt/qt6/QtCore/gsiDeclQRect.cc | 16 ++++- src/gsiqt/qt6/QtCore/gsiDeclQRectF.cc | 16 ++++- src/gsiqt/qt6/QtCore/gsiDeclQSize.cc | 36 +++++++++++ src/gsiqt/qt6/QtCore/gsiDeclQSizeF.cc | 36 +++++++++++ .../qt6/QtCore/gsiDeclQSocketDescriptor.cc | 12 ++++ src/gsiqt/qt6/QtCore/gsiDeclQStorageInfo.cc | 12 ++++ src/gsiqt/qt6/QtCore/gsiDeclQTime.cc | 36 +++++++++++ src/gsiqt/qt6/QtCore/gsiDeclQTypeRevision.cc | 36 +++++++++++ src/gsiqt/qt6/QtCore/gsiDeclQVersionNumber.cc | 36 +++++++++++ .../qt6/QtGui/gsiDeclQAccessible_State.cc | 6 ++ src/gsiqt/qt6/QtGui/gsiDeclQColorSpace.cc | 12 ++++ src/gsiqt/qt6/QtGui/gsiDeclQCursor.cc | 6 ++ src/gsiqt/qt6/QtGui/gsiDeclQMatrix4x4.cc | 20 +++---- src/gsiqt/qt6/QtGui/gsiDeclQPageLayout.cc | 12 ++++ src/gsiqt/qt6/QtGui/gsiDeclQPageRanges.cc | 12 ++++ src/gsiqt/qt6/QtGui/gsiDeclQPageSize.cc | 12 ++++ src/gsiqt/qt6/QtGui/gsiDeclQPainterPath.cc | 2 +- src/gsiqt/qt6/QtGui/gsiDeclQPixelFormat.cc | 12 ++++ .../QtGui/gsiDeclQPointingDeviceUniqueId.cc | 12 ++++ src/gsiqt/qt6/QtGui/gsiDeclQPolygon.cc | 2 +- src/gsiqt/qt6/QtGui/gsiDeclQPolygonF.cc | 2 +- src/gsiqt/qt6/QtGui/gsiDeclQQuaternion.cc | 26 +++++--- src/gsiqt/qt6/QtGui/gsiDeclQRegion.cc | 2 +- src/gsiqt/qt6/QtGui/gsiDeclQSurfaceFormat.cc | 12 ++++ src/gsiqt/qt6/QtGui/gsiDeclQTransform.cc | 8 +-- src/gsiqt/qt6/QtGui/gsiDeclQVector2D.cc | 54 +++++++++++++++++ src/gsiqt/qt6/QtGui/gsiDeclQVector3D.cc | 56 ++++++++++++++++- src/gsiqt/qt6/QtGui/gsiDeclQVector4D.cc | 56 ++++++++++++++++- .../qt6/QtMultimedia/gsiDeclQAudioFormat.cc | 12 ++++ .../qt6/QtMultimedia/gsiDeclQMediaMetaData.cc | 12 ++++ .../QtMultimedia/gsiDeclQMediaTimeRange.cc | 16 ++++- src/gsiqt/qt6/QtNetwork/gsiDeclQHstsPolicy.cc | 12 ++++ .../QtNetwork/gsiDeclQHttp2Configuration.cc | 12 ++++ .../gsiDeclQSslDiffieHellmanParameters.cc | 12 ++++ .../qt6/QtNetwork/gsiDeclQSslEllipticCurve.cc | 12 ++++ .../gsiDeclQSslPreSharedKeyAuthenticator.cc | 12 ++++ 55 files changed, 1069 insertions(+), 55 deletions(-) diff --git a/src/gsiqt/qt6/QtCore/gsiDeclQAnyStringView.cc b/src/gsiqt/qt6/QtCore/gsiDeclQAnyStringView.cc index 8e6834bf97..3f0a10ee5e 100644 --- a/src/gsiqt/qt6/QtCore/gsiDeclQAnyStringView.cc +++ b/src/gsiqt/qt6/QtCore/gsiDeclQAnyStringView.cc @@ -304,6 +304,36 @@ static void _call_f_equal_3602 (const qt_gsi::GenericStaticMethod * /*decl*/, gs } +// bool ::operator==(QAnyStringView lhs, QAnyStringView rhs) +static bool op_QAnyStringView_operator_eq__eq__3602(QAnyStringView *_self, QAnyStringView rhs) { + return operator==(*_self, rhs); +} + +// bool ::operator!=(QAnyStringView lhs, QAnyStringView rhs) +static bool op_QAnyStringView_operator_excl__eq__3602(QAnyStringView *_self, QAnyStringView rhs) { + return operator!=(*_self, rhs); +} + +// bool ::operator<=(QAnyStringView lhs, QAnyStringView rhs) +static bool op_QAnyStringView_operator_lt__eq__3602(QAnyStringView *_self, QAnyStringView rhs) { + return operator<=(*_self, rhs); +} + +// bool ::operator>=(QAnyStringView lhs, QAnyStringView rhs) +static bool op_QAnyStringView_operator_gt__eq__3602(QAnyStringView *_self, QAnyStringView rhs) { + return operator>=(*_self, rhs); +} + +// bool ::operator<(QAnyStringView lhs, QAnyStringView rhs) +static bool op_QAnyStringView_operator_lt__3602(QAnyStringView *_self, QAnyStringView rhs) { + return operator<(*_self, rhs); +} + +// bool ::operator>(QAnyStringView lhs, QAnyStringView rhs) +static bool op_QAnyStringView_operator_gt__3602(QAnyStringView *_self, QAnyStringView rhs) { + return operator>(*_self, rhs); +} + namespace gsi { @@ -326,6 +356,12 @@ static gsi::Methods methods_QAnyStringView () { methods += new qt_gsi::GenericMethod ("toString", "@brief Method QString QAnyStringView::toString()\n", true, &_init_f_toString_c0, &_call_f_toString_c0); methods += new qt_gsi::GenericStaticMethod ("compare", "@brief Static method int QAnyStringView::compare(QAnyStringView lhs, QAnyStringView rhs, Qt::CaseSensitivity cs)\nThis method is static and can be called without an instance.", &_init_f_compare_5818, &_call_f_compare_5818); methods += new qt_gsi::GenericStaticMethod ("equal", "@brief Static method bool QAnyStringView::equal(QAnyStringView lhs, QAnyStringView rhs)\nThis method is static and can be called without an instance.", &_init_f_equal_3602, &_call_f_equal_3602); + methods += gsi::method_ext("==", &::op_QAnyStringView_operator_eq__eq__3602, gsi::arg ("rhs"), "@brief Operator bool ::operator==(QAnyStringView lhs, QAnyStringView rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QAnyStringView_operator_excl__eq__3602, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(QAnyStringView lhs, QAnyStringView rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("<=", &::op_QAnyStringView_operator_lt__eq__3602, gsi::arg ("rhs"), "@brief Operator bool ::operator<=(QAnyStringView lhs, QAnyStringView rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext(">=", &::op_QAnyStringView_operator_gt__eq__3602, gsi::arg ("rhs"), "@brief Operator bool ::operator>=(QAnyStringView lhs, QAnyStringView rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("<", &::op_QAnyStringView_operator_lt__3602, gsi::arg ("rhs"), "@brief Operator bool ::operator<(QAnyStringView lhs, QAnyStringView rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext(">", &::op_QAnyStringView_operator_gt__3602, gsi::arg ("rhs"), "@brief Operator bool ::operator>(QAnyStringView lhs, QAnyStringView rhs)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtCore/gsiDeclQCollatorSortKey.cc b/src/gsiqt/qt6/QtCore/gsiDeclQCollatorSortKey.cc index f530debffa..099cb97366 100644 --- a/src/gsiqt/qt6/QtCore/gsiDeclQCollatorSortKey.cc +++ b/src/gsiqt/qt6/QtCore/gsiDeclQCollatorSortKey.cc @@ -112,6 +112,11 @@ static void _call_f_swap_2252 (const qt_gsi::GenericMethod * /*decl*/, void *cls } +// bool ::operator<(const QCollatorSortKey &lhs, const QCollatorSortKey &rhs) +static bool op_QCollatorSortKey_operator_lt__5786(const QCollatorSortKey *_self, const QCollatorSortKey &rhs) { + return operator<(*_self, rhs); +} + namespace gsi { @@ -122,6 +127,7 @@ static gsi::Methods methods_QCollatorSortKey () { methods += new qt_gsi::GenericMethod ("compare", "@brief Method int QCollatorSortKey::compare(const QCollatorSortKey &key)\n", true, &_init_f_compare_c2947, &_call_f_compare_c2947); methods += new qt_gsi::GenericMethod ("assign", "@brief Method QCollatorSortKey &QCollatorSortKey::operator=(const QCollatorSortKey &other)\n", false, &_init_f_operator_eq__2947, &_call_f_operator_eq__2947); methods += new qt_gsi::GenericMethod ("swap", "@brief Method void QCollatorSortKey::swap(QCollatorSortKey &other)\n", false, &_init_f_swap_2252, &_call_f_swap_2252); + methods += gsi::method_ext("<", &::op_QCollatorSortKey_operator_lt__5786, gsi::arg ("rhs"), "@brief Operator bool ::operator<(const QCollatorSortKey &lhs, const QCollatorSortKey &rhs)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtCore/gsiDeclQDate.cc b/src/gsiqt/qt6/QtCore/gsiDeclQDate.cc index 764ff7e022..22b4757889 100644 --- a/src/gsiqt/qt6/QtCore/gsiDeclQDate.cc +++ b/src/gsiqt/qt6/QtCore/gsiDeclQDate.cc @@ -855,6 +855,36 @@ static void _call_f_isValid_2085 (const qt_gsi::GenericStaticMethod * /*decl*/, } +// bool ::operator==(QDate lhs, QDate rhs) +static bool op_QDate_operator_eq__eq__1690(QDate *_self, QDate rhs) { + return operator==(*_self, rhs); +} + +// bool ::operator!=(QDate lhs, QDate rhs) +static bool op_QDate_operator_excl__eq__1690(QDate *_self, QDate rhs) { + return operator!=(*_self, rhs); +} + +// bool ::operator<(QDate lhs, QDate rhs) +static bool op_QDate_operator_lt__1690(QDate *_self, QDate rhs) { + return operator<(*_self, rhs); +} + +// bool ::operator<=(QDate lhs, QDate rhs) +static bool op_QDate_operator_lt__eq__1690(QDate *_self, QDate rhs) { + return operator<=(*_self, rhs); +} + +// bool ::operator>(QDate lhs, QDate rhs) +static bool op_QDate_operator_gt__1690(QDate *_self, QDate rhs) { + return operator>(*_self, rhs); +} + +// bool ::operator>=(QDate lhs, QDate rhs) +static bool op_QDate_operator_gt__eq__1690(QDate *_self, QDate rhs) { + return operator>=(*_self, rhs); +} + namespace gsi { @@ -903,6 +933,12 @@ static gsi::Methods methods_QDate () { methods += new qt_gsi::GenericStaticMethod ("fromString", "@brief Static method QDate QDate::fromString(const QString &string, const QString &format, QCalendar cal)\nThis method is static and can be called without an instance.", &_init_f_fromString_5145, &_call_f_fromString_5145); methods += new qt_gsi::GenericStaticMethod ("isLeapYear?", "@brief Static method bool QDate::isLeapYear(int year)\nThis method is static and can be called without an instance.", &_init_f_isLeapYear_767, &_call_f_isLeapYear_767); methods += new qt_gsi::GenericStaticMethod ("isValid?", "@brief Static method bool QDate::isValid(int y, int m, int d)\nThis method is static and can be called without an instance.", &_init_f_isValid_2085, &_call_f_isValid_2085); + methods += gsi::method_ext("==", &::op_QDate_operator_eq__eq__1690, gsi::arg ("rhs"), "@brief Operator bool ::operator==(QDate lhs, QDate rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QDate_operator_excl__eq__1690, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(QDate lhs, QDate rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("<", &::op_QDate_operator_lt__1690, gsi::arg ("rhs"), "@brief Operator bool ::operator<(QDate lhs, QDate rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("<=", &::op_QDate_operator_lt__eq__1690, gsi::arg ("rhs"), "@brief Operator bool ::operator<=(QDate lhs, QDate rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext(">", &::op_QDate_operator_gt__1690, gsi::arg ("rhs"), "@brief Operator bool ::operator>(QDate lhs, QDate rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext(">=", &::op_QDate_operator_gt__eq__1690, gsi::arg ("rhs"), "@brief Operator bool ::operator>=(QDate lhs, QDate rhs)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtCore/gsiDeclQDateTime.cc b/src/gsiqt/qt6/QtCore/gsiDeclQDateTime.cc index bee11a3802..0097d60783 100644 --- a/src/gsiqt/qt6/QtCore/gsiDeclQDateTime.cc +++ b/src/gsiqt/qt6/QtCore/gsiDeclQDateTime.cc @@ -951,6 +951,36 @@ static void _call_f_fromString_5145 (const qt_gsi::GenericStaticMethod * /*decl* } +// bool ::operator==(const QDateTime &lhs, const QDateTime &rhs) +static bool op_QDateTime_operator_eq__eq__4242(const QDateTime *_self, const QDateTime &rhs) { + return operator==(*_self, rhs); +} + +// bool ::operator!=(const QDateTime &lhs, const QDateTime &rhs) +static bool op_QDateTime_operator_excl__eq__4242(const QDateTime *_self, const QDateTime &rhs) { + return operator!=(*_self, rhs); +} + +// bool ::operator<(const QDateTime &lhs, const QDateTime &rhs) +static bool op_QDateTime_operator_lt__4242(const QDateTime *_self, const QDateTime &rhs) { + return operator<(*_self, rhs); +} + +// bool ::operator<=(const QDateTime &lhs, const QDateTime &rhs) +static bool op_QDateTime_operator_lt__eq__4242(const QDateTime *_self, const QDateTime &rhs) { + return operator<=(*_self, rhs); +} + +// bool ::operator>(const QDateTime &lhs, const QDateTime &rhs) +static bool op_QDateTime_operator_gt__4242(const QDateTime *_self, const QDateTime &rhs) { + return operator>(*_self, rhs); +} + +// bool ::operator>=(const QDateTime &lhs, const QDateTime &rhs) +static bool op_QDateTime_operator_gt__eq__4242(const QDateTime *_self, const QDateTime &rhs) { + return operator>=(*_self, rhs); +} + namespace gsi { @@ -1006,6 +1036,12 @@ static gsi::Methods methods_QDateTime () { methods += new qt_gsi::GenericStaticMethod ("fromSecsSinceEpoch", "@brief Static method QDateTime QDateTime::fromSecsSinceEpoch(qint64 secs, const QTimeZone &timeZone)\nThis method is static and can be called without an instance.", &_init_f_fromSecsSinceEpoch_3083, &_call_f_fromSecsSinceEpoch_3083); methods += new qt_gsi::GenericStaticMethod ("fromString", "@brief Static method QDateTime QDateTime::fromString(const QString &string, Qt::DateFormat format)\nThis method is static and can be called without an instance.", &_init_f_fromString_3665, &_call_f_fromString_3665); methods += new qt_gsi::GenericStaticMethod ("fromString", "@brief Static method QDateTime QDateTime::fromString(const QString &string, const QString &format, QCalendar cal)\nThis method is static and can be called without an instance.", &_init_f_fromString_5145, &_call_f_fromString_5145); + methods += gsi::method_ext("==", &::op_QDateTime_operator_eq__eq__4242, gsi::arg ("rhs"), "@brief Operator bool ::operator==(const QDateTime &lhs, const QDateTime &rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QDateTime_operator_excl__eq__4242, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(const QDateTime &lhs, const QDateTime &rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("<", &::op_QDateTime_operator_lt__4242, gsi::arg ("rhs"), "@brief Operator bool ::operator<(const QDateTime &lhs, const QDateTime &rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("<=", &::op_QDateTime_operator_lt__eq__4242, gsi::arg ("rhs"), "@brief Operator bool ::operator<=(const QDateTime &lhs, const QDateTime &rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext(">", &::op_QDateTime_operator_gt__4242, gsi::arg ("rhs"), "@brief Operator bool ::operator>(const QDateTime &lhs, const QDateTime &rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext(">=", &::op_QDateTime_operator_gt__eq__4242, gsi::arg ("rhs"), "@brief Operator bool ::operator>=(const QDateTime &lhs, const QDateTime &rhs)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtCore/gsiDeclQDeadlineTimer.cc b/src/gsiqt/qt6/QtCore/gsiDeclQDeadlineTimer.cc index b2e2cd0f25..60d085c2d8 100644 --- a/src/gsiqt/qt6/QtCore/gsiDeclQDeadlineTimer.cc +++ b/src/gsiqt/qt6/QtCore/gsiDeclQDeadlineTimer.cc @@ -420,6 +420,46 @@ static void _call_f_current_1680 (const qt_gsi::GenericStaticMethod * /*decl*/, } +// bool ::operator==(QDeadlineTimer d1, QDeadlineTimer d2) +static bool op_QDeadlineTimer_operator_eq__eq__3532(QDeadlineTimer *_self, QDeadlineTimer d2) { + return operator==(*_self, d2); +} + +// bool ::operator!=(QDeadlineTimer d1, QDeadlineTimer d2) +static bool op_QDeadlineTimer_operator_excl__eq__3532(QDeadlineTimer *_self, QDeadlineTimer d2) { + return operator!=(*_self, d2); +} + +// bool ::operator<(QDeadlineTimer d1, QDeadlineTimer d2) +static bool op_QDeadlineTimer_operator_lt__3532(QDeadlineTimer *_self, QDeadlineTimer d2) { + return operator<(*_self, d2); +} + +// bool ::operator<=(QDeadlineTimer d1, QDeadlineTimer d2) +static bool op_QDeadlineTimer_operator_lt__eq__3532(QDeadlineTimer *_self, QDeadlineTimer d2) { + return operator<=(*_self, d2); +} + +// bool ::operator>(QDeadlineTimer d1, QDeadlineTimer d2) +static bool op_QDeadlineTimer_operator_gt__3532(QDeadlineTimer *_self, QDeadlineTimer d2) { + return operator>(*_self, d2); +} + +// bool ::operator>=(QDeadlineTimer d1, QDeadlineTimer d2) +static bool op_QDeadlineTimer_operator_gt__eq__3532(QDeadlineTimer *_self, QDeadlineTimer d2) { + return operator>=(*_self, d2); +} + +// QDeadlineTimer ::operator-(QDeadlineTimer dt, qint64 msecs) +static QDeadlineTimer op_QDeadlineTimer_operator_minus__2698(QDeadlineTimer *_self, qint64 msecs) { + return operator-(*_self, msecs); +} + +// qint64 ::operator-(QDeadlineTimer dt1, QDeadlineTimer dt2) +static qint64 op_QDeadlineTimer_operator_minus__3532(QDeadlineTimer *_self, QDeadlineTimer dt2) { + return operator-(*_self, dt2); +} + namespace gsi { @@ -446,6 +486,14 @@ static gsi::Methods methods_QDeadlineTimer () { methods += new qt_gsi::GenericMethod (":timerType", "@brief Method Qt::TimerType QDeadlineTimer::timerType()\n", true, &_init_f_timerType_c0, &_call_f_timerType_c0); methods += new qt_gsi::GenericStaticMethod ("addNSecs", "@brief Static method QDeadlineTimer QDeadlineTimer::addNSecs(QDeadlineTimer dt, qint64 nsecs)\nThis method is static and can be called without an instance.", &_init_f_addNSecs_2698, &_call_f_addNSecs_2698); methods += new qt_gsi::GenericStaticMethod ("current", "@brief Static method QDeadlineTimer QDeadlineTimer::current(Qt::TimerType timerType)\nThis method is static and can be called without an instance.", &_init_f_current_1680, &_call_f_current_1680); + methods += gsi::method_ext("==", &::op_QDeadlineTimer_operator_eq__eq__3532, gsi::arg ("d2"), "@brief Operator bool ::operator==(QDeadlineTimer d1, QDeadlineTimer d2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QDeadlineTimer_operator_excl__eq__3532, gsi::arg ("d2"), "@brief Operator bool ::operator!=(QDeadlineTimer d1, QDeadlineTimer d2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("<", &::op_QDeadlineTimer_operator_lt__3532, gsi::arg ("d2"), "@brief Operator bool ::operator<(QDeadlineTimer d1, QDeadlineTimer d2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("<=", &::op_QDeadlineTimer_operator_lt__eq__3532, gsi::arg ("d2"), "@brief Operator bool ::operator<=(QDeadlineTimer d1, QDeadlineTimer d2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext(">", &::op_QDeadlineTimer_operator_gt__3532, gsi::arg ("d2"), "@brief Operator bool ::operator>(QDeadlineTimer d1, QDeadlineTimer d2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext(">=", &::op_QDeadlineTimer_operator_gt__eq__3532, gsi::arg ("d2"), "@brief Operator bool ::operator>=(QDeadlineTimer d1, QDeadlineTimer d2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("-", &::op_QDeadlineTimer_operator_minus__2698, gsi::arg ("msecs"), "@brief Operator QDeadlineTimer ::operator-(QDeadlineTimer dt, qint64 msecs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("-", &::op_QDeadlineTimer_operator_minus__3532, gsi::arg ("dt2"), "@brief Operator qint64 ::operator-(QDeadlineTimer dt1, QDeadlineTimer dt2)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtCore/gsiDeclQElapsedTimer.cc b/src/gsiqt/qt6/QtCore/gsiDeclQElapsedTimer.cc index a29ee88fe1..4f21046f02 100644 --- a/src/gsiqt/qt6/QtCore/gsiDeclQElapsedTimer.cc +++ b/src/gsiqt/qt6/QtCore/gsiDeclQElapsedTimer.cc @@ -244,6 +244,16 @@ static void _call_f_isMonotonic_0 (const qt_gsi::GenericStaticMethod * /*decl*/, } +// bool ::operator==(const QElapsedTimer &lhs, const QElapsedTimer &rhs) +static bool op_QElapsedTimer_operator_eq__eq__5110(const QElapsedTimer *_self, const QElapsedTimer &rhs) { + return operator==(*_self, rhs); +} + +// bool ::operator!=(const QElapsedTimer &lhs, const QElapsedTimer &rhs) +static bool op_QElapsedTimer_operator_excl__eq__5110(const QElapsedTimer *_self, const QElapsedTimer &rhs) { + return operator!=(*_self, rhs); +} + namespace gsi { @@ -263,6 +273,8 @@ static gsi::Methods methods_QElapsedTimer () { methods += new qt_gsi::GenericMethod ("start", "@brief Method void QElapsedTimer::start()\n", false, &_init_f_start_0, &_call_f_start_0); methods += new qt_gsi::GenericStaticMethod ("clockType", "@brief Static method QElapsedTimer::ClockType QElapsedTimer::clockType()\nThis method is static and can be called without an instance.", &_init_f_clockType_0, &_call_f_clockType_0); methods += new qt_gsi::GenericStaticMethod ("isMonotonic?", "@brief Static method bool QElapsedTimer::isMonotonic()\nThis method is static and can be called without an instance.", &_init_f_isMonotonic_0, &_call_f_isMonotonic_0); + methods += gsi::method_ext("==", &::op_QElapsedTimer_operator_eq__eq__5110, gsi::arg ("rhs"), "@brief Operator bool ::operator==(const QElapsedTimer &lhs, const QElapsedTimer &rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QElapsedTimer_operator_excl__eq__5110, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(const QElapsedTimer &lhs, const QElapsedTimer &rhs)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtCore/gsiDeclQKeyCombination.cc b/src/gsiqt/qt6/QtCore/gsiDeclQKeyCombination.cc index caa2038f32..811e187eff 100644 --- a/src/gsiqt/qt6/QtCore/gsiDeclQKeyCombination.cc +++ b/src/gsiqt/qt6/QtCore/gsiDeclQKeyCombination.cc @@ -162,6 +162,16 @@ static void _call_f_fromCombined_767 (const qt_gsi::GenericStaticMethod * /*decl } +// bool ::operator==(QKeyCombination lhs, QKeyCombination rhs) +static bool op_QKeyCombination_operator_eq__eq__3798(QKeyCombination *_self, QKeyCombination rhs) { + return operator==(*_self, rhs); +} + +// bool ::operator!=(QKeyCombination lhs, QKeyCombination rhs) +static bool op_QKeyCombination_operator_excl__eq__3798(QKeyCombination *_self, QKeyCombination rhs) { + return operator!=(*_self, rhs); +} + namespace gsi { @@ -175,6 +185,8 @@ static gsi::Methods methods_QKeyCombination () { methods += new qt_gsi::GenericMethod ("keyboardModifiers", "@brief Method QFlags QKeyCombination::keyboardModifiers()\n", true, &_init_f_keyboardModifiers_c0, &_call_f_keyboardModifiers_c0); methods += new qt_gsi::GenericMethod ("toCombined", "@brief Method int QKeyCombination::toCombined()\n", true, &_init_f_toCombined_c0, &_call_f_toCombined_c0); methods += new qt_gsi::GenericStaticMethod ("fromCombined", "@brief Static method QKeyCombination QKeyCombination::fromCombined(int combined)\nThis method is static and can be called without an instance.", &_init_f_fromCombined_767, &_call_f_fromCombined_767); + methods += gsi::method_ext("==", &::op_QKeyCombination_operator_eq__eq__3798, gsi::arg ("rhs"), "@brief Operator bool ::operator==(QKeyCombination lhs, QKeyCombination rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QKeyCombination_operator_excl__eq__3798, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(QKeyCombination lhs, QKeyCombination rhs)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtCore/gsiDeclQLocale.cc b/src/gsiqt/qt6/QtCore/gsiDeclQLocale.cc index 1f874c769a..63fed94e66 100644 --- a/src/gsiqt/qt6/QtCore/gsiDeclQLocale.cc +++ b/src/gsiqt/qt6/QtCore/gsiDeclQLocale.cc @@ -2105,6 +2105,16 @@ static void _call_f_territoryToString_2205 (const qt_gsi::GenericStaticMethod * } +// bool ::operator==(const QLocale &lhs, const QLocale &rhs) +static bool op_QLocale_operator_eq__eq__3864(const QLocale *_self, const QLocale &rhs) { + return operator==(*_self, rhs); +} + +// bool ::operator!=(const QLocale &lhs, const QLocale &rhs) +static bool op_QLocale_operator_excl__eq__3864(const QLocale *_self, const QLocale &rhs) { + return operator!=(*_self, rhs); +} + namespace gsi { @@ -2216,6 +2226,8 @@ static gsi::Methods methods_QLocale () { methods += new qt_gsi::GenericStaticMethod ("system", "@brief Static method QLocale QLocale::system()\nThis method is static and can be called without an instance.", &_init_f_system_0, &_call_f_system_0); methods += new qt_gsi::GenericStaticMethod ("territoryToCode", "@brief Static method QString QLocale::territoryToCode(QLocale::Territory territory)\nThis method is static and can be called without an instance.", &_init_f_territoryToCode_2205, &_call_f_territoryToCode_2205); methods += new qt_gsi::GenericStaticMethod ("territoryToString", "@brief Static method QString QLocale::territoryToString(QLocale::Territory territory)\nThis method is static and can be called without an instance.", &_init_f_territoryToString_2205, &_call_f_territoryToString_2205); + methods += gsi::method_ext("==", &::op_QLocale_operator_eq__eq__3864, gsi::arg ("rhs"), "@brief Operator bool ::operator==(const QLocale &lhs, const QLocale &rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QLocale_operator_excl__eq__3864, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(const QLocale &lhs, const QLocale &rhs)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtCore/gsiDeclQMargins.cc b/src/gsiqt/qt6/QtCore/gsiDeclQMargins.cc index b24bb53f3a..1fef1ff310 100644 --- a/src/gsiqt/qt6/QtCore/gsiDeclQMargins.cc +++ b/src/gsiqt/qt6/QtCore/gsiDeclQMargins.cc @@ -387,62 +387,72 @@ static void _call_f_top_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, g // QMargins ::operator+(const QMargins &m1, const QMargins &m2) static QMargins op_QMargins_operator_plus__4122(const QMargins *_self, const QMargins &m2) { - return ::operator+(*_self, m2); + return operator+(*_self, m2); } // QMargins ::operator-(const QMargins &m1, const QMargins &m2) static QMargins op_QMargins_operator_minus__4122(const QMargins *_self, const QMargins &m2) { - return ::operator-(*_self, m2); + return operator-(*_self, m2); } // QMargins ::operator+(const QMargins &lhs, int rhs) static QMargins op_QMargins_operator_plus__2774(const QMargins *_self, int rhs) { - return ::operator+(*_self, rhs); + return operator+(*_self, rhs); } // QMargins ::operator-(const QMargins &lhs, int rhs) static QMargins op_QMargins_operator_minus__2774(const QMargins *_self, int rhs) { - return ::operator-(*_self, rhs); + return operator-(*_self, rhs); } // QMargins ::operator*(const QMargins &margins, int factor) static QMargins op_QMargins_operator_star__2774(const QMargins *_self, int factor) { - return ::operator*(*_self, factor); + return operator*(*_self, factor); } // QMargins ::operator*(const QMargins &margins, qreal factor) static QMargins op_QMargins_operator_star__2976(const QMargins *_self, qreal factor) { - return ::operator*(*_self, factor); + return operator*(*_self, factor); } // QMargins ::operator/(const QMargins &margins, int divisor) static QMargins op_QMargins_operator_slash__2774(const QMargins *_self, int divisor) { - return ::operator/(*_self, divisor); + return operator/(*_self, divisor); } // QMargins ::operator/(const QMargins &margins, qreal divisor) static QMargins op_QMargins_operator_slash__2976(const QMargins *_self, qreal divisor) { - return ::operator/(*_self, divisor); + return operator/(*_self, divisor); } // QMargins ::operator|(const QMargins &m1, const QMargins &m2) static QMargins op_QMargins_operator_pipe__4122(const QMargins *_self, const QMargins &m2) { - return ::operator|(*_self, m2); + return operator|(*_self, m2); } // QMargins ::operator+(const QMargins &margins) static QMargins op_QMargins_operator_plus__2115(const QMargins *_self) { - return ::operator+(*_self); + return operator+(*_self); } // QMargins ::operator-(const QMargins &margins) static QMargins op_QMargins_operator_minus__2115(const QMargins *_self) { - return ::operator-(*_self); + return operator-(*_self); } // QRect ::operator+(const QMargins &margins, const QRect &rectangle) static QRect op_QMargins_operator_plus__3799(const QMargins *_self, const QRect &rectangle) { - return ::operator+(*_self, rectangle); + return operator+(*_self, rectangle); +} + +// bool ::operator==(const QMargins &m1, const QMargins &m2) +static bool op_QMargins_operator_eq__eq__4122(const QMargins *_self, const QMargins &m2) { + return operator==(*_self, m2); +} + +// bool ::operator!=(const QMargins &m1, const QMargins &m2) +static bool op_QMargins_operator_excl__eq__4122(const QMargins *_self, const QMargins &m2) { + return operator!=(*_self, m2); } @@ -482,6 +492,8 @@ static gsi::Methods methods_QMargins () { methods += gsi::method_ext("+", &::op_QMargins_operator_plus__2115, "@brief Operator QMargins ::operator+(const QMargins &margins)\nThis is the mapping of the global operator to the instance method."); methods += gsi::method_ext("-", &::op_QMargins_operator_minus__2115, "@brief Operator QMargins ::operator-(const QMargins &margins)\nThis is the mapping of the global operator to the instance method."); methods += gsi::method_ext("+", &::op_QMargins_operator_plus__3799, gsi::arg ("rectangle"), "@brief Operator QRect ::operator+(const QMargins &margins, const QRect &rectangle)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("==", &::op_QMargins_operator_eq__eq__4122, gsi::arg ("m2"), "@brief Operator bool ::operator==(const QMargins &m1, const QMargins &m2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QMargins_operator_excl__eq__4122, gsi::arg ("m2"), "@brief Operator bool ::operator!=(const QMargins &m1, const QMargins &m2)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtCore/gsiDeclQMarginsF.cc b/src/gsiqt/qt6/QtCore/gsiDeclQMarginsF.cc index 12c5696e13..d18665f31f 100644 --- a/src/gsiqt/qt6/QtCore/gsiDeclQMarginsF.cc +++ b/src/gsiqt/qt6/QtCore/gsiDeclQMarginsF.cc @@ -384,52 +384,62 @@ static void _call_f_top_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, g // QMarginsF ::operator+(const QMarginsF &lhs, const QMarginsF &rhs) static QMarginsF op_QMarginsF_operator_plus__4262(const QMarginsF *_self, const QMarginsF &rhs) { - return ::operator+(*_self, rhs); + return operator+(*_self, rhs); } // QMarginsF ::operator-(const QMarginsF &lhs, const QMarginsF &rhs) static QMarginsF op_QMarginsF_operator_minus__4262(const QMarginsF *_self, const QMarginsF &rhs) { - return ::operator-(*_self, rhs); + return operator-(*_self, rhs); } // QMarginsF ::operator+(const QMarginsF &lhs, qreal rhs) static QMarginsF op_QMarginsF_operator_plus__3046(const QMarginsF *_self, qreal rhs) { - return ::operator+(*_self, rhs); + return operator+(*_self, rhs); } // QMarginsF ::operator-(const QMarginsF &lhs, qreal rhs) static QMarginsF op_QMarginsF_operator_minus__3046(const QMarginsF *_self, qreal rhs) { - return ::operator-(*_self, rhs); + return operator-(*_self, rhs); } // QMarginsF ::operator*(const QMarginsF &lhs, qreal rhs) static QMarginsF op_QMarginsF_operator_star__3046(const QMarginsF *_self, qreal rhs) { - return ::operator*(*_self, rhs); + return operator*(*_self, rhs); } // QMarginsF ::operator/(const QMarginsF &lhs, qreal divisor) static QMarginsF op_QMarginsF_operator_slash__3046(const QMarginsF *_self, qreal divisor) { - return ::operator/(*_self, divisor); + return operator/(*_self, divisor); } // QMarginsF ::operator|(const QMarginsF &m1, const QMarginsF &m2) static QMarginsF op_QMarginsF_operator_pipe__4262(const QMarginsF *_self, const QMarginsF &m2) { - return ::operator|(*_self, m2); + return operator|(*_self, m2); } // QMarginsF ::operator+(const QMarginsF &margins) static QMarginsF op_QMarginsF_operator_plus__2185(const QMarginsF *_self) { - return ::operator+(*_self); + return operator+(*_self); } // QMarginsF ::operator-(const QMarginsF &margins) static QMarginsF op_QMarginsF_operator_minus__2185(const QMarginsF *_self) { - return ::operator-(*_self); + return operator-(*_self); } // QRectF ::operator+(const QMarginsF &lhs, const QRectF &rhs) static QRectF op_QMarginsF_operator_plus__3939(const QMarginsF *_self, const QRectF &rhs) { - return ::operator+(*_self, rhs); + return operator+(*_self, rhs); +} + +// bool ::operator==(const QMarginsF &lhs, const QMarginsF &rhs) +static bool op_QMarginsF_operator_eq__eq__4262(const QMarginsF *_self, const QMarginsF &rhs) { + return operator==(*_self, rhs); +} + +// bool ::operator!=(const QMarginsF &lhs, const QMarginsF &rhs) +static bool op_QMarginsF_operator_excl__eq__4262(const QMarginsF *_self, const QMarginsF &rhs) { + return operator!=(*_self, rhs); } @@ -467,6 +477,8 @@ static gsi::Methods methods_QMarginsF () { methods += gsi::method_ext("+", &::op_QMarginsF_operator_plus__2185, "@brief Operator QMarginsF ::operator+(const QMarginsF &margins)\nThis is the mapping of the global operator to the instance method."); methods += gsi::method_ext("-", &::op_QMarginsF_operator_minus__2185, "@brief Operator QMarginsF ::operator-(const QMarginsF &margins)\nThis is the mapping of the global operator to the instance method."); methods += gsi::method_ext("+", &::op_QMarginsF_operator_plus__3939, gsi::arg ("rhs"), "@brief Operator QRectF ::operator+(const QMarginsF &lhs, const QRectF &rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("==", &::op_QMarginsF_operator_eq__eq__4262, gsi::arg ("rhs"), "@brief Operator bool ::operator==(const QMarginsF &lhs, const QMarginsF &rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QMarginsF_operator_excl__eq__4262, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(const QMarginsF &lhs, const QMarginsF &rhs)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtCore/gsiDeclQMetaAssociation.cc b/src/gsiqt/qt6/QtCore/gsiDeclQMetaAssociation.cc index 1c2de62d44..31b3a18102 100644 --- a/src/gsiqt/qt6/QtCore/gsiDeclQMetaAssociation.cc +++ b/src/gsiqt/qt6/QtCore/gsiDeclQMetaAssociation.cc @@ -540,6 +540,16 @@ static void _call_f_setMappedAtKey_c4342 (const qt_gsi::GenericMethod * /*decl*/ } +// bool ::operator==(const QMetaAssociation &a, const QMetaAssociation &b) +static bool op_QMetaAssociation_operator_eq__eq__5760(const QMetaAssociation *_self, const QMetaAssociation &b) { + return operator==(*_self, b); +} + +// bool ::operator!=(const QMetaAssociation &a, const QMetaAssociation &b) +static bool op_QMetaAssociation_operator_excl__eq__5760(const QMetaAssociation *_self, const QMetaAssociation &b) { + return operator!=(*_self, b); +} + namespace gsi { @@ -573,6 +583,8 @@ static gsi::Methods methods_QMetaAssociation () { methods += new qt_gsi::GenericMethod ("removeKey", "@brief Method void QMetaAssociation::removeKey(void *container, const void *key)\n", true, &_init_f_removeKey_c2699, &_call_f_removeKey_c2699); methods += new qt_gsi::GenericMethod ("setMappedAtIterator", "@brief Method void QMetaAssociation::setMappedAtIterator(const void *iterator, const void *mapped)\n", true, &_init_f_setMappedAtIterator_c3394, &_call_f_setMappedAtIterator_c3394); methods += new qt_gsi::GenericMethod ("setMappedAtKey", "@brief Method void QMetaAssociation::setMappedAtKey(void *container, const void *key, const void *mapped)\n", true, &_init_f_setMappedAtKey_c4342, &_call_f_setMappedAtKey_c4342); + methods += gsi::method_ext("==", &::op_QMetaAssociation_operator_eq__eq__5760, gsi::arg ("b"), "@brief Operator bool ::operator==(const QMetaAssociation &a, const QMetaAssociation &b)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QMetaAssociation_operator_excl__eq__5760, gsi::arg ("b"), "@brief Operator bool ::operator!=(const QMetaAssociation &a, const QMetaAssociation &b)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtCore/gsiDeclQMetaMethod.cc b/src/gsiqt/qt6/QtCore/gsiDeclQMetaMethod.cc index 974768df86..dc788b9129 100644 --- a/src/gsiqt/qt6/QtCore/gsiDeclQMetaMethod.cc +++ b/src/gsiqt/qt6/QtCore/gsiDeclQMetaMethod.cc @@ -399,6 +399,16 @@ static void _call_f_typeName_c0 (const qt_gsi::GenericMethod * /*decl*/, void *c } +// bool ::operator==(const QMetaMethod &m1, const QMetaMethod &m2) +static bool op_QMetaMethod_operator_eq__eq__4680(const QMetaMethod *_self, const QMetaMethod &m2) { + return operator==(*_self, m2); +} + +// bool ::operator!=(const QMetaMethod &m1, const QMetaMethod &m2) +static bool op_QMetaMethod_operator_excl__eq__4680(const QMetaMethod *_self, const QMetaMethod &m2) { + return operator!=(*_self, m2); +} + namespace gsi { @@ -428,6 +438,8 @@ static gsi::Methods methods_QMetaMethod () { methods += new qt_gsi::GenericMethod ("revision", "@brief Method int QMetaMethod::revision()\n", true, &_init_f_revision_c0, &_call_f_revision_c0); methods += new qt_gsi::GenericMethod ("tag", "@brief Method const char *QMetaMethod::tag()\n", true, &_init_f_tag_c0, &_call_f_tag_c0); methods += new qt_gsi::GenericMethod ("typeName", "@brief Method const char *QMetaMethod::typeName()\n", true, &_init_f_typeName_c0, &_call_f_typeName_c0); + methods += gsi::method_ext("==", &::op_QMetaMethod_operator_eq__eq__4680, gsi::arg ("m2"), "@brief Operator bool ::operator==(const QMetaMethod &m1, const QMetaMethod &m2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QMetaMethod_operator_excl__eq__4680, gsi::arg ("m2"), "@brief Operator bool ::operator!=(const QMetaMethod &m1, const QMetaMethod &m2)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtCore/gsiDeclQMetaSequence.cc b/src/gsiqt/qt6/QtCore/gsiDeclQMetaSequence.cc index 30ba965380..d2bcc5683c 100644 --- a/src/gsiqt/qt6/QtCore/gsiDeclQMetaSequence.cc +++ b/src/gsiqt/qt6/QtCore/gsiDeclQMetaSequence.cc @@ -616,6 +616,16 @@ static void _call_f_valueMetaType_c0 (const qt_gsi::GenericMethod * /*decl*/, vo } +// bool ::operator==(const QMetaSequence &a, const QMetaSequence &b) +static bool op_QMetaSequence_operator_eq__eq__5112(const QMetaSequence *_self, const QMetaSequence &b) { + return operator==(*_self, b); +} + +// bool ::operator!=(const QMetaSequence &a, const QMetaSequence &b) +static bool op_QMetaSequence_operator_excl__eq__5112(const QMetaSequence *_self, const QMetaSequence &b) { + return operator!=(*_self, b); +} + namespace gsi { @@ -653,6 +663,8 @@ static gsi::Methods methods_QMetaSequence () { methods += new qt_gsi::GenericMethod ("valueAtIndex", "@brief Method void QMetaSequence::valueAtIndex(const void *container, qsizetype index, void *result)\n", true, &_init_f_valueAtIndex_c4033, &_call_f_valueAtIndex_c4033); methods += new qt_gsi::GenericMethod ("valueAtIterator", "@brief Method void QMetaSequence::valueAtIterator(const void *iterator, void *result)\n", true, &_init_f_valueAtIterator_c2699, &_call_f_valueAtIterator_c2699); methods += new qt_gsi::GenericMethod ("valueMetaType", "@brief Method QMetaType QMetaSequence::valueMetaType()\n", true, &_init_f_valueMetaType_c0, &_call_f_valueMetaType_c0); + methods += gsi::method_ext("==", &::op_QMetaSequence_operator_eq__eq__5112, gsi::arg ("b"), "@brief Operator bool ::operator==(const QMetaSequence &a, const QMetaSequence &b)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QMetaSequence_operator_excl__eq__5112, gsi::arg ("b"), "@brief Operator bool ::operator!=(const QMetaSequence &a, const QMetaSequence &b)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtCore/gsiDeclQMetaType.cc b/src/gsiqt/qt6/QtCore/gsiDeclQMetaType.cc index a19f0e64db..42e1c27131 100644 --- a/src/gsiqt/qt6/QtCore/gsiDeclQMetaType.cc +++ b/src/gsiqt/qt6/QtCore/gsiDeclQMetaType.cc @@ -1069,6 +1069,16 @@ static void _call_f_view_4440 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi } +// bool ::operator==(QMetaType a, QMetaType b) +static bool op_QMetaType_operator_eq__eq__2544(QMetaType *_self, QMetaType b) { + return operator==(*_self, b); +} + +// bool ::operator!=(QMetaType a, QMetaType b) +static bool op_QMetaType_operator_excl__eq__2544(QMetaType *_self, QMetaType b) { + return operator!=(*_self, b); +} + namespace gsi { @@ -1125,6 +1135,8 @@ static gsi::Methods methods_QMetaType () { methods += new qt_gsi::GenericStaticMethod ("unregisterMetaType", "@brief Static method void QMetaType::unregisterMetaType(QMetaType type)\nThis method is static and can be called without an instance.", &_init_f_unregisterMetaType_1326, &_call_f_unregisterMetaType_1326); methods += new qt_gsi::GenericStaticMethod ("unregisterMutableViewFunction", "@brief Static method void QMetaType::unregisterMutableViewFunction(QMetaType from, QMetaType to)\nThis method is static and can be called without an instance.", &_init_f_unregisterMutableViewFunction_2544, &_call_f_unregisterMutableViewFunction_2544); methods += new qt_gsi::GenericStaticMethod ("view", "@brief Static method bool QMetaType::view(QMetaType fromType, void *from, QMetaType toType, void *to)\nThis method is static and can be called without an instance.", &_init_f_view_4440, &_call_f_view_4440); + methods += gsi::method_ext("==", &::op_QMetaType_operator_eq__eq__2544, gsi::arg ("b"), "@brief Operator bool ::operator==(QMetaType a, QMetaType b)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QMetaType_operator_excl__eq__2544, gsi::arg ("b"), "@brief Operator bool ::operator!=(QMetaType a, QMetaType b)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtCore/gsiDeclQOperatingSystemVersion.cc b/src/gsiqt/qt6/QtCore/gsiDeclQOperatingSystemVersion.cc index 27476e8f51..e83e82717d 100644 --- a/src/gsiqt/qt6/QtCore/gsiDeclQOperatingSystemVersion.cc +++ b/src/gsiqt/qt6/QtCore/gsiDeclQOperatingSystemVersion.cc @@ -199,6 +199,26 @@ static void _call_f_currentType_0 (const qt_gsi::GenericStaticMethod * /*decl*/, } +// bool ::operator>(const QOperatingSystemVersion &lhs, const QOperatingSystemVersion &rhs) +static bool op_QOperatingSystemVersion_operator_gt__7328(const QOperatingSystemVersion *_self, const QOperatingSystemVersion &rhs) { + return operator>(*_self, rhs); +} + +// bool ::operator>=(const QOperatingSystemVersion &lhs, const QOperatingSystemVersion &rhs) +static bool op_QOperatingSystemVersion_operator_gt__eq__7328(const QOperatingSystemVersion *_self, const QOperatingSystemVersion &rhs) { + return operator>=(*_self, rhs); +} + +// bool ::operator<(const QOperatingSystemVersion &lhs, const QOperatingSystemVersion &rhs) +static bool op_QOperatingSystemVersion_operator_lt__7328(const QOperatingSystemVersion *_self, const QOperatingSystemVersion &rhs) { + return operator<(*_self, rhs); +} + +// bool ::operator<=(const QOperatingSystemVersion &lhs, const QOperatingSystemVersion &rhs) +static bool op_QOperatingSystemVersion_operator_lt__eq__7328(const QOperatingSystemVersion *_self, const QOperatingSystemVersion &rhs) { + return operator<=(*_self, rhs); +} + namespace gsi { @@ -215,6 +235,10 @@ static gsi::Methods methods_QOperatingSystemVersion () { methods += new qt_gsi::GenericMethod ("version", "@brief Method QVersionNumber QOperatingSystemVersion::version()\n", true, &_init_f_version_c0, &_call_f_version_c0); methods += new qt_gsi::GenericStaticMethod ("current", "@brief Static method QOperatingSystemVersion QOperatingSystemVersion::current()\nThis method is static and can be called without an instance.", &_init_f_current_0, &_call_f_current_0); methods += new qt_gsi::GenericStaticMethod ("currentType", "@brief Static method QOperatingSystemVersion::OSType QOperatingSystemVersion::currentType()\nThis method is static and can be called without an instance.", &_init_f_currentType_0, &_call_f_currentType_0); + methods += gsi::method_ext(">", &::op_QOperatingSystemVersion_operator_gt__7328, gsi::arg ("rhs"), "@brief Operator bool ::operator>(const QOperatingSystemVersion &lhs, const QOperatingSystemVersion &rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext(">=", &::op_QOperatingSystemVersion_operator_gt__eq__7328, gsi::arg ("rhs"), "@brief Operator bool ::operator>=(const QOperatingSystemVersion &lhs, const QOperatingSystemVersion &rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("<", &::op_QOperatingSystemVersion_operator_lt__7328, gsi::arg ("rhs"), "@brief Operator bool ::operator<(const QOperatingSystemVersion &lhs, const QOperatingSystemVersion &rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("<=", &::op_QOperatingSystemVersion_operator_lt__eq__7328, gsi::arg ("rhs"), "@brief Operator bool ::operator<=(const QOperatingSystemVersion &lhs, const QOperatingSystemVersion &rhs)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtCore/gsiDeclQPartialOrdering.cc b/src/gsiqt/qt6/QtCore/gsiDeclQPartialOrdering.cc index 84c9bd2c89..0e78d13ca2 100644 --- a/src/gsiqt/qt6/QtCore/gsiDeclQPartialOrdering.cc +++ b/src/gsiqt/qt6/QtCore/gsiDeclQPartialOrdering.cc @@ -35,12 +35,24 @@ // ----------------------------------------------------------------------- // class QPartialOrdering +// bool ::operator==(QPartialOrdering p1, QPartialOrdering p2) +static bool op_QPartialOrdering_operator_eq__eq__4012(QPartialOrdering *_self, QPartialOrdering p2) { + return operator==(*_self, p2); +} + +// bool ::operator!=(QPartialOrdering p1, QPartialOrdering p2) +static bool op_QPartialOrdering_operator_excl__eq__4012(QPartialOrdering *_self, QPartialOrdering p2) { + return operator!=(*_self, p2); +} + namespace gsi { static gsi::Methods methods_QPartialOrdering () { gsi::Methods methods; + methods += gsi::method_ext("==", &::op_QPartialOrdering_operator_eq__eq__4012, gsi::arg ("p2"), "@brief Operator bool ::operator==(QPartialOrdering p1, QPartialOrdering p2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QPartialOrdering_operator_excl__eq__4012, gsi::arg ("p2"), "@brief Operator bool ::operator!=(QPartialOrdering p1, QPartialOrdering p2)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtCore/gsiDeclQPoint.cc b/src/gsiqt/qt6/QtCore/gsiDeclQPoint.cc index 06e9392f0a..7ad8be31ee 100644 --- a/src/gsiqt/qt6/QtCore/gsiDeclQPoint.cc +++ b/src/gsiqt/qt6/QtCore/gsiDeclQPoint.cc @@ -354,6 +354,56 @@ static void _call_f_dotProduct_3724 (const qt_gsi::GenericStaticMethod * /*decl* } +// bool ::operator==(const QPoint &p1, const QPoint &p2) +static bool op_QPoint_operator_eq__eq__3724(const QPoint *_self, const QPoint &p2) { + return operator==(*_self, p2); +} + +// bool ::operator!=(const QPoint &p1, const QPoint &p2) +static bool op_QPoint_operator_excl__eq__3724(const QPoint *_self, const QPoint &p2) { + return operator!=(*_self, p2); +} + +// QPoint ::operator+(const QPoint &p1, const QPoint &p2) +static QPoint op_QPoint_operator_plus__3724(const QPoint *_self, const QPoint &p2) { + return operator+(*_self, p2); +} + +// QPoint ::operator-(const QPoint &p1, const QPoint &p2) +static QPoint op_QPoint_operator_minus__3724(const QPoint *_self, const QPoint &p2) { + return operator-(*_self, p2); +} + +// QPoint ::operator*(const QPoint &p, float factor) +static QPoint op_QPoint_operator_star__2778(const QPoint *_self, float factor) { + return operator*(*_self, factor); +} + +// QPoint ::operator*(const QPoint &p, double factor) +static QPoint op_QPoint_operator_star__2879(const QPoint *_self, double factor) { + return operator*(*_self, factor); +} + +// QPoint ::operator*(const QPoint &p, int factor) +static QPoint op_QPoint_operator_star__2575(const QPoint *_self, int factor) { + return operator*(*_self, factor); +} + +// QPoint ::operator+(const QPoint &p) +static QPoint op_QPoint_operator_plus__1916(const QPoint *_self) { + return operator+(*_self); +} + +// QPoint ::operator-(const QPoint &p) +static QPoint op_QPoint_operator_minus__1916(const QPoint *_self) { + return operator-(*_self); +} + +// QPoint ::operator/(const QPoint &p, qreal c) +static QPoint op_QPoint_operator_slash__2777(const QPoint *_self, qreal c) { + return operator/(*_self, c); +} + namespace gsi { @@ -378,6 +428,16 @@ static gsi::Methods methods_QPoint () { methods += new qt_gsi::GenericMethod (":x", "@brief Method int QPoint::x()\n", true, &_init_f_x_c0, &_call_f_x_c0); methods += new qt_gsi::GenericMethod (":y", "@brief Method int QPoint::y()\n", true, &_init_f_y_c0, &_call_f_y_c0); methods += new qt_gsi::GenericStaticMethod ("dotProduct", "@brief Static method int QPoint::dotProduct(const QPoint &p1, const QPoint &p2)\nThis method is static and can be called without an instance.", &_init_f_dotProduct_3724, &_call_f_dotProduct_3724); + methods += gsi::method_ext("==", &::op_QPoint_operator_eq__eq__3724, gsi::arg ("p2"), "@brief Operator bool ::operator==(const QPoint &p1, const QPoint &p2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QPoint_operator_excl__eq__3724, gsi::arg ("p2"), "@brief Operator bool ::operator!=(const QPoint &p1, const QPoint &p2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("+", &::op_QPoint_operator_plus__3724, gsi::arg ("p2"), "@brief Operator QPoint ::operator+(const QPoint &p1, const QPoint &p2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("-", &::op_QPoint_operator_minus__3724, gsi::arg ("p2"), "@brief Operator QPoint ::operator-(const QPoint &p1, const QPoint &p2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("*", &::op_QPoint_operator_star__2778, gsi::arg ("factor"), "@brief Operator QPoint ::operator*(const QPoint &p, float factor)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("*", &::op_QPoint_operator_star__2879, gsi::arg ("factor"), "@brief Operator QPoint ::operator*(const QPoint &p, double factor)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("*", &::op_QPoint_operator_star__2575, gsi::arg ("factor"), "@brief Operator QPoint ::operator*(const QPoint &p, int factor)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("+", &::op_QPoint_operator_plus__1916, "@brief Operator QPoint ::operator+(const QPoint &p)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("-", &::op_QPoint_operator_minus__1916, "@brief Operator QPoint ::operator-(const QPoint &p)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("/", &::op_QPoint_operator_slash__2777, gsi::arg ("c"), "@brief Operator QPoint ::operator/(const QPoint &p, qreal c)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtCore/gsiDeclQPointF.cc b/src/gsiqt/qt6/QtCore/gsiDeclQPointF.cc index 0b1cc2dfab..507cf02d3a 100644 --- a/src/gsiqt/qt6/QtCore/gsiDeclQPointF.cc +++ b/src/gsiqt/qt6/QtCore/gsiDeclQPointF.cc @@ -350,6 +350,46 @@ static void _call_f_dotProduct_3864 (const qt_gsi::GenericStaticMethod * /*decl* } +// bool ::operator==(const QPointF &p1, const QPointF &p2) +static bool op_QPointF_operator_eq__eq__3864u1(const QPointF *_self, const QPointF &p2) { + return operator==(*_self, p2); +} + +// bool ::operator!=(const QPointF &p1, const QPointF &p2) +static bool op_QPointF_operator_excl__eq__3864u1(const QPointF *_self, const QPointF &p2) { + return operator!=(*_self, p2); +} + +// QPointF ::operator+(const QPointF &p1, const QPointF &p2) +static QPointF op_QPointF_operator_plus__3864(const QPointF *_self, const QPointF &p2) { + return operator+(*_self, p2); +} + +// QPointF ::operator-(const QPointF &p1, const QPointF &p2) +static QPointF op_QPointF_operator_minus__3864(const QPointF *_self, const QPointF &p2) { + return operator-(*_self, p2); +} + +// QPointF ::operator*(const QPointF &p, qreal c) +static QPointF op_QPointF_operator_star__2847(const QPointF *_self, qreal c) { + return operator*(*_self, c); +} + +// QPointF ::operator+(const QPointF &p) +static QPointF op_QPointF_operator_plus__1986(const QPointF *_self) { + return operator+(*_self); +} + +// QPointF ::operator-(const QPointF &p) +static QPointF op_QPointF_operator_minus__1986(const QPointF *_self) { + return operator-(*_self); +} + +// QPointF ::operator/(const QPointF &p, qreal divisor) +static QPointF op_QPointF_operator_slash__2847(const QPointF *_self, qreal divisor) { + return operator/(*_self, divisor); +} + namespace gsi { @@ -374,6 +414,14 @@ static gsi::Methods methods_QPointF () { methods += new qt_gsi::GenericMethod (":x", "@brief Method double QPointF::x()\n", true, &_init_f_x_c0, &_call_f_x_c0); methods += new qt_gsi::GenericMethod (":y", "@brief Method double QPointF::y()\n", true, &_init_f_y_c0, &_call_f_y_c0); methods += new qt_gsi::GenericStaticMethod ("dotProduct", "@brief Static method double QPointF::dotProduct(const QPointF &p1, const QPointF &p2)\nThis method is static and can be called without an instance.", &_init_f_dotProduct_3864, &_call_f_dotProduct_3864); + methods += gsi::method_ext("==", &::op_QPointF_operator_eq__eq__3864u1, gsi::arg ("p2"), "@brief Operator bool ::operator==(const QPointF &p1, const QPointF &p2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QPointF_operator_excl__eq__3864u1, gsi::arg ("p2"), "@brief Operator bool ::operator!=(const QPointF &p1, const QPointF &p2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("+", &::op_QPointF_operator_plus__3864, gsi::arg ("p2"), "@brief Operator QPointF ::operator+(const QPointF &p1, const QPointF &p2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("-", &::op_QPointF_operator_minus__3864, gsi::arg ("p2"), "@brief Operator QPointF ::operator-(const QPointF &p1, const QPointF &p2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("*", &::op_QPointF_operator_star__2847, gsi::arg ("c"), "@brief Operator QPointF ::operator*(const QPointF &p, qreal c)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("+", &::op_QPointF_operator_plus__1986, "@brief Operator QPointF ::operator+(const QPointF &p)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("-", &::op_QPointF_operator_minus__1986, "@brief Operator QPointF ::operator-(const QPointF &p)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("/", &::op_QPointF_operator_slash__2847, gsi::arg ("divisor"), "@brief Operator QPointF ::operator/(const QPointF &p, qreal divisor)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtCore/gsiDeclQRandomGenerator.cc b/src/gsiqt/qt6/QtCore/gsiDeclQRandomGenerator.cc index 96e2cff14c..0cc934e6d9 100644 --- a/src/gsiqt/qt6/QtCore/gsiDeclQRandomGenerator.cc +++ b/src/gsiqt/qt6/QtCore/gsiDeclQRandomGenerator.cc @@ -561,6 +561,11 @@ static void _call_f_system_0 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi: } +// bool ::operator!=(const QRandomGenerator &rng1, const QRandomGenerator &rng2) +static bool op_QRandomGenerator_operator_excl__eq__5768(const QRandomGenerator *_self, const QRandomGenerator &rng2) { + return operator!=(*_self, rng2); +} + namespace gsi { @@ -595,6 +600,7 @@ static gsi::Methods methods_QRandomGenerator () { methods += new qt_gsi::GenericStaticMethod ("min", "@brief Static method quint32 QRandomGenerator::min()\nThis method is static and can be called without an instance.", &_init_f_min_0, &_call_f_min_0); methods += new qt_gsi::GenericStaticMethod ("securelySeeded", "@brief Static method QRandomGenerator QRandomGenerator::securelySeeded()\nThis method is static and can be called without an instance.", &_init_f_securelySeeded_0, &_call_f_securelySeeded_0); methods += new qt_gsi::GenericStaticMethod ("system", "@brief Static method QRandomGenerator *QRandomGenerator::system()\nThis method is static and can be called without an instance.", &_init_f_system_0, &_call_f_system_0); + methods += gsi::method_ext("!=", &::op_QRandomGenerator_operator_excl__eq__5768, gsi::arg ("rng2"), "@brief Operator bool ::operator!=(const QRandomGenerator &rng1, const QRandomGenerator &rng2)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtCore/gsiDeclQRect.cc b/src/gsiqt/qt6/QtCore/gsiDeclQRect.cc index 8725498406..0763f2506c 100644 --- a/src/gsiqt/qt6/QtCore/gsiDeclQRect.cc +++ b/src/gsiqt/qt6/QtCore/gsiDeclQRect.cc @@ -1474,12 +1474,22 @@ static void _call_f_span_3724 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi // QRect ::operator+(const QRect &rectangle, const QMargins &margins) static QRect op_QRect_operator_plus__3799u1(const QRect *_self, const QMargins &margins) { - return ::operator+(*_self, margins); + return operator+(*_self, margins); } // QRect ::operator-(const QRect &lhs, const QMargins &rhs) static QRect op_QRect_operator_minus__3799(const QRect *_self, const QMargins &rhs) { - return ::operator-(*_self, rhs); + return operator-(*_self, rhs); +} + +// bool ::operator==(const QRect &r1, const QRect &r2) +static bool op_QRect_operator_eq__eq__3476(const QRect *_self, const QRect &r2) { + return operator==(*_self, r2); +} + +// bool ::operator!=(const QRect &r1, const QRect &r2) +static bool op_QRect_operator_excl__eq__3476(const QRect *_self, const QRect &r2) { + return operator!=(*_self, r2); } @@ -1563,6 +1573,8 @@ static gsi::Methods methods_QRect () { methods += new qt_gsi::GenericStaticMethod ("span", "@brief Static method QRect QRect::span(const QPoint &p1, const QPoint &p2)\nThis method is static and can be called without an instance.", &_init_f_span_3724, &_call_f_span_3724); methods += gsi::method_ext("+", &::op_QRect_operator_plus__3799u1, gsi::arg ("margins"), "@brief Operator QRect ::operator+(const QRect &rectangle, const QMargins &margins)\nThis is the mapping of the global operator to the instance method."); methods += gsi::method_ext("-", &::op_QRect_operator_minus__3799, gsi::arg ("rhs"), "@brief Operator QRect ::operator-(const QRect &lhs, const QMargins &rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("==", &::op_QRect_operator_eq__eq__3476, gsi::arg ("r2"), "@brief Operator bool ::operator==(const QRect &r1, const QRect &r2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QRect_operator_excl__eq__3476, gsi::arg ("r2"), "@brief Operator bool ::operator!=(const QRect &r1, const QRect &r2)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtCore/gsiDeclQRectF.cc b/src/gsiqt/qt6/QtCore/gsiDeclQRectF.cc index 74457a9a46..cb55ef3f78 100644 --- a/src/gsiqt/qt6/QtCore/gsiDeclQRectF.cc +++ b/src/gsiqt/qt6/QtCore/gsiDeclQRectF.cc @@ -1471,12 +1471,22 @@ static void _call_f_y_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi // QRectF ::operator+(const QRectF &lhs, const QMarginsF &rhs) static QRectF op_QRectF_operator_plus__3939u1(const QRectF *_self, const QMarginsF &rhs) { - return ::operator+(*_self, rhs); + return operator+(*_self, rhs); } // QRectF ::operator-(const QRectF &lhs, const QMarginsF &rhs) static QRectF op_QRectF_operator_minus__3939(const QRectF *_self, const QMarginsF &rhs) { - return ::operator-(*_self, rhs); + return operator-(*_self, rhs); +} + +// bool ::operator==(const QRectF &r1, const QRectF &r2) +static bool op_QRectF_operator_eq__eq__3616(const QRectF *_self, const QRectF &r2) { + return operator==(*_self, r2); +} + +// bool ::operator!=(const QRectF &r1, const QRectF &r2) +static bool op_QRectF_operator_excl__eq__3616(const QRectF *_self, const QRectF &r2) { + return operator!=(*_self, r2); } @@ -1561,6 +1571,8 @@ static gsi::Methods methods_QRectF () { methods += new qt_gsi::GenericMethod (":y", "@brief Method double QRectF::y()\n", true, &_init_f_y_c0, &_call_f_y_c0); methods += gsi::method_ext("+", &::op_QRectF_operator_plus__3939u1, gsi::arg ("rhs"), "@brief Operator QRectF ::operator+(const QRectF &lhs, const QMarginsF &rhs)\nThis is the mapping of the global operator to the instance method."); methods += gsi::method_ext("-", &::op_QRectF_operator_minus__3939, gsi::arg ("rhs"), "@brief Operator QRectF ::operator-(const QRectF &lhs, const QMarginsF &rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("==", &::op_QRectF_operator_eq__eq__3616, gsi::arg ("r2"), "@brief Operator bool ::operator==(const QRectF &r1, const QRectF &r2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QRectF_operator_excl__eq__3616, gsi::arg ("r2"), "@brief Operator bool ::operator!=(const QRectF &r1, const QRectF &r2)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtCore/gsiDeclQSize.cc b/src/gsiqt/qt6/QtCore/gsiDeclQSize.cc index 0701dc08c3..82ba30bd16 100644 --- a/src/gsiqt/qt6/QtCore/gsiDeclQSize.cc +++ b/src/gsiqt/qt6/QtCore/gsiDeclQSize.cc @@ -497,6 +497,36 @@ static void _call_f_width_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, } +// bool ::operator==(const QSize &s1, const QSize &s2) +static bool op_QSize_operator_eq__eq__3502(const QSize *_self, const QSize &s2) { + return operator==(*_self, s2); +} + +// bool ::operator!=(const QSize &s1, const QSize &s2) +static bool op_QSize_operator_excl__eq__3502(const QSize *_self, const QSize &s2) { + return operator!=(*_self, s2); +} + +// QSize ::operator+(const QSize &s1, const QSize &s2) +static QSize op_QSize_operator_plus__3502(const QSize *_self, const QSize &s2) { + return operator+(*_self, s2); +} + +// QSize ::operator-(const QSize &s1, const QSize &s2) +static QSize op_QSize_operator_minus__3502(const QSize *_self, const QSize &s2) { + return operator-(*_self, s2); +} + +// QSize ::operator*(const QSize &s, qreal c) +static QSize op_QSize_operator_star__2666(const QSize *_self, qreal c) { + return operator*(*_self, c); +} + +// QSize ::operator/(const QSize &s, qreal c) +static QSize op_QSize_operator_slash__2666(const QSize *_self, qreal c) { + return operator/(*_self, c); +} + namespace gsi { @@ -528,6 +558,12 @@ static gsi::Methods methods_QSize () { methods += new qt_gsi::GenericMethod ("transpose", "@brief Method void QSize::transpose()\n", false, &_init_f_transpose_0, &_call_f_transpose_0); methods += new qt_gsi::GenericMethod ("transposed", "@brief Method QSize QSize::transposed()\n", true, &_init_f_transposed_c0, &_call_f_transposed_c0); methods += new qt_gsi::GenericMethod (":width", "@brief Method int QSize::width()\n", true, &_init_f_width_c0, &_call_f_width_c0); + methods += gsi::method_ext("==", &::op_QSize_operator_eq__eq__3502, gsi::arg ("s2"), "@brief Operator bool ::operator==(const QSize &s1, const QSize &s2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QSize_operator_excl__eq__3502, gsi::arg ("s2"), "@brief Operator bool ::operator!=(const QSize &s1, const QSize &s2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("+", &::op_QSize_operator_plus__3502, gsi::arg ("s2"), "@brief Operator QSize ::operator+(const QSize &s1, const QSize &s2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("-", &::op_QSize_operator_minus__3502, gsi::arg ("s2"), "@brief Operator QSize ::operator-(const QSize &s1, const QSize &s2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("*", &::op_QSize_operator_star__2666, gsi::arg ("c"), "@brief Operator QSize ::operator*(const QSize &s, qreal c)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("/", &::op_QSize_operator_slash__2666, gsi::arg ("c"), "@brief Operator QSize ::operator/(const QSize &s, qreal c)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtCore/gsiDeclQSizeF.cc b/src/gsiqt/qt6/QtCore/gsiDeclQSizeF.cc index c2df92947f..3f893912d6 100644 --- a/src/gsiqt/qt6/QtCore/gsiDeclQSizeF.cc +++ b/src/gsiqt/qt6/QtCore/gsiDeclQSizeF.cc @@ -532,6 +532,36 @@ static void _call_f_width_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, } +// bool ::operator==(const QSizeF &s1, const QSizeF &s2) +static bool op_QSizeF_operator_eq__eq__3642(const QSizeF *_self, const QSizeF &s2) { + return operator==(*_self, s2); +} + +// bool ::operator!=(const QSizeF &s1, const QSizeF &s2) +static bool op_QSizeF_operator_excl__eq__3642(const QSizeF *_self, const QSizeF &s2) { + return operator!=(*_self, s2); +} + +// QSizeF ::operator+(const QSizeF &s1, const QSizeF &s2) +static QSizeF op_QSizeF_operator_plus__3642(const QSizeF *_self, const QSizeF &s2) { + return operator+(*_self, s2); +} + +// QSizeF ::operator-(const QSizeF &s1, const QSizeF &s2) +static QSizeF op_QSizeF_operator_minus__3642(const QSizeF *_self, const QSizeF &s2) { + return operator-(*_self, s2); +} + +// QSizeF ::operator*(const QSizeF &s, qreal c) +static QSizeF op_QSizeF_operator_star__2736(const QSizeF *_self, qreal c) { + return operator*(*_self, c); +} + +// QSizeF ::operator/(const QSizeF &s, qreal c) +static QSizeF op_QSizeF_operator_slash__2736(const QSizeF *_self, qreal c) { + return operator/(*_self, c); +} + namespace gsi { @@ -565,6 +595,12 @@ static gsi::Methods methods_QSizeF () { methods += new qt_gsi::GenericMethod ("transpose", "@brief Method void QSizeF::transpose()\n", false, &_init_f_transpose_0, &_call_f_transpose_0); methods += new qt_gsi::GenericMethod ("transposed", "@brief Method QSizeF QSizeF::transposed()\n", true, &_init_f_transposed_c0, &_call_f_transposed_c0); methods += new qt_gsi::GenericMethod (":width", "@brief Method double QSizeF::width()\n", true, &_init_f_width_c0, &_call_f_width_c0); + methods += gsi::method_ext("==", &::op_QSizeF_operator_eq__eq__3642, gsi::arg ("s2"), "@brief Operator bool ::operator==(const QSizeF &s1, const QSizeF &s2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QSizeF_operator_excl__eq__3642, gsi::arg ("s2"), "@brief Operator bool ::operator!=(const QSizeF &s1, const QSizeF &s2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("+", &::op_QSizeF_operator_plus__3642, gsi::arg ("s2"), "@brief Operator QSizeF ::operator+(const QSizeF &s1, const QSizeF &s2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("-", &::op_QSizeF_operator_minus__3642, gsi::arg ("s2"), "@brief Operator QSizeF ::operator-(const QSizeF &s1, const QSizeF &s2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("*", &::op_QSizeF_operator_star__2736, gsi::arg ("c"), "@brief Operator QSizeF ::operator*(const QSizeF &s, qreal c)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("/", &::op_QSizeF_operator_slash__2736, gsi::arg ("c"), "@brief Operator QSizeF ::operator/(const QSizeF &s, qreal c)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtCore/gsiDeclQSocketDescriptor.cc b/src/gsiqt/qt6/QtCore/gsiDeclQSocketDescriptor.cc index 1e0ed010e3..b29f74af19 100644 --- a/src/gsiqt/qt6/QtCore/gsiDeclQSocketDescriptor.cc +++ b/src/gsiqt/qt6/QtCore/gsiDeclQSocketDescriptor.cc @@ -69,6 +69,16 @@ static void _call_f_isValid_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cl } +// bool ::operator==(QSocketDescriptor lhs, QSocketDescriptor rhs) +static bool op_QSocketDescriptor_operator_eq__eq__4270(QSocketDescriptor *_self, QSocketDescriptor rhs) { + return operator==(*_self, rhs); +} + +// bool ::operator!=(QSocketDescriptor lhs, QSocketDescriptor rhs) +static bool op_QSocketDescriptor_operator_excl__eq__4270(QSocketDescriptor *_self, QSocketDescriptor rhs) { + return operator!=(*_self, rhs); +} + namespace gsi { @@ -77,6 +87,8 @@ static gsi::Methods methods_QSocketDescriptor () { gsi::Methods methods; methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QSocketDescriptor::QSocketDescriptor(QSocketDescriptor::DescriptorType descriptor)\nThis method creates an object of class QSocketDescriptor.", &_init_ctor_QSocketDescriptor_3778, &_call_ctor_QSocketDescriptor_3778); methods += new qt_gsi::GenericMethod ("isValid?", "@brief Method bool QSocketDescriptor::isValid()\n", true, &_init_f_isValid_c0, &_call_f_isValid_c0); + methods += gsi::method_ext("==", &::op_QSocketDescriptor_operator_eq__eq__4270, gsi::arg ("rhs"), "@brief Operator bool ::operator==(QSocketDescriptor lhs, QSocketDescriptor rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QSocketDescriptor_operator_excl__eq__4270, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(QSocketDescriptor lhs, QSocketDescriptor rhs)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtCore/gsiDeclQStorageInfo.cc b/src/gsiqt/qt6/QtCore/gsiDeclQStorageInfo.cc index ec8f24733c..594be186b7 100644 --- a/src/gsiqt/qt6/QtCore/gsiDeclQStorageInfo.cc +++ b/src/gsiqt/qt6/QtCore/gsiDeclQStorageInfo.cc @@ -423,6 +423,16 @@ static void _call_f_root_0 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::S } +// bool ::operator==(const QStorageInfo &first, const QStorageInfo &second) +static bool op_QStorageInfo_operator_eq__eq__4922(const QStorageInfo *_self, const QStorageInfo &second) { + return operator==(*_self, second); +} + +// bool ::operator!=(const QStorageInfo &first, const QStorageInfo &second) +static bool op_QStorageInfo_operator_excl__eq__4922(const QStorageInfo *_self, const QStorageInfo &second) { + return operator!=(*_self, second); +} + namespace gsi { @@ -453,6 +463,8 @@ static gsi::Methods methods_QStorageInfo () { methods += new qt_gsi::GenericMethod ("swap", "@brief Method void QStorageInfo::swap(QStorageInfo &other)\n", false, &_init_f_swap_1820, &_call_f_swap_1820); methods += new qt_gsi::GenericStaticMethod ("mountedVolumes", "@brief Static method QList QStorageInfo::mountedVolumes()\nThis method is static and can be called without an instance.", &_init_f_mountedVolumes_0, &_call_f_mountedVolumes_0); methods += new qt_gsi::GenericStaticMethod ("root", "@brief Static method QStorageInfo QStorageInfo::root()\nThis method is static and can be called without an instance.", &_init_f_root_0, &_call_f_root_0); + methods += gsi::method_ext("==", &::op_QStorageInfo_operator_eq__eq__4922, gsi::arg ("second"), "@brief Operator bool ::operator==(const QStorageInfo &first, const QStorageInfo &second)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QStorageInfo_operator_excl__eq__4922, gsi::arg ("second"), "@brief Operator bool ::operator!=(const QStorageInfo &first, const QStorageInfo &second)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtCore/gsiDeclQTime.cc b/src/gsiqt/qt6/QtCore/gsiDeclQTime.cc index 7e61bd8649..f0b7b06c49 100644 --- a/src/gsiqt/qt6/QtCore/gsiDeclQTime.cc +++ b/src/gsiqt/qt6/QtCore/gsiDeclQTime.cc @@ -431,6 +431,36 @@ static void _call_f_isValid_2744 (const qt_gsi::GenericStaticMethod * /*decl*/, } +// bool ::operator==(QTime lhs, QTime rhs) +static bool op_QTime_operator_eq__eq__1724(QTime *_self, QTime rhs) { + return operator==(*_self, rhs); +} + +// bool ::operator!=(QTime lhs, QTime rhs) +static bool op_QTime_operator_excl__eq__1724(QTime *_self, QTime rhs) { + return operator!=(*_self, rhs); +} + +// bool ::operator<(QTime lhs, QTime rhs) +static bool op_QTime_operator_lt__1724(QTime *_self, QTime rhs) { + return operator<(*_self, rhs); +} + +// bool ::operator<=(QTime lhs, QTime rhs) +static bool op_QTime_operator_lt__eq__1724(QTime *_self, QTime rhs) { + return operator<=(*_self, rhs); +} + +// bool ::operator>(QTime lhs, QTime rhs) +static bool op_QTime_operator_gt__1724(QTime *_self, QTime rhs) { + return operator>(*_self, rhs); +} + +// bool ::operator>=(QTime lhs, QTime rhs) +static bool op_QTime_operator_gt__eq__1724(QTime *_self, QTime rhs) { + return operator>=(*_self, rhs); +} + namespace gsi { @@ -458,6 +488,12 @@ static gsi::Methods methods_QTime () { methods += new qt_gsi::GenericStaticMethod ("fromString", "@brief Static method QTime QTime::fromString(const QString &string, Qt::DateFormat format)\nThis method is static and can be called without an instance.", &_init_f_fromString_3665, &_call_f_fromString_3665); methods += new qt_gsi::GenericStaticMethod ("fromString", "@brief Static method QTime QTime::fromString(const QString &string, const QString &format)\nThis method is static and can be called without an instance.", &_init_f_fromString_3942, &_call_f_fromString_3942); methods += new qt_gsi::GenericStaticMethod ("isValid?", "@brief Static method bool QTime::isValid(int h, int m, int s, int ms)\nThis method is static and can be called without an instance.", &_init_f_isValid_2744, &_call_f_isValid_2744); + methods += gsi::method_ext("==", &::op_QTime_operator_eq__eq__1724, gsi::arg ("rhs"), "@brief Operator bool ::operator==(QTime lhs, QTime rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QTime_operator_excl__eq__1724, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(QTime lhs, QTime rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("<", &::op_QTime_operator_lt__1724, gsi::arg ("rhs"), "@brief Operator bool ::operator<(QTime lhs, QTime rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("<=", &::op_QTime_operator_lt__eq__1724, gsi::arg ("rhs"), "@brief Operator bool ::operator<=(QTime lhs, QTime rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext(">", &::op_QTime_operator_gt__1724, gsi::arg ("rhs"), "@brief Operator bool ::operator>(QTime lhs, QTime rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext(">=", &::op_QTime_operator_gt__eq__1724, gsi::arg ("rhs"), "@brief Operator bool ::operator>=(QTime lhs, QTime rhs)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtCore/gsiDeclQTypeRevision.cc b/src/gsiqt/qt6/QtCore/gsiDeclQTypeRevision.cc index cb45aca927..8c98f218c6 100644 --- a/src/gsiqt/qt6/QtCore/gsiDeclQTypeRevision.cc +++ b/src/gsiqt/qt6/QtCore/gsiDeclQTypeRevision.cc @@ -140,6 +140,36 @@ static void _call_f_zero_0 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::S } +// bool ::operator==(QTypeRevision lhs, QTypeRevision rhs) +static bool op_QTypeRevision_operator_eq__eq__3456(QTypeRevision *_self, QTypeRevision rhs) { + return operator==(*_self, rhs); +} + +// bool ::operator!=(QTypeRevision lhs, QTypeRevision rhs) +static bool op_QTypeRevision_operator_excl__eq__3456(QTypeRevision *_self, QTypeRevision rhs) { + return operator!=(*_self, rhs); +} + +// bool ::operator<(QTypeRevision lhs, QTypeRevision rhs) +static bool op_QTypeRevision_operator_lt__3456(QTypeRevision *_self, QTypeRevision rhs) { + return operator<(*_self, rhs); +} + +// bool ::operator>(QTypeRevision lhs, QTypeRevision rhs) +static bool op_QTypeRevision_operator_gt__3456(QTypeRevision *_self, QTypeRevision rhs) { + return operator>(*_self, rhs); +} + +// bool ::operator<=(QTypeRevision lhs, QTypeRevision rhs) +static bool op_QTypeRevision_operator_lt__eq__3456(QTypeRevision *_self, QTypeRevision rhs) { + return operator<=(*_self, rhs); +} + +// bool ::operator>=(QTypeRevision lhs, QTypeRevision rhs) +static bool op_QTypeRevision_operator_gt__eq__3456(QTypeRevision *_self, QTypeRevision rhs) { + return operator>=(*_self, rhs); +} + namespace gsi { @@ -153,6 +183,12 @@ static gsi::Methods methods_QTypeRevision () { methods += new qt_gsi::GenericMethod ("majorVersion", "@brief Method quint8 QTypeRevision::majorVersion()\n", true, &_init_f_majorVersion_c0, &_call_f_majorVersion_c0); methods += new qt_gsi::GenericMethod ("minorVersion", "@brief Method quint8 QTypeRevision::minorVersion()\n", true, &_init_f_minorVersion_c0, &_call_f_minorVersion_c0); methods += new qt_gsi::GenericStaticMethod ("zero", "@brief Static method QTypeRevision QTypeRevision::zero()\nThis method is static and can be called without an instance.", &_init_f_zero_0, &_call_f_zero_0); + methods += gsi::method_ext("==", &::op_QTypeRevision_operator_eq__eq__3456, gsi::arg ("rhs"), "@brief Operator bool ::operator==(QTypeRevision lhs, QTypeRevision rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QTypeRevision_operator_excl__eq__3456, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(QTypeRevision lhs, QTypeRevision rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("<", &::op_QTypeRevision_operator_lt__3456, gsi::arg ("rhs"), "@brief Operator bool ::operator<(QTypeRevision lhs, QTypeRevision rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext(">", &::op_QTypeRevision_operator_gt__3456, gsi::arg ("rhs"), "@brief Operator bool ::operator>(QTypeRevision lhs, QTypeRevision rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("<=", &::op_QTypeRevision_operator_lt__eq__3456, gsi::arg ("rhs"), "@brief Operator bool ::operator<=(QTypeRevision lhs, QTypeRevision rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext(">=", &::op_QTypeRevision_operator_gt__eq__3456, gsi::arg ("rhs"), "@brief Operator bool ::operator>=(QTypeRevision lhs, QTypeRevision rhs)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtCore/gsiDeclQVersionNumber.cc b/src/gsiqt/qt6/QtCore/gsiDeclQVersionNumber.cc index 7009d2356b..50ce0e5769 100644 --- a/src/gsiqt/qt6/QtCore/gsiDeclQVersionNumber.cc +++ b/src/gsiqt/qt6/QtCore/gsiDeclQVersionNumber.cc @@ -374,6 +374,36 @@ static void _call_f_fromString_2870 (const qt_gsi::GenericStaticMethod * /*decl* } +// bool ::operator>(const QVersionNumber &lhs, const QVersionNumber &rhs) +static bool op_QVersionNumber_operator_gt__5398(const QVersionNumber *_self, const QVersionNumber &rhs) { + return operator>(*_self, rhs); +} + +// bool ::operator>=(const QVersionNumber &lhs, const QVersionNumber &rhs) +static bool op_QVersionNumber_operator_gt__eq__5398(const QVersionNumber *_self, const QVersionNumber &rhs) { + return operator>=(*_self, rhs); +} + +// bool ::operator<(const QVersionNumber &lhs, const QVersionNumber &rhs) +static bool op_QVersionNumber_operator_lt__5398(const QVersionNumber *_self, const QVersionNumber &rhs) { + return operator<(*_self, rhs); +} + +// bool ::operator<=(const QVersionNumber &lhs, const QVersionNumber &rhs) +static bool op_QVersionNumber_operator_lt__eq__5398(const QVersionNumber *_self, const QVersionNumber &rhs) { + return operator<=(*_self, rhs); +} + +// bool ::operator==(const QVersionNumber &lhs, const QVersionNumber &rhs) +static bool op_QVersionNumber_operator_eq__eq__5398(const QVersionNumber *_self, const QVersionNumber &rhs) { + return operator==(*_self, rhs); +} + +// bool ::operator!=(const QVersionNumber &lhs, const QVersionNumber &rhs) +static bool op_QVersionNumber_operator_excl__eq__5398(const QVersionNumber *_self, const QVersionNumber &rhs) { + return operator!=(*_self, rhs); +} + namespace gsi { @@ -399,6 +429,12 @@ static gsi::Methods methods_QVersionNumber () { methods += new qt_gsi::GenericStaticMethod ("commonPrefix", "@brief Static method QVersionNumber QVersionNumber::commonPrefix(const QVersionNumber &v1, const QVersionNumber &v2)\nThis method is static and can be called without an instance.", &_init_f_commonPrefix_5398, &_call_f_commonPrefix_5398); methods += new qt_gsi::GenericStaticMethod ("compare", "@brief Static method int QVersionNumber::compare(const QVersionNumber &v1, const QVersionNumber &v2)\nThis method is static and can be called without an instance.", &_init_f_compare_5398, &_call_f_compare_5398); methods += new qt_gsi::GenericStaticMethod ("fromString", "@brief Static method QVersionNumber QVersionNumber::fromString(const QString &string, int *suffixIndex)\nThis method is static and can be called without an instance.", &_init_f_fromString_2870, &_call_f_fromString_2870); + methods += gsi::method_ext(">", &::op_QVersionNumber_operator_gt__5398, gsi::arg ("rhs"), "@brief Operator bool ::operator>(const QVersionNumber &lhs, const QVersionNumber &rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext(">=", &::op_QVersionNumber_operator_gt__eq__5398, gsi::arg ("rhs"), "@brief Operator bool ::operator>=(const QVersionNumber &lhs, const QVersionNumber &rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("<", &::op_QVersionNumber_operator_lt__5398, gsi::arg ("rhs"), "@brief Operator bool ::operator<(const QVersionNumber &lhs, const QVersionNumber &rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("<=", &::op_QVersionNumber_operator_lt__eq__5398, gsi::arg ("rhs"), "@brief Operator bool ::operator<=(const QVersionNumber &lhs, const QVersionNumber &rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("==", &::op_QVersionNumber_operator_eq__eq__5398, gsi::arg ("rhs"), "@brief Operator bool ::operator==(const QVersionNumber &lhs, const QVersionNumber &rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QVersionNumber_operator_excl__eq__5398, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(const QVersionNumber &lhs, const QVersionNumber &rhs)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtGui/gsiDeclQAccessible_State.cc b/src/gsiqt/qt6/QtGui/gsiDeclQAccessible_State.cc index 4e7d36089e..2bb955fad4 100644 --- a/src/gsiqt/qt6/QtGui/gsiDeclQAccessible_State.cc +++ b/src/gsiqt/qt6/QtGui/gsiDeclQAccessible_State.cc @@ -50,6 +50,11 @@ static void _call_ctor_QAccessible_State_0 (const qt_gsi::GenericStaticMethod * } +// bool ::operator==(const QAccessible::State &first, const QAccessible::State &second) +static bool op_QAccessible_State_operator_eq__eq__5950(const QAccessible::State *_self, const QAccessible::State &second) { + return operator==(*_self, second); +} + namespace gsi { @@ -57,6 +62,7 @@ namespace gsi static gsi::Methods methods_QAccessible_State () { gsi::Methods methods; methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QAccessible::State::State()\nThis method creates an object of class QAccessible::State.", &_init_ctor_QAccessible_State_0, &_call_ctor_QAccessible_State_0); + methods += gsi::method_ext("==", &::op_QAccessible_State_operator_eq__eq__5950, gsi::arg ("second"), "@brief Operator bool ::operator==(const QAccessible::State &first, const QAccessible::State &second)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtGui/gsiDeclQColorSpace.cc b/src/gsiqt/qt6/QtGui/gsiDeclQColorSpace.cc index 61ca60dfdf..9f4c83f3fb 100644 --- a/src/gsiqt/qt6/QtGui/gsiDeclQColorSpace.cc +++ b/src/gsiqt/qt6/QtGui/gsiDeclQColorSpace.cc @@ -648,6 +648,16 @@ static void _call_f_fromIccProfile_2309 (const qt_gsi::GenericStaticMethod * /*d } +// bool ::operator==(const QColorSpace &colorSpace1, const QColorSpace &colorSpace2) +static bool op_QColorSpace_operator_eq__eq__4686(const QColorSpace *_self, const QColorSpace &colorSpace2) { + return operator==(*_self, colorSpace2); +} + +// bool ::operator!=(const QColorSpace &colorSpace1, const QColorSpace &colorSpace2) +static bool op_QColorSpace_operator_excl__eq__4686(const QColorSpace *_self, const QColorSpace &colorSpace2) { + return operator!=(*_self, colorSpace2); +} + namespace gsi { @@ -683,6 +693,8 @@ static gsi::Methods methods_QColorSpace () { methods += new qt_gsi::GenericMethod ("withTransferFunction", "@brief Method QColorSpace QColorSpace::withTransferFunction(const QList &transferFunctionTable)\n", true, &_init_f_withTransferFunction_c2690, &_call_f_withTransferFunction_c2690); methods += new qt_gsi::GenericMethod ("withTransferFunctions", "@brief Method QColorSpace QColorSpace::withTransferFunctions(const QList &redTransferFunctionTable, const QList &greenTransferFunctionTable, const QList &blueTransferFunctionTable)\n", true, &_init_f_withTransferFunctions_c7854, &_call_f_withTransferFunctions_c7854); methods += new qt_gsi::GenericStaticMethod ("fromIccProfile", "@brief Static method QColorSpace QColorSpace::fromIccProfile(const QByteArray &iccProfile)\nThis method is static and can be called without an instance.", &_init_f_fromIccProfile_2309, &_call_f_fromIccProfile_2309); + methods += gsi::method_ext("==", &::op_QColorSpace_operator_eq__eq__4686, gsi::arg ("colorSpace2"), "@brief Operator bool ::operator==(const QColorSpace &colorSpace1, const QColorSpace &colorSpace2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QColorSpace_operator_excl__eq__4686, gsi::arg ("colorSpace2"), "@brief Operator bool ::operator!=(const QColorSpace &colorSpace1, const QColorSpace &colorSpace2)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtGui/gsiDeclQCursor.cc b/src/gsiqt/qt6/QtGui/gsiDeclQCursor.cc index ac77f86fe5..abc9bdd71e 100644 --- a/src/gsiqt/qt6/QtGui/gsiDeclQCursor.cc +++ b/src/gsiqt/qt6/QtGui/gsiDeclQCursor.cc @@ -441,6 +441,11 @@ static void _call_f_setPos_3119 (const qt_gsi::GenericStaticMethod * /*decl*/, g } +// bool ::operator!=(const QCursor &lhs, const QCursor &rhs) +static bool op_QCursor_operator_excl__eq__3956(const QCursor *_self, const QCursor &rhs) { + return operator!=(*_self, rhs); +} + namespace gsi { @@ -468,6 +473,7 @@ static gsi::Methods methods_QCursor () { methods += new qt_gsi::GenericStaticMethod ("setPos", "@brief Static method void QCursor::setPos(QScreen *screen, int x, int y)\nThis method is static and can be called without an instance.", &_init_f_setPos_2629, &_call_f_setPos_2629); methods += new qt_gsi::GenericStaticMethod ("setPos|pos=", "@brief Static method void QCursor::setPos(const QPoint &p)\nThis method is static and can be called without an instance.", &_init_f_setPos_1916, &_call_f_setPos_1916); methods += new qt_gsi::GenericStaticMethod ("setPos", "@brief Static method void QCursor::setPos(QScreen *screen, const QPoint &p)\nThis method is static and can be called without an instance.", &_init_f_setPos_3119, &_call_f_setPos_3119); + methods += gsi::method_ext("!=", &::op_QCursor_operator_excl__eq__3956, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(const QCursor &lhs, const QCursor &rhs)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtGui/gsiDeclQMatrix4x4.cc b/src/gsiqt/qt6/QtGui/gsiDeclQMatrix4x4.cc index acc2774ea2..b6ec973728 100644 --- a/src/gsiqt/qt6/QtGui/gsiDeclQMatrix4x4.cc +++ b/src/gsiqt/qt6/QtGui/gsiDeclQMatrix4x4.cc @@ -1321,52 +1321,52 @@ static void _call_f_viewport_5280 (const qt_gsi::GenericMethod * /*decl*/, void // QMatrix4x4 ::operator/(const QMatrix4x4 &matrix, float divisor) static QMatrix4x4 op_QMatrix4x4_operator_slash__3109(const QMatrix4x4 *_self, float divisor) { - return ::operator/(*_self, divisor); + return operator/(*_self, divisor); } // QMatrix4x4 ::operator+(const QMatrix4x4 &m1, const QMatrix4x4 &m2) static QMatrix4x4 op_QMatrix4x4_operator_plus__4386(const QMatrix4x4 *_self, const QMatrix4x4 &m2) { - return ::operator+(*_self, m2); + return operator+(*_self, m2); } // QMatrix4x4 ::operator-(const QMatrix4x4 &m1, const QMatrix4x4 &m2) static QMatrix4x4 op_QMatrix4x4_operator_minus__4386(const QMatrix4x4 *_self, const QMatrix4x4 &m2) { - return ::operator-(*_self, m2); + return operator-(*_self, m2); } // QMatrix4x4 ::operator*(const QMatrix4x4 &m1, const QMatrix4x4 &m2) static QMatrix4x4 op_QMatrix4x4_operator_star__4386(const QMatrix4x4 *_self, const QMatrix4x4 &m2) { - return ::operator*(*_self, m2); + return operator*(*_self, m2); } // QVector3D ::operator*(const QMatrix4x4 &matrix, const QVector3D &vector) static QVector3D op_QMatrix4x4_operator_star__4279(const QMatrix4x4 *_self, const QVector3D &vector) { - return ::operator*(*_self, vector); + return operator*(*_self, vector); } // QVector4D ::operator*(const QMatrix4x4 &matrix, const QVector4D &vector) static QVector4D op_QMatrix4x4_operator_star__4280(const QMatrix4x4 *_self, const QVector4D &vector) { - return ::operator*(*_self, vector); + return operator*(*_self, vector); } // QPoint ::operator*(const QMatrix4x4 &matrix, const QPoint &point) static QPoint op_QMatrix4x4_operator_star__4055(const QMatrix4x4 *_self, const QPoint &point) { - return ::operator*(*_self, point); + return operator*(*_self, point); } // QPointF ::operator*(const QMatrix4x4 &matrix, const QPointF &point) static QPointF op_QMatrix4x4_operator_star__4125(const QMatrix4x4 *_self, const QPointF &point) { - return ::operator*(*_self, point); + return operator*(*_self, point); } // QMatrix4x4 ::operator-(const QMatrix4x4 &matrix) static QMatrix4x4 op_QMatrix4x4_operator_minus__2247(const QMatrix4x4 *_self) { - return ::operator-(*_self); + return operator-(*_self); } // QMatrix4x4 ::operator*(const QMatrix4x4 &matrix, float factor) static QMatrix4x4 op_QMatrix4x4_operator_star__3109(const QMatrix4x4 *_self, float factor) { - return ::operator*(*_self, factor); + return operator*(*_self, factor); } diff --git a/src/gsiqt/qt6/QtGui/gsiDeclQPageLayout.cc b/src/gsiqt/qt6/QtGui/gsiDeclQPageLayout.cc index 90aebdf09a..fb0a7fd7fa 100644 --- a/src/gsiqt/qt6/QtGui/gsiDeclQPageLayout.cc +++ b/src/gsiqt/qt6/QtGui/gsiDeclQPageLayout.cc @@ -670,6 +670,16 @@ static void _call_f_units_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, } +// bool ::operator==(const QPageLayout &lhs, const QPageLayout &rhs) +static bool op_QPageLayout_operator_eq__eq__4718(const QPageLayout *_self, const QPageLayout &rhs) { + return operator==(*_self, rhs); +} + +// bool ::operator!=(const QPageLayout &lhs, const QPageLayout &rhs) +static bool op_QPageLayout_operator_excl__eq__4718(const QPageLayout *_self, const QPageLayout &rhs) { + return operator!=(*_self, rhs); +} + namespace gsi { @@ -711,6 +721,8 @@ static gsi::Methods methods_QPageLayout () { methods += new qt_gsi::GenericMethod ("setUnits|units=", "@brief Method void QPageLayout::setUnits(QPageLayout::Unit units)\n", false, &_init_f_setUnits_2068, &_call_f_setUnits_2068); methods += new qt_gsi::GenericMethod ("swap", "@brief Method void QPageLayout::swap(QPageLayout &other)\n", false, &_init_f_swap_1718, &_call_f_swap_1718); methods += new qt_gsi::GenericMethod (":units", "@brief Method QPageLayout::Unit QPageLayout::units()\n", true, &_init_f_units_c0, &_call_f_units_c0); + methods += gsi::method_ext("==", &::op_QPageLayout_operator_eq__eq__4718, gsi::arg ("rhs"), "@brief Operator bool ::operator==(const QPageLayout &lhs, const QPageLayout &rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QPageLayout_operator_excl__eq__4718, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(const QPageLayout &lhs, const QPageLayout &rhs)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtGui/gsiDeclQPageRanges.cc b/src/gsiqt/qt6/QtGui/gsiDeclQPageRanges.cc index ac0e68a099..e9e1ffd124 100644 --- a/src/gsiqt/qt6/QtGui/gsiDeclQPageRanges.cc +++ b/src/gsiqt/qt6/QtGui/gsiDeclQPageRanges.cc @@ -296,6 +296,16 @@ static void _call_f_fromString_2025 (const qt_gsi::GenericStaticMethod * /*decl* } +// bool ::operator==(const QPageRanges &lhs, const QPageRanges &rhs) +static bool op_QPageRanges_operator_eq__eq__4658(const QPageRanges *_self, const QPageRanges &rhs) { + return operator==(*_self, rhs); +} + +// bool ::operator!=(const QPageRanges &lhs, const QPageRanges &rhs) +static bool op_QPageRanges_operator_excl__eq__4658(const QPageRanges *_self, const QPageRanges &rhs) { + return operator!=(*_self, rhs); +} + namespace gsi { @@ -317,6 +327,8 @@ static gsi::Methods methods_QPageRanges () { methods += new qt_gsi::GenericMethod ("toRangeList", "@brief Method QList QPageRanges::toRangeList()\n", true, &_init_f_toRangeList_c0, &_call_f_toRangeList_c0); methods += new qt_gsi::GenericMethod ("toString", "@brief Method QString QPageRanges::toString()\n", true, &_init_f_toString_c0, &_call_f_toString_c0); methods += new qt_gsi::GenericStaticMethod ("fromString", "@brief Static method QPageRanges QPageRanges::fromString(const QString &ranges)\nThis method is static and can be called without an instance.", &_init_f_fromString_2025, &_call_f_fromString_2025); + methods += gsi::method_ext("==", &::op_QPageRanges_operator_eq__eq__4658, gsi::arg ("rhs"), "@brief Operator bool ::operator==(const QPageRanges &lhs, const QPageRanges &rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QPageRanges_operator_excl__eq__4658, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(const QPageRanges &lhs, const QPageRanges &rhs)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtGui/gsiDeclQPageSize.cc b/src/gsiqt/qt6/QtGui/gsiDeclQPageSize.cc index 1339dfebd7..8178366390 100644 --- a/src/gsiqt/qt6/QtGui/gsiDeclQPageSize.cc +++ b/src/gsiqt/qt6/QtGui/gsiDeclQPageSize.cc @@ -638,6 +638,16 @@ static void _call_f_windowsId_2390 (const qt_gsi::GenericStaticMethod * /*decl*/ } +// bool ::operator==(const QPageSize &lhs, const QPageSize &rhs) +static bool op_QPageSize_operator_eq__eq__4264(const QPageSize *_self, const QPageSize &rhs) { + return operator==(*_self, rhs); +} + +// bool ::operator!=(const QPageSize &lhs, const QPageSize &rhs) +static bool op_QPageSize_operator_excl__eq__4264(const QPageSize *_self, const QPageSize &rhs) { + return operator!=(*_self, rhs); +} + namespace gsi { @@ -676,6 +686,8 @@ static gsi::Methods methods_QPageSize () { methods += new qt_gsi::GenericStaticMethod ("sizePixels", "@brief Static method QSize QPageSize::sizePixels(QPageSize::PageSizeId pageSizeId, int resolution)\nThis method is static and can be called without an instance.", &_init_f_sizePixels_3049, &_call_f_sizePixels_3049); methods += new qt_gsi::GenericStaticMethod ("sizePoints", "@brief Static method QSize QPageSize::sizePoints(QPageSize::PageSizeId pageSizeId)\nThis method is static and can be called without an instance.", &_init_f_sizePoints_2390, &_call_f_sizePoints_2390); methods += new qt_gsi::GenericStaticMethod ("windowsId", "@brief Static method int QPageSize::windowsId(QPageSize::PageSizeId pageSizeId)\nThis method is static and can be called without an instance.", &_init_f_windowsId_2390, &_call_f_windowsId_2390); + methods += gsi::method_ext("==", &::op_QPageSize_operator_eq__eq__4264, gsi::arg ("rhs"), "@brief Operator bool ::operator==(const QPageSize &lhs, const QPageSize &rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QPageSize_operator_excl__eq__4264, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(const QPageSize &lhs, const QPageSize &rhs)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtGui/gsiDeclQPainterPath.cc b/src/gsiqt/qt6/QtGui/gsiDeclQPainterPath.cc index e89a8519f9..9e387019e7 100644 --- a/src/gsiqt/qt6/QtGui/gsiDeclQPainterPath.cc +++ b/src/gsiqt/qt6/QtGui/gsiDeclQPainterPath.cc @@ -1602,7 +1602,7 @@ static void _call_f_united_c2514 (const qt_gsi::GenericMethod * /*decl*/, void * // QPainterPath ::operator *(const QPainterPath &p, const QTransform &m) static QPainterPath op_QPainterPath_operator_star__4756(const QPainterPath *_self, const QTransform &m) { - return ::operator *(*_self, m); + return operator *(*_self, m); } diff --git a/src/gsiqt/qt6/QtGui/gsiDeclQPixelFormat.cc b/src/gsiqt/qt6/QtGui/gsiDeclQPixelFormat.cc index 8dc66f3cff..ce129d9d06 100644 --- a/src/gsiqt/qt6/QtGui/gsiDeclQPixelFormat.cc +++ b/src/gsiqt/qt6/QtGui/gsiDeclQPixelFormat.cc @@ -435,6 +435,16 @@ static void _call_f_yuvLayout_c0 (const qt_gsi::GenericMethod * /*decl*/, void * } +// bool ::operator==(QPixelFormat fmt1, QPixelFormat fmt2) +static bool op_QPixelFormat_operator_eq__eq__3188(QPixelFormat *_self, QPixelFormat fmt2) { + return operator==(*_self, fmt2); +} + +// bool ::operator!=(QPixelFormat fmt1, QPixelFormat fmt2) +static bool op_QPixelFormat_operator_excl__eq__3188(QPixelFormat *_self, QPixelFormat fmt2) { + return operator!=(*_self, fmt2); +} + namespace gsi { @@ -465,6 +475,8 @@ static gsi::Methods methods_QPixelFormat () { methods += new qt_gsi::GenericMethod ("typeInterpretation", "@brief Method QPixelFormat::TypeInterpretation QPixelFormat::typeInterpretation()\n", true, &_init_f_typeInterpretation_c0, &_call_f_typeInterpretation_c0); methods += new qt_gsi::GenericMethod ("yellowSize", "@brief Method unsigned char QPixelFormat::yellowSize()\n", true, &_init_f_yellowSize_c0, &_call_f_yellowSize_c0); methods += new qt_gsi::GenericMethod ("yuvLayout", "@brief Method QPixelFormat::YUVLayout QPixelFormat::yuvLayout()\n", true, &_init_f_yuvLayout_c0, &_call_f_yuvLayout_c0); + methods += gsi::method_ext("==", &::op_QPixelFormat_operator_eq__eq__3188, gsi::arg ("fmt2"), "@brief Operator bool ::operator==(QPixelFormat fmt1, QPixelFormat fmt2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QPixelFormat_operator_excl__eq__3188, gsi::arg ("fmt2"), "@brief Operator bool ::operator!=(QPixelFormat fmt1, QPixelFormat fmt2)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtGui/gsiDeclQPointingDeviceUniqueId.cc b/src/gsiqt/qt6/QtGui/gsiDeclQPointingDeviceUniqueId.cc index b50bf45d0b..50585a39fc 100644 --- a/src/gsiqt/qt6/QtGui/gsiDeclQPointingDeviceUniqueId.cc +++ b/src/gsiqt/qt6/QtGui/gsiDeclQPointingDeviceUniqueId.cc @@ -99,6 +99,16 @@ static void _call_f_fromNumericId_986 (const qt_gsi::GenericStaticMethod * /*dec } +// bool ::operator==(QPointingDeviceUniqueId lhs, QPointingDeviceUniqueId rhs) +static bool op_QPointingDeviceUniqueId_operator_eq__eq__5398(QPointingDeviceUniqueId *_self, QPointingDeviceUniqueId rhs) { + return operator==(*_self, rhs); +} + +// bool ::operator!=(QPointingDeviceUniqueId lhs, QPointingDeviceUniqueId rhs) +static bool op_QPointingDeviceUniqueId_operator_excl__eq__5398(QPointingDeviceUniqueId *_self, QPointingDeviceUniqueId rhs) { + return operator!=(*_self, rhs); +} + namespace gsi { @@ -109,6 +119,8 @@ static gsi::Methods methods_QPointingDeviceUniqueId () { methods += new qt_gsi::GenericMethod ("isValid?", "@brief Method bool QPointingDeviceUniqueId::isValid()\n", true, &_init_f_isValid_c0, &_call_f_isValid_c0); methods += new qt_gsi::GenericMethod ("numericId", "@brief Method qint64 QPointingDeviceUniqueId::numericId()\n", true, &_init_f_numericId_c0, &_call_f_numericId_c0); methods += new qt_gsi::GenericStaticMethod ("fromNumericId", "@brief Static method QPointingDeviceUniqueId QPointingDeviceUniqueId::fromNumericId(qint64 id)\nThis method is static and can be called without an instance.", &_init_f_fromNumericId_986, &_call_f_fromNumericId_986); + methods += gsi::method_ext("==", &::op_QPointingDeviceUniqueId_operator_eq__eq__5398, gsi::arg ("rhs"), "@brief Operator bool ::operator==(QPointingDeviceUniqueId lhs, QPointingDeviceUniqueId rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QPointingDeviceUniqueId_operator_excl__eq__5398, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(QPointingDeviceUniqueId lhs, QPointingDeviceUniqueId rhs)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtGui/gsiDeclQPolygon.cc b/src/gsiqt/qt6/QtGui/gsiDeclQPolygon.cc index 5f06f297bd..2571baed20 100644 --- a/src/gsiqt/qt6/QtGui/gsiDeclQPolygon.cc +++ b/src/gsiqt/qt6/QtGui/gsiDeclQPolygon.cc @@ -597,7 +597,7 @@ static void _call_f_united_c2138 (const qt_gsi::GenericMethod * /*decl*/, void * // QPolygon ::operator *(const QPolygon &a, const QTransform &m) static QPolygon op_QPolygon_operator_star__4380(const QPolygon *_self, const QTransform &m) { - return ::operator *(*_self, m); + return operator *(*_self, m); } diff --git a/src/gsiqt/qt6/QtGui/gsiDeclQPolygonF.cc b/src/gsiqt/qt6/QtGui/gsiDeclQPolygonF.cc index 90ea5c3d97..1efb69e36e 100644 --- a/src/gsiqt/qt6/QtGui/gsiDeclQPolygonF.cc +++ b/src/gsiqt/qt6/QtGui/gsiDeclQPolygonF.cc @@ -466,7 +466,7 @@ static void _call_f_united_c2208 (const qt_gsi::GenericMethod * /*decl*/, void * // QPolygonF ::operator *(const QPolygonF &a, const QTransform &m) static QPolygonF op_QPolygonF_operator_star__4450(const QPolygonF *_self, const QTransform &m) { - return ::operator *(*_self, m); + return operator *(*_self, m); } diff --git a/src/gsiqt/qt6/QtGui/gsiDeclQQuaternion.cc b/src/gsiqt/qt6/QtGui/gsiDeclQQuaternion.cc index 0501a5b2ce..7a6fb7cbd2 100644 --- a/src/gsiqt/qt6/QtGui/gsiDeclQQuaternion.cc +++ b/src/gsiqt/qt6/QtGui/gsiDeclQQuaternion.cc @@ -928,37 +928,47 @@ static void _call_f_slerp_5666 (const qt_gsi::GenericStaticMethod * /*decl*/, gs // const QQuaternion ::operator*(const QQuaternion &q1, const QQuaternion &q2) static const QQuaternion op_QQuaternion_operator_star__4804(const QQuaternion *_self, const QQuaternion &q2) { - return ::operator*(*_self, q2); + return operator*(*_self, q2); } // const QQuaternion ::operator+(const QQuaternion &q1, const QQuaternion &q2) static const QQuaternion op_QQuaternion_operator_plus__4804(const QQuaternion *_self, const QQuaternion &q2) { - return ::operator+(*_self, q2); + return operator+(*_self, q2); } // const QQuaternion ::operator-(const QQuaternion &q1, const QQuaternion &q2) static const QQuaternion op_QQuaternion_operator_minus__4804(const QQuaternion *_self, const QQuaternion &q2) { - return ::operator-(*_self, q2); + return operator-(*_self, q2); } // const QQuaternion ::operator*(const QQuaternion &quaternion, float factor) static const QQuaternion op_QQuaternion_operator_star__3318(const QQuaternion *_self, float factor) { - return ::operator*(*_self, factor); + return operator*(*_self, factor); } // const QQuaternion ::operator-(const QQuaternion &quaternion) static const QQuaternion op_QQuaternion_operator_minus__2456(const QQuaternion *_self) { - return ::operator-(*_self); + return operator-(*_self); } // const QQuaternion ::operator/(const QQuaternion &quaternion, float divisor) static const QQuaternion op_QQuaternion_operator_slash__3318(const QQuaternion *_self, float divisor) { - return ::operator/(*_self, divisor); + return operator/(*_self, divisor); } // QVector3D ::operator*(const QQuaternion &quaternion, const QVector3D &vec) static QVector3D op_QQuaternion_operator_star__4488(const QQuaternion *_self, const QVector3D &vec) { - return ::operator*(*_self, vec); + return operator*(*_self, vec); +} + +// bool ::operator==(const QQuaternion &q1, const QQuaternion &q2) +static bool op_QQuaternion_operator_eq__eq__4804(const QQuaternion *_self, const QQuaternion &q2) { + return operator==(*_self, q2); +} + +// bool ::operator!=(const QQuaternion &q1, const QQuaternion &q2) +static bool op_QQuaternion_operator_excl__eq__4804(const QQuaternion *_self, const QQuaternion &q2) { + return operator!=(*_self, q2); } @@ -1019,6 +1029,8 @@ static gsi::Methods methods_QQuaternion () { methods += gsi::method_ext("-", &::op_QQuaternion_operator_minus__2456, "@brief Operator const QQuaternion ::operator-(const QQuaternion &quaternion)\nThis is the mapping of the global operator to the instance method."); methods += gsi::method_ext("/", &::op_QQuaternion_operator_slash__3318, gsi::arg ("divisor"), "@brief Operator const QQuaternion ::operator/(const QQuaternion &quaternion, float divisor)\nThis is the mapping of the global operator to the instance method."); methods += gsi::method_ext("*", &::op_QQuaternion_operator_star__4488, gsi::arg ("vec"), "@brief Operator QVector3D ::operator*(const QQuaternion &quaternion, const QVector3D &vec)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("==", &::op_QQuaternion_operator_eq__eq__4804, gsi::arg ("q2"), "@brief Operator bool ::operator==(const QQuaternion &q1, const QQuaternion &q2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QQuaternion_operator_excl__eq__4804, gsi::arg ("q2"), "@brief Operator bool ::operator!=(const QQuaternion &q1, const QQuaternion &q2)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtGui/gsiDeclQRegion.cc b/src/gsiqt/qt6/QtGui/gsiDeclQRegion.cc index 9fbce4ff43..8fc947b753 100644 --- a/src/gsiqt/qt6/QtGui/gsiDeclQRegion.cc +++ b/src/gsiqt/qt6/QtGui/gsiDeclQRegion.cc @@ -912,7 +912,7 @@ static void _call_f_xored_c2006 (const qt_gsi::GenericMethod * /*decl*/, void *c // QRegion ::operator *(const QRegion &r, const QTransform &m) static QRegion op_QRegion_operator_star__4248(const QRegion *_self, const QTransform &m) { - return ::operator *(*_self, m); + return operator *(*_self, m); } diff --git a/src/gsiqt/qt6/QtGui/gsiDeclQSurfaceFormat.cc b/src/gsiqt/qt6/QtGui/gsiDeclQSurfaceFormat.cc index 49ebdd75a8..9bcd20cd19 100644 --- a/src/gsiqt/qt6/QtGui/gsiDeclQSurfaceFormat.cc +++ b/src/gsiqt/qt6/QtGui/gsiDeclQSurfaceFormat.cc @@ -818,6 +818,16 @@ static void _call_f_setDefaultFormat_2724 (const qt_gsi::GenericStaticMethod * / } +// bool ::operator==(const QSurfaceFormat &lhs, const QSurfaceFormat &rhs) +static bool op_QSurfaceFormat_operator_eq__eq__5340(const QSurfaceFormat *_self, const QSurfaceFormat &rhs) { + return operator==(*_self, rhs); +} + +// bool ::operator!=(const QSurfaceFormat &lhs, const QSurfaceFormat &rhs) +static bool op_QSurfaceFormat_operator_excl__eq__5340(const QSurfaceFormat *_self, const QSurfaceFormat &rhs) { + return operator!=(*_self, rhs); +} + namespace gsi { @@ -868,6 +878,8 @@ static gsi::Methods methods_QSurfaceFormat () { methods += new qt_gsi::GenericMethod ("version", "@brief Method QPair QSurfaceFormat::version()\n", true, &_init_f_version_c0, &_call_f_version_c0); methods += new qt_gsi::GenericStaticMethod (":defaultFormat", "@brief Static method QSurfaceFormat QSurfaceFormat::defaultFormat()\nThis method is static and can be called without an instance.", &_init_f_defaultFormat_0, &_call_f_defaultFormat_0); methods += new qt_gsi::GenericStaticMethod ("setDefaultFormat|defaultFormat=", "@brief Static method void QSurfaceFormat::setDefaultFormat(const QSurfaceFormat &format)\nThis method is static and can be called without an instance.", &_init_f_setDefaultFormat_2724, &_call_f_setDefaultFormat_2724); + methods += gsi::method_ext("==", &::op_QSurfaceFormat_operator_eq__eq__5340, gsi::arg ("rhs"), "@brief Operator bool ::operator==(const QSurfaceFormat &lhs, const QSurfaceFormat &rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QSurfaceFormat_operator_excl__eq__5340, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(const QSurfaceFormat &lhs, const QSurfaceFormat &rhs)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtGui/gsiDeclQTransform.cc b/src/gsiqt/qt6/QtGui/gsiDeclQTransform.cc index 56f13fc9a8..0d6038e48a 100644 --- a/src/gsiqt/qt6/QtGui/gsiDeclQTransform.cc +++ b/src/gsiqt/qt6/QtGui/gsiDeclQTransform.cc @@ -1213,22 +1213,22 @@ static void _call_f_squareToQuad_3755 (const qt_gsi::GenericStaticMethod * /*dec // QTransform ::operator *(const QTransform &a, qreal n) static QTransform op_QTransform_operator_star__3211(const QTransform *_self, qreal n) { - return ::operator *(*_self, n); + return operator *(*_self, n); } // QTransform ::operator /(const QTransform &a, qreal n) static QTransform op_QTransform_operator_slash__3211(const QTransform *_self, qreal n) { - return ::operator /(*_self, n); + return operator /(*_self, n); } // QTransform ::operator +(const QTransform &a, qreal n) static QTransform op_QTransform_operator_plus__3211(const QTransform *_self, qreal n) { - return ::operator +(*_self, n); + return operator +(*_self, n); } // QTransform ::operator -(const QTransform &a, qreal n) static QTransform op_QTransform_operator_minus__3211(const QTransform *_self, qreal n) { - return ::operator -(*_self, n); + return operator -(*_self, n); } diff --git a/src/gsiqt/qt6/QtGui/gsiDeclQVector2D.cc b/src/gsiqt/qt6/QtGui/gsiDeclQVector2D.cc index b39884a65a..e975abaf6e 100644 --- a/src/gsiqt/qt6/QtGui/gsiDeclQVector2D.cc +++ b/src/gsiqt/qt6/QtGui/gsiDeclQVector2D.cc @@ -573,6 +573,51 @@ static void _call_f_dotProduct_2416 (const qt_gsi::GenericStaticMethod * /*decl* } +// bool ::operator==(QVector2D v1, QVector2D v2) +static bool op_QVector2D_operator_eq__eq__2416(QVector2D *_self, QVector2D v2) { + return operator==(*_self, v2); +} + +// bool ::operator!=(QVector2D v1, QVector2D v2) +static bool op_QVector2D_operator_excl__eq__2416(QVector2D *_self, QVector2D v2) { + return operator!=(*_self, v2); +} + +// QVector2D ::operator+(QVector2D v1, QVector2D v2) +static QVector2D op_QVector2D_operator_plus__2416(QVector2D *_self, QVector2D v2) { + return operator+(*_self, v2); +} + +// QVector2D ::operator-(QVector2D v1, QVector2D v2) +static QVector2D op_QVector2D_operator_minus__2416(QVector2D *_self, QVector2D v2) { + return operator-(*_self, v2); +} + +// QVector2D ::operator*(QVector2D vector, float factor) +static QVector2D op_QVector2D_operator_star__2124(QVector2D *_self, float factor) { + return operator*(*_self, factor); +} + +// QVector2D ::operator*(QVector2D v1, QVector2D v2) +static QVector2D op_QVector2D_operator_star__2416(QVector2D *_self, QVector2D v2) { + return operator*(*_self, v2); +} + +// QVector2D ::operator-(QVector2D vector) +static QVector2D op_QVector2D_operator_minus__1262(QVector2D *_self) { + return operator-(*_self); +} + +// QVector2D ::operator/(QVector2D vector, float divisor) +static QVector2D op_QVector2D_operator_slash__2124(QVector2D *_self, float divisor) { + return operator/(*_self, divisor); +} + +// QVector2D ::operator/(QVector2D vector, QVector2D divisor) +static QVector2D op_QVector2D_operator_slash__2416(QVector2D *_self, QVector2D divisor) { + return operator/(*_self, divisor); +} + namespace gsi { @@ -609,6 +654,15 @@ static gsi::Methods methods_QVector2D () { methods += new qt_gsi::GenericMethod (":x", "@brief Method float QVector2D::x()\n", true, &_init_f_x_c0, &_call_f_x_c0); methods += new qt_gsi::GenericMethod (":y", "@brief Method float QVector2D::y()\n", true, &_init_f_y_c0, &_call_f_y_c0); methods += new qt_gsi::GenericStaticMethod ("dotProduct", "@brief Static method float QVector2D::dotProduct(QVector2D v1, QVector2D v2)\nThis method is static and can be called without an instance.", &_init_f_dotProduct_2416, &_call_f_dotProduct_2416); + methods += gsi::method_ext("==", &::op_QVector2D_operator_eq__eq__2416, gsi::arg ("v2"), "@brief Operator bool ::operator==(QVector2D v1, QVector2D v2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QVector2D_operator_excl__eq__2416, gsi::arg ("v2"), "@brief Operator bool ::operator!=(QVector2D v1, QVector2D v2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("+", &::op_QVector2D_operator_plus__2416, gsi::arg ("v2"), "@brief Operator QVector2D ::operator+(QVector2D v1, QVector2D v2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("-", &::op_QVector2D_operator_minus__2416, gsi::arg ("v2"), "@brief Operator QVector2D ::operator-(QVector2D v1, QVector2D v2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("*", &::op_QVector2D_operator_star__2124, gsi::arg ("factor"), "@brief Operator QVector2D ::operator*(QVector2D vector, float factor)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("*", &::op_QVector2D_operator_star__2416, gsi::arg ("v2"), "@brief Operator QVector2D ::operator*(QVector2D v1, QVector2D v2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("-", &::op_QVector2D_operator_minus__1262, "@brief Operator QVector2D ::operator-(QVector2D vector)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("/", &::op_QVector2D_operator_slash__2124, gsi::arg ("divisor"), "@brief Operator QVector2D ::operator/(QVector2D vector, float divisor)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("/", &::op_QVector2D_operator_slash__2416, gsi::arg ("divisor"), "@brief Operator QVector2D ::operator/(QVector2D vector, QVector2D divisor)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtGui/gsiDeclQVector3D.cc b/src/gsiqt/qt6/QtGui/gsiDeclQVector3D.cc index 5b3b48f940..a4974cbe2c 100644 --- a/src/gsiqt/qt6/QtGui/gsiDeclQVector3D.cc +++ b/src/gsiqt/qt6/QtGui/gsiDeclQVector3D.cc @@ -799,7 +799,52 @@ static void _call_f_normal_3573 (const qt_gsi::GenericStaticMethod * /*decl*/, g // QVector3D ::operator*(const QVector3D &vector, const QMatrix4x4 &matrix) static QVector3D op_QVector3D_operator_star__4279u1(const QVector3D *_self, const QMatrix4x4 &matrix) { - return ::operator*(*_self, matrix); + return operator*(*_self, matrix); +} + +// bool ::operator==(QVector3D v1, QVector3D v2) +static bool op_QVector3D_operator_eq__eq__2418(QVector3D *_self, QVector3D v2) { + return operator==(*_self, v2); +} + +// bool ::operator!=(QVector3D v1, QVector3D v2) +static bool op_QVector3D_operator_excl__eq__2418(QVector3D *_self, QVector3D v2) { + return operator!=(*_self, v2); +} + +// QVector3D ::operator+(QVector3D v1, QVector3D v2) +static QVector3D op_QVector3D_operator_plus__2418(QVector3D *_self, QVector3D v2) { + return operator+(*_self, v2); +} + +// QVector3D ::operator-(QVector3D v1, QVector3D v2) +static QVector3D op_QVector3D_operator_minus__2418(QVector3D *_self, QVector3D v2) { + return operator-(*_self, v2); +} + +// QVector3D ::operator*(QVector3D vector, float factor) +static QVector3D op_QVector3D_operator_star__2125(QVector3D *_self, float factor) { + return operator*(*_self, factor); +} + +// QVector3D ::operator*(QVector3D v1, QVector3D v2) +static QVector3D op_QVector3D_operator_star__2418(QVector3D *_self, QVector3D v2) { + return operator*(*_self, v2); +} + +// QVector3D ::operator-(QVector3D vector) +static QVector3D op_QVector3D_operator_minus__1263(QVector3D *_self) { + return operator-(*_self); +} + +// QVector3D ::operator/(QVector3D vector, float divisor) +static QVector3D op_QVector3D_operator_slash__2125(QVector3D *_self, float divisor) { + return operator/(*_self, divisor); +} + +// QVector3D ::operator/(QVector3D vector, QVector3D divisor) +static QVector3D op_QVector3D_operator_slash__2418(QVector3D *_self, QVector3D divisor) { + return operator/(*_self, divisor); } @@ -849,6 +894,15 @@ static gsi::Methods methods_QVector3D () { methods += new qt_gsi::GenericStaticMethod ("normal", "@brief Static method QVector3D QVector3D::normal(QVector3D v1, QVector3D v2)\nThis method is static and can be called without an instance.", &_init_f_normal_2418, &_call_f_normal_2418); methods += new qt_gsi::GenericStaticMethod ("normal", "@brief Static method QVector3D QVector3D::normal(QVector3D v1, QVector3D v2, QVector3D v3)\nThis method is static and can be called without an instance.", &_init_f_normal_3573, &_call_f_normal_3573); methods += gsi::method_ext("*", &::op_QVector3D_operator_star__4279u1, gsi::arg ("matrix"), "@brief Operator QVector3D ::operator*(const QVector3D &vector, const QMatrix4x4 &matrix)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("==", &::op_QVector3D_operator_eq__eq__2418, gsi::arg ("v2"), "@brief Operator bool ::operator==(QVector3D v1, QVector3D v2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QVector3D_operator_excl__eq__2418, gsi::arg ("v2"), "@brief Operator bool ::operator!=(QVector3D v1, QVector3D v2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("+", &::op_QVector3D_operator_plus__2418, gsi::arg ("v2"), "@brief Operator QVector3D ::operator+(QVector3D v1, QVector3D v2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("-", &::op_QVector3D_operator_minus__2418, gsi::arg ("v2"), "@brief Operator QVector3D ::operator-(QVector3D v1, QVector3D v2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("*", &::op_QVector3D_operator_star__2125, gsi::arg ("factor"), "@brief Operator QVector3D ::operator*(QVector3D vector, float factor)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("*", &::op_QVector3D_operator_star__2418, gsi::arg ("v2"), "@brief Operator QVector3D ::operator*(QVector3D v1, QVector3D v2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("-", &::op_QVector3D_operator_minus__1263, "@brief Operator QVector3D ::operator-(QVector3D vector)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("/", &::op_QVector3D_operator_slash__2125, gsi::arg ("divisor"), "@brief Operator QVector3D ::operator/(QVector3D vector, float divisor)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("/", &::op_QVector3D_operator_slash__2418, gsi::arg ("divisor"), "@brief Operator QVector3D ::operator/(QVector3D vector, QVector3D divisor)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtGui/gsiDeclQVector4D.cc b/src/gsiqt/qt6/QtGui/gsiDeclQVector4D.cc index ee80f6a394..021ca8e731 100644 --- a/src/gsiqt/qt6/QtGui/gsiDeclQVector4D.cc +++ b/src/gsiqt/qt6/QtGui/gsiDeclQVector4D.cc @@ -685,7 +685,52 @@ static void _call_f_dotProduct_2420 (const qt_gsi::GenericStaticMethod * /*decl* // QVector4D ::operator*(const QVector4D &vector, const QMatrix4x4 &matrix) static QVector4D op_QVector4D_operator_star__4280u1(const QVector4D *_self, const QMatrix4x4 &matrix) { - return ::operator*(*_self, matrix); + return operator*(*_self, matrix); +} + +// bool ::operator==(QVector4D v1, QVector4D v2) +static bool op_QVector4D_operator_eq__eq__2420(QVector4D *_self, QVector4D v2) { + return operator==(*_self, v2); +} + +// bool ::operator!=(QVector4D v1, QVector4D v2) +static bool op_QVector4D_operator_excl__eq__2420(QVector4D *_self, QVector4D v2) { + return operator!=(*_self, v2); +} + +// QVector4D ::operator+(QVector4D v1, QVector4D v2) +static QVector4D op_QVector4D_operator_plus__2420(QVector4D *_self, QVector4D v2) { + return operator+(*_self, v2); +} + +// QVector4D ::operator-(QVector4D v1, QVector4D v2) +static QVector4D op_QVector4D_operator_minus__2420(QVector4D *_self, QVector4D v2) { + return operator-(*_self, v2); +} + +// QVector4D ::operator*(QVector4D vector, float factor) +static QVector4D op_QVector4D_operator_star__2126(QVector4D *_self, float factor) { + return operator*(*_self, factor); +} + +// QVector4D ::operator*(QVector4D v1, QVector4D v2) +static QVector4D op_QVector4D_operator_star__2420(QVector4D *_self, QVector4D v2) { + return operator*(*_self, v2); +} + +// QVector4D ::operator-(QVector4D vector) +static QVector4D op_QVector4D_operator_minus__1264(QVector4D *_self) { + return operator-(*_self); +} + +// QVector4D ::operator/(QVector4D vector, float divisor) +static QVector4D op_QVector4D_operator_slash__2126(QVector4D *_self, float divisor) { + return operator/(*_self, divisor); +} + +// QVector4D ::operator/(QVector4D vector, QVector4D divisor) +static QVector4D op_QVector4D_operator_slash__2420(QVector4D *_self, QVector4D divisor) { + return operator/(*_self, divisor); } @@ -731,6 +776,15 @@ static gsi::Methods methods_QVector4D () { methods += new qt_gsi::GenericMethod (":z", "@brief Method float QVector4D::z()\n", true, &_init_f_z_c0, &_call_f_z_c0); methods += new qt_gsi::GenericStaticMethod ("dotProduct", "@brief Static method float QVector4D::dotProduct(QVector4D v1, QVector4D v2)\nThis method is static and can be called without an instance.", &_init_f_dotProduct_2420, &_call_f_dotProduct_2420); methods += gsi::method_ext("*", &::op_QVector4D_operator_star__4280u1, gsi::arg ("matrix"), "@brief Operator QVector4D ::operator*(const QVector4D &vector, const QMatrix4x4 &matrix)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("==", &::op_QVector4D_operator_eq__eq__2420, gsi::arg ("v2"), "@brief Operator bool ::operator==(QVector4D v1, QVector4D v2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QVector4D_operator_excl__eq__2420, gsi::arg ("v2"), "@brief Operator bool ::operator!=(QVector4D v1, QVector4D v2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("+", &::op_QVector4D_operator_plus__2420, gsi::arg ("v2"), "@brief Operator QVector4D ::operator+(QVector4D v1, QVector4D v2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("-", &::op_QVector4D_operator_minus__2420, gsi::arg ("v2"), "@brief Operator QVector4D ::operator-(QVector4D v1, QVector4D v2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("*", &::op_QVector4D_operator_star__2126, gsi::arg ("factor"), "@brief Operator QVector4D ::operator*(QVector4D vector, float factor)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("*", &::op_QVector4D_operator_star__2420, gsi::arg ("v2"), "@brief Operator QVector4D ::operator*(QVector4D v1, QVector4D v2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("-", &::op_QVector4D_operator_minus__1264, "@brief Operator QVector4D ::operator-(QVector4D vector)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("/", &::op_QVector4D_operator_slash__2126, gsi::arg ("divisor"), "@brief Operator QVector4D ::operator/(QVector4D vector, float divisor)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("/", &::op_QVector4D_operator_slash__2420, gsi::arg ("divisor"), "@brief Operator QVector4D ::operator/(QVector4D vector, QVector4D divisor)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtMultimedia/gsiDeclQAudioFormat.cc b/src/gsiqt/qt6/QtMultimedia/gsiDeclQAudioFormat.cc index 45cd64ba86..777d8a43b4 100644 --- a/src/gsiqt/qt6/QtMultimedia/gsiDeclQAudioFormat.cc +++ b/src/gsiqt/qt6/QtMultimedia/gsiDeclQAudioFormat.cc @@ -387,6 +387,16 @@ static void _call_f_setSampleRate_767 (const qt_gsi::GenericMethod * /*decl*/, v } +// bool ::operator==(const QAudioFormat &a, const QAudioFormat &b) +static bool op_QAudioFormat_operator_eq__eq__4910(const QAudioFormat *_self, const QAudioFormat &b) { + return operator==(*_self, b); +} + +// bool ::operator!=(const QAudioFormat &a, const QAudioFormat &b) +static bool op_QAudioFormat_operator_excl__eq__4910(const QAudioFormat *_self, const QAudioFormat &b) { + return operator!=(*_self, b); +} + namespace gsi { @@ -413,6 +423,8 @@ static gsi::Methods methods_QAudioFormat () { methods += new qt_gsi::GenericMethod ("setChannelCount|channelCount=", "@brief Method void QAudioFormat::setChannelCount(int channelCount)\n", false, &_init_f_setChannelCount_767, &_call_f_setChannelCount_767); methods += new qt_gsi::GenericMethod ("setSampleFormat|sampleFormat=", "@brief Method void QAudioFormat::setSampleFormat(QAudioFormat::SampleFormat f)\n", false, &_init_f_setSampleFormat_2975, &_call_f_setSampleFormat_2975); methods += new qt_gsi::GenericMethod ("setSampleRate|sampleRate=", "@brief Method void QAudioFormat::setSampleRate(int sampleRate)\n", false, &_init_f_setSampleRate_767, &_call_f_setSampleRate_767); + methods += gsi::method_ext("==", &::op_QAudioFormat_operator_eq__eq__4910, gsi::arg ("b"), "@brief Operator bool ::operator==(const QAudioFormat &a, const QAudioFormat &b)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QAudioFormat_operator_excl__eq__4910, gsi::arg ("b"), "@brief Operator bool ::operator!=(const QAudioFormat &a, const QAudioFormat &b)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtMultimedia/gsiDeclQMediaMetaData.cc b/src/gsiqt/qt6/QtMultimedia/gsiDeclQMediaMetaData.cc index d4d3c4ac3d..75c15748e2 100644 --- a/src/gsiqt/qt6/QtMultimedia/gsiDeclQMediaMetaData.cc +++ b/src/gsiqt/qt6/QtMultimedia/gsiDeclQMediaMetaData.cc @@ -215,6 +215,16 @@ static void _call_f_metaDataKeyToString_2179 (const qt_gsi::GenericStaticMethod } +// bool ::operator==(const QMediaMetaData &a, const QMediaMetaData &b) +static bool op_QMediaMetaData_operator_eq__eq__5178(const QMediaMetaData *_self, const QMediaMetaData &b) { + return operator==(*_self, b); +} + +// bool ::operator!=(const QMediaMetaData &a, const QMediaMetaData &b) +static bool op_QMediaMetaData_operator_excl__eq__5178(const QMediaMetaData *_self, const QMediaMetaData &b) { + return operator!=(*_self, b); +} + namespace gsi { @@ -231,6 +241,8 @@ static gsi::Methods methods_QMediaMetaData () { methods += new qt_gsi::GenericMethod ("stringValue", "@brief Method QString QMediaMetaData::stringValue(QMediaMetaData::Key k)\n", true, &_init_f_stringValue_c2179, &_call_f_stringValue_c2179); methods += new qt_gsi::GenericMethod ("value", "@brief Method QVariant QMediaMetaData::value(QMediaMetaData::Key k)\n", true, &_init_f_value_c2179, &_call_f_value_c2179); methods += new qt_gsi::GenericStaticMethod ("metaDataKeyToString", "@brief Static method QString QMediaMetaData::metaDataKeyToString(QMediaMetaData::Key k)\nThis method is static and can be called without an instance.", &_init_f_metaDataKeyToString_2179, &_call_f_metaDataKeyToString_2179); + methods += gsi::method_ext("==", &::op_QMediaMetaData_operator_eq__eq__5178, gsi::arg ("b"), "@brief Operator bool ::operator==(const QMediaMetaData &a, const QMediaMetaData &b)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QMediaMetaData_operator_excl__eq__5178, gsi::arg ("b"), "@brief Operator bool ::operator!=(const QMediaMetaData &a, const QMediaMetaData &b)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtMultimedia/gsiDeclQMediaTimeRange.cc b/src/gsiqt/qt6/QtMultimedia/gsiDeclQMediaTimeRange.cc index 32f559df81..0b76c8d9ee 100644 --- a/src/gsiqt/qt6/QtMultimedia/gsiDeclQMediaTimeRange.cc +++ b/src/gsiqt/qt6/QtMultimedia/gsiDeclQMediaTimeRange.cc @@ -498,12 +498,22 @@ static void _call_f_swap_2071 (const qt_gsi::GenericMethod * /*decl*/, void *cls // QMediaTimeRange ::operator+(const QMediaTimeRange &r1, const QMediaTimeRange &r2) static QMediaTimeRange op_QMediaTimeRange_operator_plus__5424(const QMediaTimeRange *_self, const QMediaTimeRange &r2) { - return ::operator+(*_self, r2); + return operator+(*_self, r2); } // QMediaTimeRange ::operator-(const QMediaTimeRange &r1, const QMediaTimeRange &r2) static QMediaTimeRange op_QMediaTimeRange_operator_minus__5424(const QMediaTimeRange *_self, const QMediaTimeRange &r2) { - return ::operator-(*_self, r2); + return operator-(*_self, r2); +} + +// bool ::operator==(const QMediaTimeRange &lhs, const QMediaTimeRange &rhs) +static bool op_QMediaTimeRange_operator_eq__eq__5424(const QMediaTimeRange *_self, const QMediaTimeRange &rhs) { + return operator==(*_self, rhs); +} + +// bool ::operator!=(const QMediaTimeRange &lhs, const QMediaTimeRange &rhs) +static bool op_QMediaTimeRange_operator_excl__eq__5424(const QMediaTimeRange *_self, const QMediaTimeRange &rhs) { + return operator!=(*_self, rhs); } @@ -539,6 +549,8 @@ static gsi::Methods methods_QMediaTimeRange () { methods += new qt_gsi::GenericMethod ("swap", "@brief Method void QMediaTimeRange::swap(QMediaTimeRange &other)\n", false, &_init_f_swap_2071, &_call_f_swap_2071); methods += gsi::method_ext("+", &::op_QMediaTimeRange_operator_plus__5424, gsi::arg ("r2"), "@brief Operator QMediaTimeRange ::operator+(const QMediaTimeRange &r1, const QMediaTimeRange &r2)\nThis is the mapping of the global operator to the instance method."); methods += gsi::method_ext("-", &::op_QMediaTimeRange_operator_minus__5424, gsi::arg ("r2"), "@brief Operator QMediaTimeRange ::operator-(const QMediaTimeRange &r1, const QMediaTimeRange &r2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("==", &::op_QMediaTimeRange_operator_eq__eq__5424, gsi::arg ("rhs"), "@brief Operator bool ::operator==(const QMediaTimeRange &lhs, const QMediaTimeRange &rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QMediaTimeRange_operator_excl__eq__5424, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(const QMediaTimeRange &lhs, const QMediaTimeRange &rhs)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtNetwork/gsiDeclQHstsPolicy.cc b/src/gsiqt/qt6/QtNetwork/gsiDeclQHstsPolicy.cc index 7a3711670f..94c85b0376 100644 --- a/src/gsiqt/qt6/QtNetwork/gsiDeclQHstsPolicy.cc +++ b/src/gsiqt/qt6/QtNetwork/gsiDeclQHstsPolicy.cc @@ -264,6 +264,16 @@ static void _call_f_swap_1741 (const qt_gsi::GenericMethod * /*decl*/, void *cls } +// bool ::operator==(const QHstsPolicy &lhs, const QHstsPolicy &rhs) +static bool op_QHstsPolicy_operator_eq__eq__4764(const QHstsPolicy *_self, const QHstsPolicy &rhs) { + return operator==(*_self, rhs); +} + +// bool ::operator!=(const QHstsPolicy &lhs, const QHstsPolicy &rhs) +static bool op_QHstsPolicy_operator_excl__eq__4764(const QHstsPolicy *_self, const QHstsPolicy &rhs) { + return operator!=(*_self, rhs); +} + namespace gsi { @@ -282,6 +292,8 @@ static gsi::Methods methods_QHstsPolicy () { methods += new qt_gsi::GenericMethod ("setHost", "@brief Method void QHstsPolicy::setHost(const QString &host, QUrl::ParsingMode mode)\n", false, &_init_f_setHost_3970, &_call_f_setHost_3970); methods += new qt_gsi::GenericMethod ("setIncludesSubDomains|includesSubDomains=", "@brief Method void QHstsPolicy::setIncludesSubDomains(bool include)\n", false, &_init_f_setIncludesSubDomains_864, &_call_f_setIncludesSubDomains_864); methods += new qt_gsi::GenericMethod ("swap", "@brief Method void QHstsPolicy::swap(QHstsPolicy &other)\n", false, &_init_f_swap_1741, &_call_f_swap_1741); + methods += gsi::method_ext("==", &::op_QHstsPolicy_operator_eq__eq__4764, gsi::arg ("rhs"), "@brief Operator bool ::operator==(const QHstsPolicy &lhs, const QHstsPolicy &rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QHstsPolicy_operator_excl__eq__4764, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(const QHstsPolicy &lhs, const QHstsPolicy &rhs)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtNetwork/gsiDeclQHttp2Configuration.cc b/src/gsiqt/qt6/QtNetwork/gsiDeclQHttp2Configuration.cc index 68a773c562..6d48069ea4 100644 --- a/src/gsiqt/qt6/QtNetwork/gsiDeclQHttp2Configuration.cc +++ b/src/gsiqt/qt6/QtNetwork/gsiDeclQHttp2Configuration.cc @@ -280,6 +280,16 @@ static void _call_f_swap_2533 (const qt_gsi::GenericMethod * /*decl*/, void *cls } +// bool ::operator==(const QHttp2Configuration &lhs, const QHttp2Configuration &rhs) +static bool op_QHttp2Configuration_operator_eq__eq__6348(const QHttp2Configuration *_self, const QHttp2Configuration &rhs) { + return operator==(*_self, rhs); +} + +// bool ::operator!=(const QHttp2Configuration &lhs, const QHttp2Configuration &rhs) +static bool op_QHttp2Configuration_operator_excl__eq__6348(const QHttp2Configuration *_self, const QHttp2Configuration &rhs) { + return operator!=(*_self, rhs); +} + namespace gsi { @@ -300,6 +310,8 @@ static gsi::Methods methods_QHttp2Configuration () { methods += new qt_gsi::GenericMethod ("setStreamReceiveWindowSize", "@brief Method bool QHttp2Configuration::setStreamReceiveWindowSize(unsigned int size)\n", false, &_init_f_setStreamReceiveWindowSize_1772, &_call_f_setStreamReceiveWindowSize_1772); methods += new qt_gsi::GenericMethod ("streamReceiveWindowSize", "@brief Method unsigned int QHttp2Configuration::streamReceiveWindowSize()\n", true, &_init_f_streamReceiveWindowSize_c0, &_call_f_streamReceiveWindowSize_c0); methods += new qt_gsi::GenericMethod ("swap", "@brief Method void QHttp2Configuration::swap(QHttp2Configuration &other)\n", false, &_init_f_swap_2533, &_call_f_swap_2533); + methods += gsi::method_ext("==", &::op_QHttp2Configuration_operator_eq__eq__6348, gsi::arg ("rhs"), "@brief Operator bool ::operator==(const QHttp2Configuration &lhs, const QHttp2Configuration &rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QHttp2Configuration_operator_excl__eq__6348, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(const QHttp2Configuration &lhs, const QHttp2Configuration &rhs)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtNetwork/gsiDeclQSslDiffieHellmanParameters.cc b/src/gsiqt/qt6/QtNetwork/gsiDeclQSslDiffieHellmanParameters.cc index 479a9fde8b..cf4a522ef6 100644 --- a/src/gsiqt/qt6/QtNetwork/gsiDeclQSslDiffieHellmanParameters.cc +++ b/src/gsiqt/qt6/QtNetwork/gsiDeclQSslDiffieHellmanParameters.cc @@ -228,6 +228,16 @@ static void _call_f_fromEncoded_3702 (const qt_gsi::GenericStaticMethod * /*decl } +// bool ::operator==(const QSslDiffieHellmanParameters &lhs, const QSslDiffieHellmanParameters &rhs) +static bool op_QSslDiffieHellmanParameters_operator_eq__eq__7956(const QSslDiffieHellmanParameters *_self, const QSslDiffieHellmanParameters &rhs) { + return operator==(*_self, rhs); +} + +// bool ::operator!=(const QSslDiffieHellmanParameters &lhs, const QSslDiffieHellmanParameters &rhs) +static bool op_QSslDiffieHellmanParameters_operator_excl__eq__7956(const QSslDiffieHellmanParameters *_self, const QSslDiffieHellmanParameters &rhs) { + return operator!=(*_self, rhs); +} + namespace gsi { @@ -245,6 +255,8 @@ static gsi::Methods methods_QSslDiffieHellmanParameters () { methods += new qt_gsi::GenericStaticMethod ("defaultParameters", "@brief Static method QSslDiffieHellmanParameters QSslDiffieHellmanParameters::defaultParameters()\nThis method is static and can be called without an instance.", &_init_f_defaultParameters_0, &_call_f_defaultParameters_0); methods += new qt_gsi::GenericStaticMethod ("fromEncoded", "@brief Static method QSslDiffieHellmanParameters QSslDiffieHellmanParameters::fromEncoded(const QByteArray &encoded, QSsl::EncodingFormat format)\nThis method is static and can be called without an instance.", &_init_f_fromEncoded_4564, &_call_f_fromEncoded_4564); methods += new qt_gsi::GenericStaticMethod ("fromEncoded", "@brief Static method QSslDiffieHellmanParameters QSslDiffieHellmanParameters::fromEncoded(QIODevice *device, QSsl::EncodingFormat format)\nThis method is static and can be called without an instance.", &_init_f_fromEncoded_3702, &_call_f_fromEncoded_3702); + methods += gsi::method_ext("==", &::op_QSslDiffieHellmanParameters_operator_eq__eq__7956, gsi::arg ("rhs"), "@brief Operator bool ::operator==(const QSslDiffieHellmanParameters &lhs, const QSslDiffieHellmanParameters &rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QSslDiffieHellmanParameters_operator_excl__eq__7956, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(const QSslDiffieHellmanParameters &lhs, const QSslDiffieHellmanParameters &rhs)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtNetwork/gsiDeclQSslEllipticCurve.cc b/src/gsiqt/qt6/QtNetwork/gsiDeclQSslEllipticCurve.cc index baea1d3e69..a7b7ad606e 100644 --- a/src/gsiqt/qt6/QtNetwork/gsiDeclQSslEllipticCurve.cc +++ b/src/gsiqt/qt6/QtNetwork/gsiDeclQSslEllipticCurve.cc @@ -148,6 +148,16 @@ static void _call_f_fromShortName_2025 (const qt_gsi::GenericStaticMethod * /*de } +// bool ::operator==(QSslEllipticCurve lhs, QSslEllipticCurve rhs) +static bool op_QSslEllipticCurve_operator_eq__eq__4216(QSslEllipticCurve *_self, QSslEllipticCurve rhs) { + return operator==(*_self, rhs); +} + +// bool ::operator!=(QSslEllipticCurve lhs, QSslEllipticCurve rhs) +static bool op_QSslEllipticCurve_operator_excl__eq__4216(QSslEllipticCurve *_self, QSslEllipticCurve rhs) { + return operator!=(*_self, rhs); +} + namespace gsi { @@ -161,6 +171,8 @@ static gsi::Methods methods_QSslEllipticCurve () { methods += new qt_gsi::GenericMethod ("shortName", "@brief Method QString QSslEllipticCurve::shortName()\n", true, &_init_f_shortName_c0, &_call_f_shortName_c0); methods += new qt_gsi::GenericStaticMethod ("fromLongName", "@brief Static method QSslEllipticCurve QSslEllipticCurve::fromLongName(const QString &name)\nThis method is static and can be called without an instance.", &_init_f_fromLongName_2025, &_call_f_fromLongName_2025); methods += new qt_gsi::GenericStaticMethod ("fromShortName", "@brief Static method QSslEllipticCurve QSslEllipticCurve::fromShortName(const QString &name)\nThis method is static and can be called without an instance.", &_init_f_fromShortName_2025, &_call_f_fromShortName_2025); + methods += gsi::method_ext("==", &::op_QSslEllipticCurve_operator_eq__eq__4216, gsi::arg ("rhs"), "@brief Operator bool ::operator==(QSslEllipticCurve lhs, QSslEllipticCurve rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QSslEllipticCurve_operator_excl__eq__4216, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(QSslEllipticCurve lhs, QSslEllipticCurve rhs)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt6/QtNetwork/gsiDeclQSslPreSharedKeyAuthenticator.cc b/src/gsiqt/qt6/QtNetwork/gsiDeclQSslPreSharedKeyAuthenticator.cc index 7fb92588ed..6be4fa8699 100644 --- a/src/gsiqt/qt6/QtNetwork/gsiDeclQSslPreSharedKeyAuthenticator.cc +++ b/src/gsiqt/qt6/QtNetwork/gsiDeclQSslPreSharedKeyAuthenticator.cc @@ -223,6 +223,16 @@ static void _call_f_swap_3567 (const qt_gsi::GenericMethod * /*decl*/, void *cls } +// bool ::operator==(const QSslPreSharedKeyAuthenticator &lhs, const QSslPreSharedKeyAuthenticator &rhs) +static bool op_QSslPreSharedKeyAuthenticator_operator_eq__eq__8416(const QSslPreSharedKeyAuthenticator *_self, const QSslPreSharedKeyAuthenticator &rhs) { + return operator==(*_self, rhs); +} + +// bool ::operator!=(const QSslPreSharedKeyAuthenticator &lhs, const QSslPreSharedKeyAuthenticator &rhs) +static bool op_QSslPreSharedKeyAuthenticator_operator_excl__eq__8416(const QSslPreSharedKeyAuthenticator *_self, const QSslPreSharedKeyAuthenticator &rhs) { + return operator!=(*_self, rhs); +} + namespace gsi { @@ -240,6 +250,8 @@ static gsi::Methods methods_QSslPreSharedKeyAuthenticator () { methods += new qt_gsi::GenericMethod ("setIdentity|identity=", "@brief Method void QSslPreSharedKeyAuthenticator::setIdentity(const QByteArray &identity)\n", false, &_init_f_setIdentity_2309, &_call_f_setIdentity_2309); methods += new qt_gsi::GenericMethod ("setPreSharedKey|preSharedKey=", "@brief Method void QSslPreSharedKeyAuthenticator::setPreSharedKey(const QByteArray &preSharedKey)\n", false, &_init_f_setPreSharedKey_2309, &_call_f_setPreSharedKey_2309); methods += new qt_gsi::GenericMethod ("swap", "@brief Method void QSslPreSharedKeyAuthenticator::swap(QSslPreSharedKeyAuthenticator &other)\n", false, &_init_f_swap_3567, &_call_f_swap_3567); + methods += gsi::method_ext("==", &::op_QSslPreSharedKeyAuthenticator_operator_eq__eq__8416, gsi::arg ("rhs"), "@brief Operator bool ::operator==(const QSslPreSharedKeyAuthenticator &lhs, const QSslPreSharedKeyAuthenticator &rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QSslPreSharedKeyAuthenticator_operator_excl__eq__8416, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(const QSslPreSharedKeyAuthenticator &lhs, const QSslPreSharedKeyAuthenticator &rhs)\nThis is the mapping of the global operator to the instance method."); return methods; } From 14fa7a376001fce17dce335b8f8fc2ae0c3e8059 Mon Sep 17 00:00:00 2001 From: Matthias Koefferlein Date: Sat, 19 Oct 2024 20:35:47 +0200 Subject: [PATCH 3/4] Adding tests --- testdata/ruby/qtbinding.rb | 33 +++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) diff --git a/testdata/ruby/qtbinding.rb b/testdata/ruby/qtbinding.rb index de4ebaac82..3a90d11bfb 100644 --- a/testdata/ruby/qtbinding.rb +++ b/testdata/ruby/qtbinding.rb @@ -881,6 +881,39 @@ def test_60 end + # issue-1899 + def test_61 + + p1 = RBA::QPoint::new(1, 2) + p2 = RBA::QPoint::new(1, 2) + p3 = RBA::QPoint::new(2, 3) + assert_equal((p1 * 5).x, 5) + assert_equal((p1 * 5).y, 10) + assert_equal(p1 == p2, true) + assert_equal(p1 == p3, false) + assert_equal(p1 != p2, false) + assert_equal(p1 != p3, true) + assert_equal((p1 + p3).x, 3) + assert_equal((p1 + p3).y, 5) + assert_equal((p1 - p3).x, -1) + assert_equal((p1 - p3).y, -1) + + p1 = RBA::QPointF::new(1, 2) + p2 = RBA::QPointF::new(1, 2) + p3 = RBA::QPointF::new(2, 3) + assert_equal((p1 * 5).x, 5) + assert_equal((p1 * 5).y, 10) + assert_equal(p1 == p2, true) + assert_equal(p1 == p3, false) + assert_equal(p1 != p2, false) + assert_equal(p1 != p3, true) + assert_equal((p1 + p3).x, 3) + assert_equal((p1 + p3).y, 5) + assert_equal((p1 - p3).x, -1) + assert_equal((p1 - p3).y, -1) + + end + end load("test_epilogue.rb") From 761388f6801a255220989d4c78be5a1d9b90a3cb Mon Sep 17 00:00:00 2001 From: Matthias Koefferlein Date: Sat, 19 Oct 2024 23:15:37 +0200 Subject: [PATCH 4/4] Updating definitions for Qt5 too - some additional operator bindings show up. --- .../qt5/QtCore/gsiDeclQCollatorSortKey.cc | 2 +- src/gsiqt/qt5/QtCore/gsiDeclQDeadlineTimer.cc | 48 +++++++++++++++++++ src/gsiqt/qt5/QtCore/gsiDeclQMargins.cc | 26 +++++----- src/gsiqt/qt5/QtCore/gsiDeclQMarginsF.cc | 22 ++++----- src/gsiqt/qt5/QtCore/gsiDeclQMetaMethod.cc | 4 +- .../QtCore/gsiDeclQOperatingSystemVersion.cc | 24 ++++++++++ src/gsiqt/qt5/QtCore/gsiDeclQPoint.cc | 20 ++++---- src/gsiqt/qt5/QtCore/gsiDeclQPointF.cc | 16 +++---- .../qt5/QtCore/gsiDeclQRandomGenerator.cc | 6 +++ src/gsiqt/qt5/QtCore/gsiDeclQRect.cc | 8 ++-- src/gsiqt/qt5/QtCore/gsiDeclQRectF.cc | 8 ++-- src/gsiqt/qt5/QtCore/gsiDeclQSize.cc | 12 ++--- src/gsiqt/qt5/QtCore/gsiDeclQSizeF.cc | 12 ++--- src/gsiqt/qt5/QtCore/gsiDeclQStorageInfo.cc | 4 +- src/gsiqt/qt5/QtCore/gsiDeclQVersionNumber.cc | 12 ++--- .../qt5/QtGui/gsiDeclQAccessible_State.cc | 2 +- src/gsiqt/qt5/QtGui/gsiDeclQCursor.cc | 4 +- src/gsiqt/qt5/QtGui/gsiDeclQMatrix4x4.cc | 20 ++++---- src/gsiqt/qt5/QtGui/gsiDeclQPageLayout.cc | 4 +- src/gsiqt/qt5/QtGui/gsiDeclQPageSize.cc | 4 +- src/gsiqt/qt5/QtGui/gsiDeclQPainterPath.cc | 4 +- src/gsiqt/qt5/QtGui/gsiDeclQPixelFormat.cc | 12 +++++ .../QtGui/gsiDeclQPointingDeviceUniqueId.cc | 4 +- src/gsiqt/qt5/QtGui/gsiDeclQPolygon.cc | 4 +- src/gsiqt/qt5/QtGui/gsiDeclQPolygonF.cc | 4 +- src/gsiqt/qt5/QtGui/gsiDeclQQuaternion.cc | 18 +++---- src/gsiqt/qt5/QtGui/gsiDeclQRegion.cc | 4 +- src/gsiqt/qt5/QtGui/gsiDeclQSurfaceFormat.cc | 4 +- src/gsiqt/qt5/QtGui/gsiDeclQTransform.cc | 8 ++-- src/gsiqt/qt5/QtGui/gsiDeclQVector2D.cc | 18 +++---- src/gsiqt/qt5/QtGui/gsiDeclQVector3D.cc | 20 ++++---- src/gsiqt/qt5/QtGui/gsiDeclQVector4D.cc | 20 ++++---- .../gsiDeclQCameraViewfinderSettings.cc | 2 +- .../gsiDeclQCamera_FrameRateRange.cc | 4 +- .../QtMultimedia/gsiDeclQMediaTimeInterval.cc | 4 +- .../QtMultimedia/gsiDeclQMediaTimeRange.cc | 8 ++-- src/gsiqt/qt5/QtNetwork/gsiDeclQHstsPolicy.cc | 4 +- .../gsiDeclQSslDiffieHellmanParameters.cc | 4 +- .../qt5/QtNetwork/gsiDeclQSslEllipticCurve.cc | 4 +- .../gsiDeclQSslPreSharedKeyAuthenticator.cc | 2 +- 40 files changed, 250 insertions(+), 160 deletions(-) diff --git a/src/gsiqt/qt5/QtCore/gsiDeclQCollatorSortKey.cc b/src/gsiqt/qt5/QtCore/gsiDeclQCollatorSortKey.cc index aedf57d1b9..099cb97366 100644 --- a/src/gsiqt/qt5/QtCore/gsiDeclQCollatorSortKey.cc +++ b/src/gsiqt/qt5/QtCore/gsiDeclQCollatorSortKey.cc @@ -114,7 +114,7 @@ static void _call_f_swap_2252 (const qt_gsi::GenericMethod * /*decl*/, void *cls // bool ::operator<(const QCollatorSortKey &lhs, const QCollatorSortKey &rhs) static bool op_QCollatorSortKey_operator_lt__5786(const QCollatorSortKey *_self, const QCollatorSortKey &rhs) { - return ::operator<(*_self, rhs); + return operator<(*_self, rhs); } diff --git a/src/gsiqt/qt5/QtCore/gsiDeclQDeadlineTimer.cc b/src/gsiqt/qt5/QtCore/gsiDeclQDeadlineTimer.cc index b2e2cd0f25..60d085c2d8 100644 --- a/src/gsiqt/qt5/QtCore/gsiDeclQDeadlineTimer.cc +++ b/src/gsiqt/qt5/QtCore/gsiDeclQDeadlineTimer.cc @@ -420,6 +420,46 @@ static void _call_f_current_1680 (const qt_gsi::GenericStaticMethod * /*decl*/, } +// bool ::operator==(QDeadlineTimer d1, QDeadlineTimer d2) +static bool op_QDeadlineTimer_operator_eq__eq__3532(QDeadlineTimer *_self, QDeadlineTimer d2) { + return operator==(*_self, d2); +} + +// bool ::operator!=(QDeadlineTimer d1, QDeadlineTimer d2) +static bool op_QDeadlineTimer_operator_excl__eq__3532(QDeadlineTimer *_self, QDeadlineTimer d2) { + return operator!=(*_self, d2); +} + +// bool ::operator<(QDeadlineTimer d1, QDeadlineTimer d2) +static bool op_QDeadlineTimer_operator_lt__3532(QDeadlineTimer *_self, QDeadlineTimer d2) { + return operator<(*_self, d2); +} + +// bool ::operator<=(QDeadlineTimer d1, QDeadlineTimer d2) +static bool op_QDeadlineTimer_operator_lt__eq__3532(QDeadlineTimer *_self, QDeadlineTimer d2) { + return operator<=(*_self, d2); +} + +// bool ::operator>(QDeadlineTimer d1, QDeadlineTimer d2) +static bool op_QDeadlineTimer_operator_gt__3532(QDeadlineTimer *_self, QDeadlineTimer d2) { + return operator>(*_self, d2); +} + +// bool ::operator>=(QDeadlineTimer d1, QDeadlineTimer d2) +static bool op_QDeadlineTimer_operator_gt__eq__3532(QDeadlineTimer *_self, QDeadlineTimer d2) { + return operator>=(*_self, d2); +} + +// QDeadlineTimer ::operator-(QDeadlineTimer dt, qint64 msecs) +static QDeadlineTimer op_QDeadlineTimer_operator_minus__2698(QDeadlineTimer *_self, qint64 msecs) { + return operator-(*_self, msecs); +} + +// qint64 ::operator-(QDeadlineTimer dt1, QDeadlineTimer dt2) +static qint64 op_QDeadlineTimer_operator_minus__3532(QDeadlineTimer *_self, QDeadlineTimer dt2) { + return operator-(*_self, dt2); +} + namespace gsi { @@ -446,6 +486,14 @@ static gsi::Methods methods_QDeadlineTimer () { methods += new qt_gsi::GenericMethod (":timerType", "@brief Method Qt::TimerType QDeadlineTimer::timerType()\n", true, &_init_f_timerType_c0, &_call_f_timerType_c0); methods += new qt_gsi::GenericStaticMethod ("addNSecs", "@brief Static method QDeadlineTimer QDeadlineTimer::addNSecs(QDeadlineTimer dt, qint64 nsecs)\nThis method is static and can be called without an instance.", &_init_f_addNSecs_2698, &_call_f_addNSecs_2698); methods += new qt_gsi::GenericStaticMethod ("current", "@brief Static method QDeadlineTimer QDeadlineTimer::current(Qt::TimerType timerType)\nThis method is static and can be called without an instance.", &_init_f_current_1680, &_call_f_current_1680); + methods += gsi::method_ext("==", &::op_QDeadlineTimer_operator_eq__eq__3532, gsi::arg ("d2"), "@brief Operator bool ::operator==(QDeadlineTimer d1, QDeadlineTimer d2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QDeadlineTimer_operator_excl__eq__3532, gsi::arg ("d2"), "@brief Operator bool ::operator!=(QDeadlineTimer d1, QDeadlineTimer d2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("<", &::op_QDeadlineTimer_operator_lt__3532, gsi::arg ("d2"), "@brief Operator bool ::operator<(QDeadlineTimer d1, QDeadlineTimer d2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("<=", &::op_QDeadlineTimer_operator_lt__eq__3532, gsi::arg ("d2"), "@brief Operator bool ::operator<=(QDeadlineTimer d1, QDeadlineTimer d2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext(">", &::op_QDeadlineTimer_operator_gt__3532, gsi::arg ("d2"), "@brief Operator bool ::operator>(QDeadlineTimer d1, QDeadlineTimer d2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext(">=", &::op_QDeadlineTimer_operator_gt__eq__3532, gsi::arg ("d2"), "@brief Operator bool ::operator>=(QDeadlineTimer d1, QDeadlineTimer d2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("-", &::op_QDeadlineTimer_operator_minus__2698, gsi::arg ("msecs"), "@brief Operator QDeadlineTimer ::operator-(QDeadlineTimer dt, qint64 msecs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("-", &::op_QDeadlineTimer_operator_minus__3532, gsi::arg ("dt2"), "@brief Operator qint64 ::operator-(QDeadlineTimer dt1, QDeadlineTimer dt2)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt5/QtCore/gsiDeclQMargins.cc b/src/gsiqt/qt5/QtCore/gsiDeclQMargins.cc index 17416d2e0c..a09bb6d812 100644 --- a/src/gsiqt/qt5/QtCore/gsiDeclQMargins.cc +++ b/src/gsiqt/qt5/QtCore/gsiDeclQMargins.cc @@ -387,67 +387,67 @@ static void _call_f_top_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, g // bool ::operator==(const QMargins &m1, const QMargins &m2) static bool op_QMargins_operator_eq__eq__4122(const QMargins *_self, const QMargins &m2) { - return ::operator==(*_self, m2); + return operator==(*_self, m2); } // bool ::operator!=(const QMargins &m1, const QMargins &m2) static bool op_QMargins_operator_excl__eq__4122(const QMargins *_self, const QMargins &m2) { - return ::operator!=(*_self, m2); + return operator!=(*_self, m2); } // QMargins ::operator+(const QMargins &m1, const QMargins &m2) static QMargins op_QMargins_operator_plus__4122(const QMargins *_self, const QMargins &m2) { - return ::operator+(*_self, m2); + return operator+(*_self, m2); } // QMargins ::operator-(const QMargins &m1, const QMargins &m2) static QMargins op_QMargins_operator_minus__4122(const QMargins *_self, const QMargins &m2) { - return ::operator-(*_self, m2); + return operator-(*_self, m2); } // QMargins ::operator+(const QMargins &lhs, int rhs) static QMargins op_QMargins_operator_plus__2774(const QMargins *_self, int rhs) { - return ::operator+(*_self, rhs); + return operator+(*_self, rhs); } // QMargins ::operator-(const QMargins &lhs, int rhs) static QMargins op_QMargins_operator_minus__2774(const QMargins *_self, int rhs) { - return ::operator-(*_self, rhs); + return operator-(*_self, rhs); } // QMargins ::operator*(const QMargins &margins, int factor) static QMargins op_QMargins_operator_star__2774(const QMargins *_self, int factor) { - return ::operator*(*_self, factor); + return operator*(*_self, factor); } // QMargins ::operator*(const QMargins &margins, qreal factor) static QMargins op_QMargins_operator_star__2976(const QMargins *_self, qreal factor) { - return ::operator*(*_self, factor); + return operator*(*_self, factor); } // QMargins ::operator/(const QMargins &margins, int divisor) static QMargins op_QMargins_operator_slash__2774(const QMargins *_self, int divisor) { - return ::operator/(*_self, divisor); + return operator/(*_self, divisor); } // QMargins ::operator/(const QMargins &margins, qreal divisor) static QMargins op_QMargins_operator_slash__2976(const QMargins *_self, qreal divisor) { - return ::operator/(*_self, divisor); + return operator/(*_self, divisor); } // QMargins ::operator+(const QMargins &margins) static QMargins op_QMargins_operator_plus__2115(const QMargins *_self) { - return ::operator+(*_self); + return operator+(*_self); } // QMargins ::operator-(const QMargins &margins) static QMargins op_QMargins_operator_minus__2115(const QMargins *_self) { - return ::operator-(*_self); + return operator-(*_self); } // QRect ::operator+(const QMargins &margins, const QRect &rectangle) static QRect op_QMargins_operator_plus__3799(const QMargins *_self, const QRect &rectangle) { - return ::operator+(*_self, rectangle); + return operator+(*_self, rectangle); } diff --git a/src/gsiqt/qt5/QtCore/gsiDeclQMarginsF.cc b/src/gsiqt/qt5/QtCore/gsiDeclQMarginsF.cc index 082bba067b..8cfbe1c8bb 100644 --- a/src/gsiqt/qt5/QtCore/gsiDeclQMarginsF.cc +++ b/src/gsiqt/qt5/QtCore/gsiDeclQMarginsF.cc @@ -384,57 +384,57 @@ static void _call_f_top_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, g // bool ::operator==(const QMarginsF &lhs, const QMarginsF &rhs) static bool op_QMarginsF_operator_eq__eq__4262(const QMarginsF *_self, const QMarginsF &rhs) { - return ::operator==(*_self, rhs); + return operator==(*_self, rhs); } // bool ::operator!=(const QMarginsF &lhs, const QMarginsF &rhs) static bool op_QMarginsF_operator_excl__eq__4262(const QMarginsF *_self, const QMarginsF &rhs) { - return ::operator!=(*_self, rhs); + return operator!=(*_self, rhs); } // QMarginsF ::operator+(const QMarginsF &lhs, const QMarginsF &rhs) static QMarginsF op_QMarginsF_operator_plus__4262(const QMarginsF *_self, const QMarginsF &rhs) { - return ::operator+(*_self, rhs); + return operator+(*_self, rhs); } // QMarginsF ::operator-(const QMarginsF &lhs, const QMarginsF &rhs) static QMarginsF op_QMarginsF_operator_minus__4262(const QMarginsF *_self, const QMarginsF &rhs) { - return ::operator-(*_self, rhs); + return operator-(*_self, rhs); } // QMarginsF ::operator+(const QMarginsF &lhs, qreal rhs) static QMarginsF op_QMarginsF_operator_plus__3046(const QMarginsF *_self, qreal rhs) { - return ::operator+(*_self, rhs); + return operator+(*_self, rhs); } // QMarginsF ::operator-(const QMarginsF &lhs, qreal rhs) static QMarginsF op_QMarginsF_operator_minus__3046(const QMarginsF *_self, qreal rhs) { - return ::operator-(*_self, rhs); + return operator-(*_self, rhs); } // QMarginsF ::operator*(const QMarginsF &lhs, qreal rhs) static QMarginsF op_QMarginsF_operator_star__3046(const QMarginsF *_self, qreal rhs) { - return ::operator*(*_self, rhs); + return operator*(*_self, rhs); } // QMarginsF ::operator/(const QMarginsF &lhs, qreal divisor) static QMarginsF op_QMarginsF_operator_slash__3046(const QMarginsF *_self, qreal divisor) { - return ::operator/(*_self, divisor); + return operator/(*_self, divisor); } // QMarginsF ::operator+(const QMarginsF &margins) static QMarginsF op_QMarginsF_operator_plus__2185(const QMarginsF *_self) { - return ::operator+(*_self); + return operator+(*_self); } // QMarginsF ::operator-(const QMarginsF &margins) static QMarginsF op_QMarginsF_operator_minus__2185(const QMarginsF *_self) { - return ::operator-(*_self); + return operator-(*_self); } // QRectF ::operator+(const QMarginsF &lhs, const QRectF &rhs) static QRectF op_QMarginsF_operator_plus__3939(const QMarginsF *_self, const QRectF &rhs) { - return ::operator+(*_self, rhs); + return operator+(*_self, rhs); } diff --git a/src/gsiqt/qt5/QtCore/gsiDeclQMetaMethod.cc b/src/gsiqt/qt5/QtCore/gsiDeclQMetaMethod.cc index 898f3d2d5b..42a5d75adb 100644 --- a/src/gsiqt/qt5/QtCore/gsiDeclQMetaMethod.cc +++ b/src/gsiqt/qt5/QtCore/gsiDeclQMetaMethod.cc @@ -317,12 +317,12 @@ static void _call_f_typeName_c0 (const qt_gsi::GenericMethod * /*decl*/, void *c // bool ::operator==(const QMetaMethod &m1, const QMetaMethod &m2) static bool op_QMetaMethod_operator_eq__eq__4680(const QMetaMethod *_self, const QMetaMethod &m2) { - return ::operator==(*_self, m2); + return operator==(*_self, m2); } // bool ::operator!=(const QMetaMethod &m1, const QMetaMethod &m2) static bool op_QMetaMethod_operator_excl__eq__4680(const QMetaMethod *_self, const QMetaMethod &m2) { - return ::operator!=(*_self, m2); + return operator!=(*_self, m2); } diff --git a/src/gsiqt/qt5/QtCore/gsiDeclQOperatingSystemVersion.cc b/src/gsiqt/qt5/QtCore/gsiDeclQOperatingSystemVersion.cc index 818293963d..ed00b19ee7 100644 --- a/src/gsiqt/qt5/QtCore/gsiDeclQOperatingSystemVersion.cc +++ b/src/gsiqt/qt5/QtCore/gsiDeclQOperatingSystemVersion.cc @@ -183,6 +183,26 @@ static void _call_f_currentType_0 (const qt_gsi::GenericStaticMethod * /*decl*/, } +// bool ::operator>(const QOperatingSystemVersion &lhs, const QOperatingSystemVersion &rhs) +static bool op_QOperatingSystemVersion_operator_gt__7328(const QOperatingSystemVersion *_self, const QOperatingSystemVersion &rhs) { + return operator>(*_self, rhs); +} + +// bool ::operator>=(const QOperatingSystemVersion &lhs, const QOperatingSystemVersion &rhs) +static bool op_QOperatingSystemVersion_operator_gt__eq__7328(const QOperatingSystemVersion *_self, const QOperatingSystemVersion &rhs) { + return operator>=(*_self, rhs); +} + +// bool ::operator<(const QOperatingSystemVersion &lhs, const QOperatingSystemVersion &rhs) +static bool op_QOperatingSystemVersion_operator_lt__7328(const QOperatingSystemVersion *_self, const QOperatingSystemVersion &rhs) { + return operator<(*_self, rhs); +} + +// bool ::operator<=(const QOperatingSystemVersion &lhs, const QOperatingSystemVersion &rhs) +static bool op_QOperatingSystemVersion_operator_lt__eq__7328(const QOperatingSystemVersion *_self, const QOperatingSystemVersion &rhs) { + return operator<=(*_self, rhs); +} + namespace gsi { @@ -198,6 +218,10 @@ static gsi::Methods methods_QOperatingSystemVersion () { methods += new qt_gsi::GenericMethod ("type", "@brief Method QOperatingSystemVersion::OSType QOperatingSystemVersion::type()\n", true, &_init_f_type_c0, &_call_f_type_c0); methods += new qt_gsi::GenericStaticMethod ("current", "@brief Static method QOperatingSystemVersion QOperatingSystemVersion::current()\nThis method is static and can be called without an instance.", &_init_f_current_0, &_call_f_current_0); methods += new qt_gsi::GenericStaticMethod ("currentType", "@brief Static method QOperatingSystemVersion::OSType QOperatingSystemVersion::currentType()\nThis method is static and can be called without an instance.", &_init_f_currentType_0, &_call_f_currentType_0); + methods += gsi::method_ext(">", &::op_QOperatingSystemVersion_operator_gt__7328, gsi::arg ("rhs"), "@brief Operator bool ::operator>(const QOperatingSystemVersion &lhs, const QOperatingSystemVersion &rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext(">=", &::op_QOperatingSystemVersion_operator_gt__eq__7328, gsi::arg ("rhs"), "@brief Operator bool ::operator>=(const QOperatingSystemVersion &lhs, const QOperatingSystemVersion &rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("<", &::op_QOperatingSystemVersion_operator_lt__7328, gsi::arg ("rhs"), "@brief Operator bool ::operator<(const QOperatingSystemVersion &lhs, const QOperatingSystemVersion &rhs)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("<=", &::op_QOperatingSystemVersion_operator_lt__eq__7328, gsi::arg ("rhs"), "@brief Operator bool ::operator<=(const QOperatingSystemVersion &lhs, const QOperatingSystemVersion &rhs)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt5/QtCore/gsiDeclQPoint.cc b/src/gsiqt/qt5/QtCore/gsiDeclQPoint.cc index b7e293229c..c7c0d540e7 100644 --- a/src/gsiqt/qt5/QtCore/gsiDeclQPoint.cc +++ b/src/gsiqt/qt5/QtCore/gsiDeclQPoint.cc @@ -342,52 +342,52 @@ static void _call_f_dotProduct_3724 (const qt_gsi::GenericStaticMethod * /*decl* // bool ::operator==(const QPoint &p1, const QPoint &p2) static bool op_QPoint_operator_eq__eq__3724(const QPoint *_self, const QPoint &p2) { - return ::operator==(*_self, p2); + return operator==(*_self, p2); } // bool ::operator!=(const QPoint &p1, const QPoint &p2) static bool op_QPoint_operator_excl__eq__3724(const QPoint *_self, const QPoint &p2) { - return ::operator!=(*_self, p2); + return operator!=(*_self, p2); } // const QPoint ::operator+(const QPoint &p1, const QPoint &p2) static const QPoint op_QPoint_operator_plus__3724(const QPoint *_self, const QPoint &p2) { - return ::operator+(*_self, p2); + return operator+(*_self, p2); } // const QPoint ::operator-(const QPoint &p1, const QPoint &p2) static const QPoint op_QPoint_operator_minus__3724(const QPoint *_self, const QPoint &p2) { - return ::operator-(*_self, p2); + return operator-(*_self, p2); } // const QPoint ::operator*(const QPoint &p, float factor) static const QPoint op_QPoint_operator_star__2778(const QPoint *_self, float factor) { - return ::operator*(*_self, factor); + return operator*(*_self, factor); } // const QPoint ::operator*(const QPoint &p, double factor) static const QPoint op_QPoint_operator_star__2879(const QPoint *_self, double factor) { - return ::operator*(*_self, factor); + return operator*(*_self, factor); } // const QPoint ::operator*(const QPoint &p, int factor) static const QPoint op_QPoint_operator_star__2575(const QPoint *_self, int factor) { - return ::operator*(*_self, factor); + return operator*(*_self, factor); } // const QPoint ::operator+(const QPoint &p) static const QPoint op_QPoint_operator_plus__1916(const QPoint *_self) { - return ::operator+(*_self); + return operator+(*_self); } // const QPoint ::operator-(const QPoint &p) static const QPoint op_QPoint_operator_minus__1916(const QPoint *_self) { - return ::operator-(*_self); + return operator-(*_self); } // const QPoint ::operator/(const QPoint &p, qreal c) static const QPoint op_QPoint_operator_slash__2777(const QPoint *_self, qreal c) { - return ::operator/(*_self, c); + return operator/(*_self, c); } diff --git a/src/gsiqt/qt5/QtCore/gsiDeclQPointF.cc b/src/gsiqt/qt5/QtCore/gsiDeclQPointF.cc index ccfdcb26dc..7091bad58a 100644 --- a/src/gsiqt/qt5/QtCore/gsiDeclQPointF.cc +++ b/src/gsiqt/qt5/QtCore/gsiDeclQPointF.cc @@ -338,42 +338,42 @@ static void _call_f_dotProduct_3864 (const qt_gsi::GenericStaticMethod * /*decl* // bool ::operator==(const QPointF &p1, const QPointF &p2) static bool op_QPointF_operator_eq__eq__3864(const QPointF *_self, const QPointF &p2) { - return ::operator==(*_self, p2); + return operator==(*_self, p2); } // bool ::operator!=(const QPointF &p1, const QPointF &p2) static bool op_QPointF_operator_excl__eq__3864(const QPointF *_self, const QPointF &p2) { - return ::operator!=(*_self, p2); + return operator!=(*_self, p2); } // const QPointF ::operator+(const QPointF &p1, const QPointF &p2) static const QPointF op_QPointF_operator_plus__3864(const QPointF *_self, const QPointF &p2) { - return ::operator+(*_self, p2); + return operator+(*_self, p2); } // const QPointF ::operator-(const QPointF &p1, const QPointF &p2) static const QPointF op_QPointF_operator_minus__3864(const QPointF *_self, const QPointF &p2) { - return ::operator-(*_self, p2); + return operator-(*_self, p2); } // const QPointF ::operator*(const QPointF &p, qreal c) static const QPointF op_QPointF_operator_star__2847(const QPointF *_self, qreal c) { - return ::operator*(*_self, c); + return operator*(*_self, c); } // const QPointF ::operator+(const QPointF &p) static const QPointF op_QPointF_operator_plus__1986(const QPointF *_self) { - return ::operator+(*_self); + return operator+(*_self); } // const QPointF ::operator-(const QPointF &p) static const QPointF op_QPointF_operator_minus__1986(const QPointF *_self) { - return ::operator-(*_self); + return operator-(*_self); } // const QPointF ::operator/(const QPointF &p, qreal divisor) static const QPointF op_QPointF_operator_slash__2847(const QPointF *_self, qreal divisor) { - return ::operator/(*_self, divisor); + return operator/(*_self, divisor); } diff --git a/src/gsiqt/qt5/QtCore/gsiDeclQRandomGenerator.cc b/src/gsiqt/qt5/QtCore/gsiDeclQRandomGenerator.cc index 3ffa7c33f0..4ab69e1bfe 100644 --- a/src/gsiqt/qt5/QtCore/gsiDeclQRandomGenerator.cc +++ b/src/gsiqt/qt5/QtCore/gsiDeclQRandomGenerator.cc @@ -391,6 +391,11 @@ static void _call_f_system_0 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi: } +// bool ::operator!=(const QRandomGenerator &rng1, const QRandomGenerator &rng2) +static bool op_QRandomGenerator_operator_excl__eq__5768(const QRandomGenerator *_self, const QRandomGenerator &rng2) { + return operator!=(*_self, rng2); +} + namespace gsi { @@ -417,6 +422,7 @@ static gsi::Methods methods_QRandomGenerator () { methods += new qt_gsi::GenericStaticMethod ("min", "@brief Static method quint32 QRandomGenerator::min()\nThis method is static and can be called without an instance.", &_init_f_min_0, &_call_f_min_0); methods += new qt_gsi::GenericStaticMethod ("securelySeeded", "@brief Static method QRandomGenerator QRandomGenerator::securelySeeded()\nThis method is static and can be called without an instance.", &_init_f_securelySeeded_0, &_call_f_securelySeeded_0); methods += new qt_gsi::GenericStaticMethod ("system", "@brief Static method QRandomGenerator *QRandomGenerator::system()\nThis method is static and can be called without an instance.", &_init_f_system_0, &_call_f_system_0); + methods += gsi::method_ext("!=", &::op_QRandomGenerator_operator_excl__eq__5768, gsi::arg ("rng2"), "@brief Operator bool ::operator!=(const QRandomGenerator &rng1, const QRandomGenerator &rng2)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt5/QtCore/gsiDeclQRect.cc b/src/gsiqt/qt5/QtCore/gsiDeclQRect.cc index 6053ac7785..2a11ac0be3 100644 --- a/src/gsiqt/qt5/QtCore/gsiDeclQRect.cc +++ b/src/gsiqt/qt5/QtCore/gsiDeclQRect.cc @@ -1452,22 +1452,22 @@ static void _call_f_y_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi // bool ::operator==(const QRect &, const QRect &) static bool op_QRect_operator_eq__eq__3476(const QRect *_self, const QRect &arg2) { - return ::operator==(*_self, arg2); + return operator==(*_self, arg2); } // bool ::operator!=(const QRect &, const QRect &) static bool op_QRect_operator_excl__eq__3476(const QRect *_self, const QRect &arg2) { - return ::operator!=(*_self, arg2); + return operator!=(*_self, arg2); } // QRect ::operator+(const QRect &rectangle, const QMargins &margins) static QRect op_QRect_operator_plus__3799u1(const QRect *_self, const QMargins &margins) { - return ::operator+(*_self, margins); + return operator+(*_self, margins); } // QRect ::operator-(const QRect &lhs, const QMargins &rhs) static QRect op_QRect_operator_minus__3799(const QRect *_self, const QMargins &rhs) { - return ::operator-(*_self, rhs); + return operator-(*_self, rhs); } diff --git a/src/gsiqt/qt5/QtCore/gsiDeclQRectF.cc b/src/gsiqt/qt5/QtCore/gsiDeclQRectF.cc index 0ebc7aeea0..9406483f20 100644 --- a/src/gsiqt/qt5/QtCore/gsiDeclQRectF.cc +++ b/src/gsiqt/qt5/QtCore/gsiDeclQRectF.cc @@ -1471,22 +1471,22 @@ static void _call_f_y_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi // bool ::operator==(const QRectF &, const QRectF &) static bool op_QRectF_operator_eq__eq__3616(const QRectF *_self, const QRectF &arg2) { - return ::operator==(*_self, arg2); + return operator==(*_self, arg2); } // bool ::operator!=(const QRectF &, const QRectF &) static bool op_QRectF_operator_excl__eq__3616(const QRectF *_self, const QRectF &arg2) { - return ::operator!=(*_self, arg2); + return operator!=(*_self, arg2); } // QRectF ::operator+(const QRectF &lhs, const QMarginsF &rhs) static QRectF op_QRectF_operator_plus__3939u1(const QRectF *_self, const QMarginsF &rhs) { - return ::operator+(*_self, rhs); + return operator+(*_self, rhs); } // QRectF ::operator-(const QRectF &lhs, const QMarginsF &rhs) static QRectF op_QRectF_operator_minus__3939(const QRectF *_self, const QMarginsF &rhs) { - return ::operator-(*_self, rhs); + return operator-(*_self, rhs); } diff --git a/src/gsiqt/qt5/QtCore/gsiDeclQSize.cc b/src/gsiqt/qt5/QtCore/gsiDeclQSize.cc index 9763c56e87..e81a78ff4a 100644 --- a/src/gsiqt/qt5/QtCore/gsiDeclQSize.cc +++ b/src/gsiqt/qt5/QtCore/gsiDeclQSize.cc @@ -460,32 +460,32 @@ static void _call_f_width_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, // bool ::operator==(const QSize &s1, const QSize &s2) static bool op_QSize_operator_eq__eq__3502(const QSize *_self, const QSize &s2) { - return ::operator==(*_self, s2); + return operator==(*_self, s2); } // bool ::operator!=(const QSize &s1, const QSize &s2) static bool op_QSize_operator_excl__eq__3502(const QSize *_self, const QSize &s2) { - return ::operator!=(*_self, s2); + return operator!=(*_self, s2); } // const QSize ::operator+(const QSize &s1, const QSize &s2) static const QSize op_QSize_operator_plus__3502(const QSize *_self, const QSize &s2) { - return ::operator+(*_self, s2); + return operator+(*_self, s2); } // const QSize ::operator-(const QSize &s1, const QSize &s2) static const QSize op_QSize_operator_minus__3502(const QSize *_self, const QSize &s2) { - return ::operator-(*_self, s2); + return operator-(*_self, s2); } // const QSize ::operator*(const QSize &s, qreal c) static const QSize op_QSize_operator_star__2666(const QSize *_self, qreal c) { - return ::operator*(*_self, c); + return operator*(*_self, c); } // const QSize ::operator/(const QSize &s, qreal c) static const QSize op_QSize_operator_slash__2666(const QSize *_self, qreal c) { - return ::operator/(*_self, c); + return operator/(*_self, c); } diff --git a/src/gsiqt/qt5/QtCore/gsiDeclQSizeF.cc b/src/gsiqt/qt5/QtCore/gsiDeclQSizeF.cc index 910c1c3cbb..755e2a9c80 100644 --- a/src/gsiqt/qt5/QtCore/gsiDeclQSizeF.cc +++ b/src/gsiqt/qt5/QtCore/gsiDeclQSizeF.cc @@ -495,32 +495,32 @@ static void _call_f_width_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, // bool ::operator==(const QSizeF &s1, const QSizeF &s2) static bool op_QSizeF_operator_eq__eq__3642(const QSizeF *_self, const QSizeF &s2) { - return ::operator==(*_self, s2); + return operator==(*_self, s2); } // bool ::operator!=(const QSizeF &s1, const QSizeF &s2) static bool op_QSizeF_operator_excl__eq__3642(const QSizeF *_self, const QSizeF &s2) { - return ::operator!=(*_self, s2); + return operator!=(*_self, s2); } // const QSizeF ::operator+(const QSizeF &s1, const QSizeF &s2) static const QSizeF op_QSizeF_operator_plus__3642(const QSizeF *_self, const QSizeF &s2) { - return ::operator+(*_self, s2); + return operator+(*_self, s2); } // const QSizeF ::operator-(const QSizeF &s1, const QSizeF &s2) static const QSizeF op_QSizeF_operator_minus__3642(const QSizeF *_self, const QSizeF &s2) { - return ::operator-(*_self, s2); + return operator-(*_self, s2); } // const QSizeF ::operator*(const QSizeF &s, qreal c) static const QSizeF op_QSizeF_operator_star__2736(const QSizeF *_self, qreal c) { - return ::operator*(*_self, c); + return operator*(*_self, c); } // const QSizeF ::operator/(const QSizeF &s, qreal c) static const QSizeF op_QSizeF_operator_slash__2736(const QSizeF *_self, qreal c) { - return ::operator/(*_self, c); + return operator/(*_self, c); } diff --git a/src/gsiqt/qt5/QtCore/gsiDeclQStorageInfo.cc b/src/gsiqt/qt5/QtCore/gsiDeclQStorageInfo.cc index 2c9feafc8d..594be186b7 100644 --- a/src/gsiqt/qt5/QtCore/gsiDeclQStorageInfo.cc +++ b/src/gsiqt/qt5/QtCore/gsiDeclQStorageInfo.cc @@ -425,12 +425,12 @@ static void _call_f_root_0 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::S // bool ::operator==(const QStorageInfo &first, const QStorageInfo &second) static bool op_QStorageInfo_operator_eq__eq__4922(const QStorageInfo *_self, const QStorageInfo &second) { - return ::operator==(*_self, second); + return operator==(*_self, second); } // bool ::operator!=(const QStorageInfo &first, const QStorageInfo &second) static bool op_QStorageInfo_operator_excl__eq__4922(const QStorageInfo *_self, const QStorageInfo &second) { - return ::operator!=(*_self, second); + return operator!=(*_self, second); } diff --git a/src/gsiqt/qt5/QtCore/gsiDeclQVersionNumber.cc b/src/gsiqt/qt5/QtCore/gsiDeclQVersionNumber.cc index b295957e23..f932e67b0c 100644 --- a/src/gsiqt/qt5/QtCore/gsiDeclQVersionNumber.cc +++ b/src/gsiqt/qt5/QtCore/gsiDeclQVersionNumber.cc @@ -376,32 +376,32 @@ static void _call_f_fromString_2870 (const qt_gsi::GenericStaticMethod * /*decl* // bool ::operator>(const QVersionNumber &lhs, const QVersionNumber &rhs) static bool op_QVersionNumber_operator_gt__5398(const QVersionNumber *_self, const QVersionNumber &rhs) { - return ::operator>(*_self, rhs); + return operator>(*_self, rhs); } // bool ::operator>=(const QVersionNumber &lhs, const QVersionNumber &rhs) static bool op_QVersionNumber_operator_gt__eq__5398(const QVersionNumber *_self, const QVersionNumber &rhs) { - return ::operator>=(*_self, rhs); + return operator>=(*_self, rhs); } // bool ::operator<(const QVersionNumber &lhs, const QVersionNumber &rhs) static bool op_QVersionNumber_operator_lt__5398(const QVersionNumber *_self, const QVersionNumber &rhs) { - return ::operator<(*_self, rhs); + return operator<(*_self, rhs); } // bool ::operator<=(const QVersionNumber &lhs, const QVersionNumber &rhs) static bool op_QVersionNumber_operator_lt__eq__5398(const QVersionNumber *_self, const QVersionNumber &rhs) { - return ::operator<=(*_self, rhs); + return operator<=(*_self, rhs); } // bool ::operator==(const QVersionNumber &lhs, const QVersionNumber &rhs) static bool op_QVersionNumber_operator_eq__eq__5398(const QVersionNumber *_self, const QVersionNumber &rhs) { - return ::operator==(*_self, rhs); + return operator==(*_self, rhs); } // bool ::operator!=(const QVersionNumber &lhs, const QVersionNumber &rhs) static bool op_QVersionNumber_operator_excl__eq__5398(const QVersionNumber *_self, const QVersionNumber &rhs) { - return ::operator!=(*_self, rhs); + return operator!=(*_self, rhs); } diff --git a/src/gsiqt/qt5/QtGui/gsiDeclQAccessible_State.cc b/src/gsiqt/qt5/QtGui/gsiDeclQAccessible_State.cc index 73c6395c6c..2bb955fad4 100644 --- a/src/gsiqt/qt5/QtGui/gsiDeclQAccessible_State.cc +++ b/src/gsiqt/qt5/QtGui/gsiDeclQAccessible_State.cc @@ -52,7 +52,7 @@ static void _call_ctor_QAccessible_State_0 (const qt_gsi::GenericStaticMethod * // bool ::operator==(const QAccessible::State &first, const QAccessible::State &second) static bool op_QAccessible_State_operator_eq__eq__5950(const QAccessible::State *_self, const QAccessible::State &second) { - return ::operator==(*_self, second); + return operator==(*_self, second); } diff --git a/src/gsiqt/qt5/QtGui/gsiDeclQCursor.cc b/src/gsiqt/qt5/QtGui/gsiDeclQCursor.cc index 7ea6ef23f5..c273308b75 100644 --- a/src/gsiqt/qt5/QtGui/gsiDeclQCursor.cc +++ b/src/gsiqt/qt5/QtGui/gsiDeclQCursor.cc @@ -405,12 +405,12 @@ static void _call_f_setPos_3119 (const qt_gsi::GenericStaticMethod * /*decl*/, g // bool ::operator==(const QCursor &lhs, const QCursor &rhs) static bool op_QCursor_operator_eq__eq__3956(const QCursor *_self, const QCursor &rhs) { - return ::operator==(*_self, rhs); + return operator==(*_self, rhs); } // bool ::operator!=(const QCursor &lhs, const QCursor &rhs) static bool op_QCursor_operator_excl__eq__3956(const QCursor *_self, const QCursor &rhs) { - return ::operator!=(*_self, rhs); + return operator!=(*_self, rhs); } diff --git a/src/gsiqt/qt5/QtGui/gsiDeclQMatrix4x4.cc b/src/gsiqt/qt5/QtGui/gsiDeclQMatrix4x4.cc index 75a59eb46f..719fc43050 100644 --- a/src/gsiqt/qt5/QtGui/gsiDeclQMatrix4x4.cc +++ b/src/gsiqt/qt5/QtGui/gsiDeclQMatrix4x4.cc @@ -1312,52 +1312,52 @@ static void _call_f_viewport_5280 (const qt_gsi::GenericMethod * /*decl*/, void // QMatrix4x4 ::operator/(const QMatrix4x4 &matrix, float divisor) static QMatrix4x4 op_QMatrix4x4_operator_slash__3109(const QMatrix4x4 *_self, float divisor) { - return ::operator/(*_self, divisor); + return operator/(*_self, divisor); } // QMatrix4x4 ::operator+(const QMatrix4x4 &m1, const QMatrix4x4 &m2) static QMatrix4x4 op_QMatrix4x4_operator_plus__4386(const QMatrix4x4 *_self, const QMatrix4x4 &m2) { - return ::operator+(*_self, m2); + return operator+(*_self, m2); } // QMatrix4x4 ::operator-(const QMatrix4x4 &m1, const QMatrix4x4 &m2) static QMatrix4x4 op_QMatrix4x4_operator_minus__4386(const QMatrix4x4 *_self, const QMatrix4x4 &m2) { - return ::operator-(*_self, m2); + return operator-(*_self, m2); } // QMatrix4x4 ::operator*(const QMatrix4x4 &m1, const QMatrix4x4 &m2) static QMatrix4x4 op_QMatrix4x4_operator_star__4386(const QMatrix4x4 *_self, const QMatrix4x4 &m2) { - return ::operator*(*_self, m2); + return operator*(*_self, m2); } // QVector3D ::operator*(const QMatrix4x4 &matrix, const QVector3D &vector) static QVector3D op_QMatrix4x4_operator_star__4279(const QMatrix4x4 *_self, const QVector3D &vector) { - return ::operator*(*_self, vector); + return operator*(*_self, vector); } // QVector4D ::operator*(const QMatrix4x4 &matrix, const QVector4D &vector) static QVector4D op_QMatrix4x4_operator_star__4280(const QMatrix4x4 *_self, const QVector4D &vector) { - return ::operator*(*_self, vector); + return operator*(*_self, vector); } // QPoint ::operator*(const QMatrix4x4 &matrix, const QPoint &point) static QPoint op_QMatrix4x4_operator_star__4055(const QMatrix4x4 *_self, const QPoint &point) { - return ::operator*(*_self, point); + return operator*(*_self, point); } // QPointF ::operator*(const QMatrix4x4 &matrix, const QPointF &point) static QPointF op_QMatrix4x4_operator_star__4125(const QMatrix4x4 *_self, const QPointF &point) { - return ::operator*(*_self, point); + return operator*(*_self, point); } // QMatrix4x4 ::operator-(const QMatrix4x4 &matrix) static QMatrix4x4 op_QMatrix4x4_operator_minus__2247(const QMatrix4x4 *_self) { - return ::operator-(*_self); + return operator-(*_self); } // QMatrix4x4 ::operator*(const QMatrix4x4 &matrix, float factor) static QMatrix4x4 op_QMatrix4x4_operator_star__3109(const QMatrix4x4 *_self, float factor) { - return ::operator*(*_self, factor); + return operator*(*_self, factor); } diff --git a/src/gsiqt/qt5/QtGui/gsiDeclQPageLayout.cc b/src/gsiqt/qt5/QtGui/gsiDeclQPageLayout.cc index 04bd701054..fb0a7fd7fa 100644 --- a/src/gsiqt/qt5/QtGui/gsiDeclQPageLayout.cc +++ b/src/gsiqt/qt5/QtGui/gsiDeclQPageLayout.cc @@ -672,12 +672,12 @@ static void _call_f_units_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, // bool ::operator==(const QPageLayout &lhs, const QPageLayout &rhs) static bool op_QPageLayout_operator_eq__eq__4718(const QPageLayout *_self, const QPageLayout &rhs) { - return ::operator==(*_self, rhs); + return operator==(*_self, rhs); } // bool ::operator!=(const QPageLayout &lhs, const QPageLayout &rhs) static bool op_QPageLayout_operator_excl__eq__4718(const QPageLayout *_self, const QPageLayout &rhs) { - return ::operator!=(*_self, rhs); + return operator!=(*_self, rhs); } diff --git a/src/gsiqt/qt5/QtGui/gsiDeclQPageSize.cc b/src/gsiqt/qt5/QtGui/gsiDeclQPageSize.cc index de927bebfe..3f6c76a34a 100644 --- a/src/gsiqt/qt5/QtGui/gsiDeclQPageSize.cc +++ b/src/gsiqt/qt5/QtGui/gsiDeclQPageSize.cc @@ -640,12 +640,12 @@ static void _call_f_windowsId_2390 (const qt_gsi::GenericStaticMethod * /*decl*/ // bool ::operator==(const QPageSize &lhs, const QPageSize &rhs) static bool op_QPageSize_operator_eq__eq__4264(const QPageSize *_self, const QPageSize &rhs) { - return ::operator==(*_self, rhs); + return operator==(*_self, rhs); } // bool ::operator!=(const QPageSize &lhs, const QPageSize &rhs) static bool op_QPageSize_operator_excl__eq__4264(const QPageSize *_self, const QPageSize &rhs) { - return ::operator!=(*_self, rhs); + return operator!=(*_self, rhs); } diff --git a/src/gsiqt/qt5/QtGui/gsiDeclQPainterPath.cc b/src/gsiqt/qt5/QtGui/gsiDeclQPainterPath.cc index ce66f14cfe..79105c569b 100644 --- a/src/gsiqt/qt5/QtGui/gsiDeclQPainterPath.cc +++ b/src/gsiqt/qt5/QtGui/gsiDeclQPainterPath.cc @@ -1744,12 +1744,12 @@ static void _call_f_united_c2514 (const qt_gsi::GenericMethod * /*decl*/, void * // QPainterPath ::operator *(const QPainterPath &p, const QMatrix &m) static QPainterPath op_QPainterPath_operator_star__4429(const QPainterPath *_self, const QMatrix &m) { - return ::operator *(*_self, m); + return operator *(*_self, m); } // QPainterPath ::operator *(const QPainterPath &p, const QTransform &m) static QPainterPath op_QPainterPath_operator_star__4756(const QPainterPath *_self, const QTransform &m) { - return ::operator *(*_self, m); + return operator *(*_self, m); } diff --git a/src/gsiqt/qt5/QtGui/gsiDeclQPixelFormat.cc b/src/gsiqt/qt5/QtGui/gsiDeclQPixelFormat.cc index 8dc66f3cff..ce129d9d06 100644 --- a/src/gsiqt/qt5/QtGui/gsiDeclQPixelFormat.cc +++ b/src/gsiqt/qt5/QtGui/gsiDeclQPixelFormat.cc @@ -435,6 +435,16 @@ static void _call_f_yuvLayout_c0 (const qt_gsi::GenericMethod * /*decl*/, void * } +// bool ::operator==(QPixelFormat fmt1, QPixelFormat fmt2) +static bool op_QPixelFormat_operator_eq__eq__3188(QPixelFormat *_self, QPixelFormat fmt2) { + return operator==(*_self, fmt2); +} + +// bool ::operator!=(QPixelFormat fmt1, QPixelFormat fmt2) +static bool op_QPixelFormat_operator_excl__eq__3188(QPixelFormat *_self, QPixelFormat fmt2) { + return operator!=(*_self, fmt2); +} + namespace gsi { @@ -465,6 +475,8 @@ static gsi::Methods methods_QPixelFormat () { methods += new qt_gsi::GenericMethod ("typeInterpretation", "@brief Method QPixelFormat::TypeInterpretation QPixelFormat::typeInterpretation()\n", true, &_init_f_typeInterpretation_c0, &_call_f_typeInterpretation_c0); methods += new qt_gsi::GenericMethod ("yellowSize", "@brief Method unsigned char QPixelFormat::yellowSize()\n", true, &_init_f_yellowSize_c0, &_call_f_yellowSize_c0); methods += new qt_gsi::GenericMethod ("yuvLayout", "@brief Method QPixelFormat::YUVLayout QPixelFormat::yuvLayout()\n", true, &_init_f_yuvLayout_c0, &_call_f_yuvLayout_c0); + methods += gsi::method_ext("==", &::op_QPixelFormat_operator_eq__eq__3188, gsi::arg ("fmt2"), "@brief Operator bool ::operator==(QPixelFormat fmt1, QPixelFormat fmt2)\nThis is the mapping of the global operator to the instance method."); + methods += gsi::method_ext("!=", &::op_QPixelFormat_operator_excl__eq__3188, gsi::arg ("fmt2"), "@brief Operator bool ::operator!=(QPixelFormat fmt1, QPixelFormat fmt2)\nThis is the mapping of the global operator to the instance method."); return methods; } diff --git a/src/gsiqt/qt5/QtGui/gsiDeclQPointingDeviceUniqueId.cc b/src/gsiqt/qt5/QtGui/gsiDeclQPointingDeviceUniqueId.cc index 5289a8e6cd..50585a39fc 100644 --- a/src/gsiqt/qt5/QtGui/gsiDeclQPointingDeviceUniqueId.cc +++ b/src/gsiqt/qt5/QtGui/gsiDeclQPointingDeviceUniqueId.cc @@ -101,12 +101,12 @@ static void _call_f_fromNumericId_986 (const qt_gsi::GenericStaticMethod * /*dec // bool ::operator==(QPointingDeviceUniqueId lhs, QPointingDeviceUniqueId rhs) static bool op_QPointingDeviceUniqueId_operator_eq__eq__5398(QPointingDeviceUniqueId *_self, QPointingDeviceUniqueId rhs) { - return ::operator==(*_self, rhs); + return operator==(*_self, rhs); } // bool ::operator!=(QPointingDeviceUniqueId lhs, QPointingDeviceUniqueId rhs) static bool op_QPointingDeviceUniqueId_operator_excl__eq__5398(QPointingDeviceUniqueId *_self, QPointingDeviceUniqueId rhs) { - return ::operator!=(*_self, rhs); + return operator!=(*_self, rhs); } diff --git a/src/gsiqt/qt5/QtGui/gsiDeclQPolygon.cc b/src/gsiqt/qt5/QtGui/gsiDeclQPolygon.cc index 367a1fab26..c2de76e116 100644 --- a/src/gsiqt/qt5/QtGui/gsiDeclQPolygon.cc +++ b/src/gsiqt/qt5/QtGui/gsiDeclQPolygon.cc @@ -654,12 +654,12 @@ static void _call_f_united_c2138 (const qt_gsi::GenericMethod * /*decl*/, void * // QPolygon ::operator *(const QPolygon &a, const QMatrix &m) static QPolygon op_QPolygon_operator_star__4053(const QPolygon *_self, const QMatrix &m) { - return ::operator *(*_self, m); + return operator *(*_self, m); } // QPolygon ::operator *(const QPolygon &a, const QTransform &m) static QPolygon op_QPolygon_operator_star__4380(const QPolygon *_self, const QTransform &m) { - return ::operator *(*_self, m); + return operator *(*_self, m); } diff --git a/src/gsiqt/qt5/QtGui/gsiDeclQPolygonF.cc b/src/gsiqt/qt5/QtGui/gsiDeclQPolygonF.cc index d2aec364f1..d414be8eaa 100644 --- a/src/gsiqt/qt5/QtGui/gsiDeclQPolygonF.cc +++ b/src/gsiqt/qt5/QtGui/gsiDeclQPolygonF.cc @@ -523,12 +523,12 @@ static void _call_f_united_c2208 (const qt_gsi::GenericMethod * /*decl*/, void * // QPolygonF ::operator *(const QPolygonF &a, const QMatrix &m) static QPolygonF op_QPolygonF_operator_star__4123(const QPolygonF *_self, const QMatrix &m) { - return ::operator *(*_self, m); + return operator *(*_self, m); } // QPolygonF ::operator *(const QPolygonF &a, const QTransform &m) static QPolygonF op_QPolygonF_operator_star__4450(const QPolygonF *_self, const QTransform &m) { - return ::operator *(*_self, m); + return operator *(*_self, m); } diff --git a/src/gsiqt/qt5/QtGui/gsiDeclQQuaternion.cc b/src/gsiqt/qt5/QtGui/gsiDeclQQuaternion.cc index 785b70c7d3..47a960e0b5 100644 --- a/src/gsiqt/qt5/QtGui/gsiDeclQQuaternion.cc +++ b/src/gsiqt/qt5/QtGui/gsiDeclQQuaternion.cc @@ -943,47 +943,47 @@ static void _call_f_slerp_5666 (const qt_gsi::GenericStaticMethod * /*decl*/, gs // bool ::operator==(const QQuaternion &q1, const QQuaternion &q2) static bool op_QQuaternion_operator_eq__eq__4804(const QQuaternion *_self, const QQuaternion &q2) { - return ::operator==(*_self, q2); + return operator==(*_self, q2); } // const QQuaternion ::operator*(const QQuaternion &q1, const QQuaternion &q2) static const QQuaternion op_QQuaternion_operator_star__4804(const QQuaternion *_self, const QQuaternion &q2) { - return ::operator*(*_self, q2); + return operator*(*_self, q2); } // bool ::operator!=(const QQuaternion &q1, const QQuaternion &q2) static bool op_QQuaternion_operator_excl__eq__4804(const QQuaternion *_self, const QQuaternion &q2) { - return ::operator!=(*_self, q2); + return operator!=(*_self, q2); } // const QQuaternion ::operator+(const QQuaternion &q1, const QQuaternion &q2) static const QQuaternion op_QQuaternion_operator_plus__4804(const QQuaternion *_self, const QQuaternion &q2) { - return ::operator+(*_self, q2); + return operator+(*_self, q2); } // const QQuaternion ::operator-(const QQuaternion &q1, const QQuaternion &q2) static const QQuaternion op_QQuaternion_operator_minus__4804(const QQuaternion *_self, const QQuaternion &q2) { - return ::operator-(*_self, q2); + return operator-(*_self, q2); } // const QQuaternion ::operator*(const QQuaternion &quaternion, float factor) static const QQuaternion op_QQuaternion_operator_star__3318(const QQuaternion *_self, float factor) { - return ::operator*(*_self, factor); + return operator*(*_self, factor); } // const QQuaternion ::operator-(const QQuaternion &quaternion) static const QQuaternion op_QQuaternion_operator_minus__2456(const QQuaternion *_self) { - return ::operator-(*_self); + return operator-(*_self); } // const QQuaternion ::operator/(const QQuaternion &quaternion, float divisor) static const QQuaternion op_QQuaternion_operator_slash__3318(const QQuaternion *_self, float divisor) { - return ::operator/(*_self, divisor); + return operator/(*_self, divisor); } // QVector3D ::operator*(const QQuaternion &quaternion, const QVector3D &vec) static QVector3D op_QQuaternion_operator_star__4488(const QQuaternion *_self, const QVector3D &vec) { - return ::operator*(*_self, vec); + return operator*(*_self, vec); } diff --git a/src/gsiqt/qt5/QtGui/gsiDeclQRegion.cc b/src/gsiqt/qt5/QtGui/gsiDeclQRegion.cc index 361d3b9cdf..431461a35e 100644 --- a/src/gsiqt/qt5/QtGui/gsiDeclQRegion.cc +++ b/src/gsiqt/qt5/QtGui/gsiDeclQRegion.cc @@ -927,12 +927,12 @@ static void _call_f_xored_c2006 (const qt_gsi::GenericMethod * /*decl*/, void *c // QRegion ::operator *(const QRegion &r, const QMatrix &m) static QRegion op_QRegion_operator_star__3921(const QRegion *_self, const QMatrix &m) { - return ::operator *(*_self, m); + return operator *(*_self, m); } // QRegion ::operator *(const QRegion &r, const QTransform &m) static QRegion op_QRegion_operator_star__4248(const QRegion *_self, const QTransform &m) { - return ::operator *(*_self, m); + return operator *(*_self, m); } diff --git a/src/gsiqt/qt5/QtGui/gsiDeclQSurfaceFormat.cc b/src/gsiqt/qt5/QtGui/gsiDeclQSurfaceFormat.cc index e064e71d36..4a1c845fa6 100644 --- a/src/gsiqt/qt5/QtGui/gsiDeclQSurfaceFormat.cc +++ b/src/gsiqt/qt5/QtGui/gsiDeclQSurfaceFormat.cc @@ -838,12 +838,12 @@ static void _call_f_setDefaultFormat_2724 (const qt_gsi::GenericStaticMethod * / // bool ::operator==(const QSurfaceFormat &, const QSurfaceFormat &) static bool op_QSurfaceFormat_operator_eq__eq__5340(const QSurfaceFormat *_self, const QSurfaceFormat &arg2) { - return ::operator==(*_self, arg2); + return operator==(*_self, arg2); } // bool ::operator!=(const QSurfaceFormat &, const QSurfaceFormat &) static bool op_QSurfaceFormat_operator_excl__eq__5340(const QSurfaceFormat *_self, const QSurfaceFormat &arg2) { - return ::operator!=(*_self, arg2); + return operator!=(*_self, arg2); } diff --git a/src/gsiqt/qt5/QtGui/gsiDeclQTransform.cc b/src/gsiqt/qt5/QtGui/gsiDeclQTransform.cc index 819bb14476..d1a5983ffd 100644 --- a/src/gsiqt/qt5/QtGui/gsiDeclQTransform.cc +++ b/src/gsiqt/qt5/QtGui/gsiDeclQTransform.cc @@ -1263,22 +1263,22 @@ static void _call_f_squareToQuad_3755 (const qt_gsi::GenericStaticMethod * /*dec // QTransform ::operator *(const QTransform &a, qreal n) static QTransform op_QTransform_operator_star__3211(const QTransform *_self, qreal n) { - return ::operator *(*_self, n); + return operator *(*_self, n); } // QTransform ::operator /(const QTransform &a, qreal n) static QTransform op_QTransform_operator_slash__3211(const QTransform *_self, qreal n) { - return ::operator /(*_self, n); + return operator /(*_self, n); } // QTransform ::operator +(const QTransform &a, qreal n) static QTransform op_QTransform_operator_plus__3211(const QTransform *_self, qreal n) { - return ::operator +(*_self, n); + return operator +(*_self, n); } // QTransform ::operator -(const QTransform &a, qreal n) static QTransform op_QTransform_operator_minus__3211(const QTransform *_self, qreal n) { - return ::operator -(*_self, n); + return operator -(*_self, n); } diff --git a/src/gsiqt/qt5/QtGui/gsiDeclQVector2D.cc b/src/gsiqt/qt5/QtGui/gsiDeclQVector2D.cc index f6313fb9b0..367eb50ddc 100644 --- a/src/gsiqt/qt5/QtGui/gsiDeclQVector2D.cc +++ b/src/gsiqt/qt5/QtGui/gsiDeclQVector2D.cc @@ -575,47 +575,47 @@ static void _call_f_dotProduct_4170 (const qt_gsi::GenericStaticMethod * /*decl* // bool ::operator==(const QVector2D &v1, const QVector2D &v2) static bool op_QVector2D_operator_eq__eq__4170(const QVector2D *_self, const QVector2D &v2) { - return ::operator==(*_self, v2); + return operator==(*_self, v2); } // bool ::operator!=(const QVector2D &v1, const QVector2D &v2) static bool op_QVector2D_operator_excl__eq__4170(const QVector2D *_self, const QVector2D &v2) { - return ::operator!=(*_self, v2); + return operator!=(*_self, v2); } // const QVector2D ::operator+(const QVector2D &v1, const QVector2D &v2) static const QVector2D op_QVector2D_operator_plus__4170(const QVector2D *_self, const QVector2D &v2) { - return ::operator+(*_self, v2); + return operator+(*_self, v2); } // const QVector2D ::operator-(const QVector2D &v1, const QVector2D &v2) static const QVector2D op_QVector2D_operator_minus__4170(const QVector2D *_self, const QVector2D &v2) { - return ::operator-(*_self, v2); + return operator-(*_self, v2); } // const QVector2D ::operator*(const QVector2D &vector, float factor) static const QVector2D op_QVector2D_operator_star__3001(const QVector2D *_self, float factor) { - return ::operator*(*_self, factor); + return operator*(*_self, factor); } // const QVector2D ::operator*(const QVector2D &v1, const QVector2D &v2) static const QVector2D op_QVector2D_operator_star__4170(const QVector2D *_self, const QVector2D &v2) { - return ::operator*(*_self, v2); + return operator*(*_self, v2); } // const QVector2D ::operator-(const QVector2D &vector) static const QVector2D op_QVector2D_operator_minus__2139(const QVector2D *_self) { - return ::operator-(*_self); + return operator-(*_self); } // const QVector2D ::operator/(const QVector2D &vector, float divisor) static const QVector2D op_QVector2D_operator_slash__3001(const QVector2D *_self, float divisor) { - return ::operator/(*_self, divisor); + return operator/(*_self, divisor); } // const QVector2D ::operator/(const QVector2D &vector, const QVector2D &divisor) static const QVector2D op_QVector2D_operator_slash__4170(const QVector2D *_self, const QVector2D &divisor) { - return ::operator/(*_self, divisor); + return operator/(*_self, divisor); } diff --git a/src/gsiqt/qt5/QtGui/gsiDeclQVector3D.cc b/src/gsiqt/qt5/QtGui/gsiDeclQVector3D.cc index 78b6bb3e0a..5151c2622c 100644 --- a/src/gsiqt/qt5/QtGui/gsiDeclQVector3D.cc +++ b/src/gsiqt/qt5/QtGui/gsiDeclQVector3D.cc @@ -799,52 +799,52 @@ static void _call_f_normal_6204 (const qt_gsi::GenericStaticMethod * /*decl*/, g // bool ::operator==(const QVector3D &v1, const QVector3D &v2) static bool op_QVector3D_operator_eq__eq__4172(const QVector3D *_self, const QVector3D &v2) { - return ::operator==(*_self, v2); + return operator==(*_self, v2); } // bool ::operator!=(const QVector3D &v1, const QVector3D &v2) static bool op_QVector3D_operator_excl__eq__4172(const QVector3D *_self, const QVector3D &v2) { - return ::operator!=(*_self, v2); + return operator!=(*_self, v2); } // const QVector3D ::operator+(const QVector3D &v1, const QVector3D &v2) static const QVector3D op_QVector3D_operator_plus__4172(const QVector3D *_self, const QVector3D &v2) { - return ::operator+(*_self, v2); + return operator+(*_self, v2); } // const QVector3D ::operator-(const QVector3D &v1, const QVector3D &v2) static const QVector3D op_QVector3D_operator_minus__4172(const QVector3D *_self, const QVector3D &v2) { - return ::operator-(*_self, v2); + return operator-(*_self, v2); } // const QVector3D ::operator*(const QVector3D &vector, float factor) static const QVector3D op_QVector3D_operator_star__3002(const QVector3D *_self, float factor) { - return ::operator*(*_self, factor); + return operator*(*_self, factor); } // const QVector3D ::operator*(const QVector3D &v1, const QVector3D &v2) static const QVector3D op_QVector3D_operator_star__4172(const QVector3D *_self, const QVector3D &v2) { - return ::operator*(*_self, v2); + return operator*(*_self, v2); } // const QVector3D ::operator-(const QVector3D &vector) static const QVector3D op_QVector3D_operator_minus__2140(const QVector3D *_self) { - return ::operator-(*_self); + return operator-(*_self); } // const QVector3D ::operator/(const QVector3D &vector, float divisor) static const QVector3D op_QVector3D_operator_slash__3002(const QVector3D *_self, float divisor) { - return ::operator/(*_self, divisor); + return operator/(*_self, divisor); } // const QVector3D ::operator/(const QVector3D &vector, const QVector3D &divisor) static const QVector3D op_QVector3D_operator_slash__4172(const QVector3D *_self, const QVector3D &divisor) { - return ::operator/(*_self, divisor); + return operator/(*_self, divisor); } // QVector3D ::operator*(const QVector3D &vector, const QMatrix4x4 &matrix) static QVector3D op_QVector3D_operator_star__4279u1(const QVector3D *_self, const QMatrix4x4 &matrix) { - return ::operator*(*_self, matrix); + return operator*(*_self, matrix); } diff --git a/src/gsiqt/qt5/QtGui/gsiDeclQVector4D.cc b/src/gsiqt/qt5/QtGui/gsiDeclQVector4D.cc index 60f094c9c4..4a397931e5 100644 --- a/src/gsiqt/qt5/QtGui/gsiDeclQVector4D.cc +++ b/src/gsiqt/qt5/QtGui/gsiDeclQVector4D.cc @@ -685,52 +685,52 @@ static void _call_f_dotProduct_4174 (const qt_gsi::GenericStaticMethod * /*decl* // bool ::operator==(const QVector4D &v1, const QVector4D &v2) static bool op_QVector4D_operator_eq__eq__4174(const QVector4D *_self, const QVector4D &v2) { - return ::operator==(*_self, v2); + return operator==(*_self, v2); } // bool ::operator!=(const QVector4D &v1, const QVector4D &v2) static bool op_QVector4D_operator_excl__eq__4174(const QVector4D *_self, const QVector4D &v2) { - return ::operator!=(*_self, v2); + return operator!=(*_self, v2); } // const QVector4D ::operator+(const QVector4D &v1, const QVector4D &v2) static const QVector4D op_QVector4D_operator_plus__4174(const QVector4D *_self, const QVector4D &v2) { - return ::operator+(*_self, v2); + return operator+(*_self, v2); } // const QVector4D ::operator-(const QVector4D &v1, const QVector4D &v2) static const QVector4D op_QVector4D_operator_minus__4174(const QVector4D *_self, const QVector4D &v2) { - return ::operator-(*_self, v2); + return operator-(*_self, v2); } // const QVector4D ::operator*(const QVector4D &vector, float factor) static const QVector4D op_QVector4D_operator_star__3003(const QVector4D *_self, float factor) { - return ::operator*(*_self, factor); + return operator*(*_self, factor); } // const QVector4D ::operator*(const QVector4D &v1, const QVector4D &v2) static const QVector4D op_QVector4D_operator_star__4174(const QVector4D *_self, const QVector4D &v2) { - return ::operator*(*_self, v2); + return operator*(*_self, v2); } // const QVector4D ::operator-(const QVector4D &vector) static const QVector4D op_QVector4D_operator_minus__2141(const QVector4D *_self) { - return ::operator-(*_self); + return operator-(*_self); } // const QVector4D ::operator/(const QVector4D &vector, float divisor) static const QVector4D op_QVector4D_operator_slash__3003(const QVector4D *_self, float divisor) { - return ::operator/(*_self, divisor); + return operator/(*_self, divisor); } // const QVector4D ::operator/(const QVector4D &vector, const QVector4D &divisor) static const QVector4D op_QVector4D_operator_slash__4174(const QVector4D *_self, const QVector4D &divisor) { - return ::operator/(*_self, divisor); + return operator/(*_self, divisor); } // QVector4D ::operator*(const QVector4D &vector, const QMatrix4x4 &matrix) static QVector4D op_QVector4D_operator_star__4280u1(const QVector4D *_self, const QMatrix4x4 &matrix) { - return ::operator*(*_self, matrix); + return operator*(*_self, matrix); } diff --git a/src/gsiqt/qt5/QtMultimedia/gsiDeclQCameraViewfinderSettings.cc b/src/gsiqt/qt5/QtMultimedia/gsiDeclQCameraViewfinderSettings.cc index 2bee16c4fe..08ea33d3c9 100644 --- a/src/gsiqt/qt5/QtMultimedia/gsiDeclQCameraViewfinderSettings.cc +++ b/src/gsiqt/qt5/QtMultimedia/gsiDeclQCameraViewfinderSettings.cc @@ -347,7 +347,7 @@ static void _call_f_swap_3176 (const qt_gsi::GenericMethod * /*decl*/, void *cls // bool ::operator!=(const QCameraViewfinderSettings &lhs, const QCameraViewfinderSettings &rhs) static bool op_QCameraViewfinderSettings_operator_excl__eq__7634(const QCameraViewfinderSettings *_self, const QCameraViewfinderSettings &rhs) { - return ::operator!=(*_self, rhs); + return operator!=(*_self, rhs); } diff --git a/src/gsiqt/qt5/QtMultimedia/gsiDeclQCamera_FrameRateRange.cc b/src/gsiqt/qt5/QtMultimedia/gsiDeclQCamera_FrameRateRange.cc index 84521a0f1f..332b358b16 100644 --- a/src/gsiqt/qt5/QtMultimedia/gsiDeclQCamera_FrameRateRange.cc +++ b/src/gsiqt/qt5/QtMultimedia/gsiDeclQCamera_FrameRateRange.cc @@ -74,12 +74,12 @@ static void _call_ctor_QCamera_FrameRateRange_2034 (const qt_gsi::GenericStaticM // bool ::operator==(const QCamera::FrameRateRange &r1, const QCamera::FrameRateRange &r2) static bool op_QCamera_FrameRateRange_operator_eq__eq__6842(const QCamera::FrameRateRange *_self, const QCamera::FrameRateRange &r2) { - return ::operator==(*_self, r2); + return operator==(*_self, r2); } // bool ::operator!=(const QCamera::FrameRateRange &r1, const QCamera::FrameRateRange &r2) static bool op_QCamera_FrameRateRange_operator_excl__eq__6842(const QCamera::FrameRateRange *_self, const QCamera::FrameRateRange &r2) { - return ::operator!=(*_self, r2); + return operator!=(*_self, r2); } diff --git a/src/gsiqt/qt5/QtMultimedia/gsiDeclQMediaTimeInterval.cc b/src/gsiqt/qt5/QtMultimedia/gsiDeclQMediaTimeInterval.cc index 03e9c912af..9041c834c5 100644 --- a/src/gsiqt/qt5/QtMultimedia/gsiDeclQMediaTimeInterval.cc +++ b/src/gsiqt/qt5/QtMultimedia/gsiDeclQMediaTimeInterval.cc @@ -210,12 +210,12 @@ static void _call_f_translated_c986 (const qt_gsi::GenericMethod * /*decl*/, voi // bool ::operator==(const QMediaTimeInterval &, const QMediaTimeInterval &) static bool op_QMediaTimeInterval_operator_eq__eq__6112(const QMediaTimeInterval *_self, const QMediaTimeInterval &arg2) { - return ::operator==(*_self, arg2); + return operator==(*_self, arg2); } // bool ::operator!=(const QMediaTimeInterval &, const QMediaTimeInterval &) static bool op_QMediaTimeInterval_operator_excl__eq__6112(const QMediaTimeInterval *_self, const QMediaTimeInterval &arg2) { - return ::operator!=(*_self, arg2); + return operator!=(*_self, arg2); } diff --git a/src/gsiqt/qt5/QtMultimedia/gsiDeclQMediaTimeRange.cc b/src/gsiqt/qt5/QtMultimedia/gsiDeclQMediaTimeRange.cc index 504d3758f4..53558eea64 100644 --- a/src/gsiqt/qt5/QtMultimedia/gsiDeclQMediaTimeRange.cc +++ b/src/gsiqt/qt5/QtMultimedia/gsiDeclQMediaTimeRange.cc @@ -463,22 +463,22 @@ static void _call_f_removeTimeRange_2766 (const qt_gsi::GenericMethod * /*decl*/ // bool ::operator==(const QMediaTimeRange &, const QMediaTimeRange &) static bool op_QMediaTimeRange_operator_eq__eq__5424(const QMediaTimeRange *_self, const QMediaTimeRange &arg2) { - return ::operator==(*_self, arg2); + return operator==(*_self, arg2); } // bool ::operator!=(const QMediaTimeRange &, const QMediaTimeRange &) static bool op_QMediaTimeRange_operator_excl__eq__5424(const QMediaTimeRange *_self, const QMediaTimeRange &arg2) { - return ::operator!=(*_self, arg2); + return operator!=(*_self, arg2); } // QMediaTimeRange ::operator+(const QMediaTimeRange &, const QMediaTimeRange &) static QMediaTimeRange op_QMediaTimeRange_operator_plus__5424(const QMediaTimeRange *_self, const QMediaTimeRange &arg2) { - return ::operator+(*_self, arg2); + return operator+(*_self, arg2); } // QMediaTimeRange ::operator-(const QMediaTimeRange &, const QMediaTimeRange &) static QMediaTimeRange op_QMediaTimeRange_operator_minus__5424(const QMediaTimeRange *_self, const QMediaTimeRange &arg2) { - return ::operator-(*_self, arg2); + return operator-(*_self, arg2); } diff --git a/src/gsiqt/qt5/QtNetwork/gsiDeclQHstsPolicy.cc b/src/gsiqt/qt5/QtNetwork/gsiDeclQHstsPolicy.cc index c782229850..94c85b0376 100644 --- a/src/gsiqt/qt5/QtNetwork/gsiDeclQHstsPolicy.cc +++ b/src/gsiqt/qt5/QtNetwork/gsiDeclQHstsPolicy.cc @@ -266,12 +266,12 @@ static void _call_f_swap_1741 (const qt_gsi::GenericMethod * /*decl*/, void *cls // bool ::operator==(const QHstsPolicy &lhs, const QHstsPolicy &rhs) static bool op_QHstsPolicy_operator_eq__eq__4764(const QHstsPolicy *_self, const QHstsPolicy &rhs) { - return ::operator==(*_self, rhs); + return operator==(*_self, rhs); } // bool ::operator!=(const QHstsPolicy &lhs, const QHstsPolicy &rhs) static bool op_QHstsPolicy_operator_excl__eq__4764(const QHstsPolicy *_self, const QHstsPolicy &rhs) { - return ::operator!=(*_self, rhs); + return operator!=(*_self, rhs); } diff --git a/src/gsiqt/qt5/QtNetwork/gsiDeclQSslDiffieHellmanParameters.cc b/src/gsiqt/qt5/QtNetwork/gsiDeclQSslDiffieHellmanParameters.cc index 1f2b58ad96..cf4a522ef6 100644 --- a/src/gsiqt/qt5/QtNetwork/gsiDeclQSslDiffieHellmanParameters.cc +++ b/src/gsiqt/qt5/QtNetwork/gsiDeclQSslDiffieHellmanParameters.cc @@ -230,12 +230,12 @@ static void _call_f_fromEncoded_3702 (const qt_gsi::GenericStaticMethod * /*decl // bool ::operator==(const QSslDiffieHellmanParameters &lhs, const QSslDiffieHellmanParameters &rhs) static bool op_QSslDiffieHellmanParameters_operator_eq__eq__7956(const QSslDiffieHellmanParameters *_self, const QSslDiffieHellmanParameters &rhs) { - return ::operator==(*_self, rhs); + return operator==(*_self, rhs); } // bool ::operator!=(const QSslDiffieHellmanParameters &lhs, const QSslDiffieHellmanParameters &rhs) static bool op_QSslDiffieHellmanParameters_operator_excl__eq__7956(const QSslDiffieHellmanParameters *_self, const QSslDiffieHellmanParameters &rhs) { - return ::operator!=(*_self, rhs); + return operator!=(*_self, rhs); } diff --git a/src/gsiqt/qt5/QtNetwork/gsiDeclQSslEllipticCurve.cc b/src/gsiqt/qt5/QtNetwork/gsiDeclQSslEllipticCurve.cc index 4fc98a759b..a7b7ad606e 100644 --- a/src/gsiqt/qt5/QtNetwork/gsiDeclQSslEllipticCurve.cc +++ b/src/gsiqt/qt5/QtNetwork/gsiDeclQSslEllipticCurve.cc @@ -150,12 +150,12 @@ static void _call_f_fromShortName_2025 (const qt_gsi::GenericStaticMethod * /*de // bool ::operator==(QSslEllipticCurve lhs, QSslEllipticCurve rhs) static bool op_QSslEllipticCurve_operator_eq__eq__4216(QSslEllipticCurve *_self, QSslEllipticCurve rhs) { - return ::operator==(*_self, rhs); + return operator==(*_self, rhs); } // bool ::operator!=(QSslEllipticCurve lhs, QSslEllipticCurve rhs) static bool op_QSslEllipticCurve_operator_excl__eq__4216(QSslEllipticCurve *_self, QSslEllipticCurve rhs) { - return ::operator!=(*_self, rhs); + return operator!=(*_self, rhs); } diff --git a/src/gsiqt/qt5/QtNetwork/gsiDeclQSslPreSharedKeyAuthenticator.cc b/src/gsiqt/qt5/QtNetwork/gsiDeclQSslPreSharedKeyAuthenticator.cc index 48ca1cab62..6159c40ccc 100644 --- a/src/gsiqt/qt5/QtNetwork/gsiDeclQSslPreSharedKeyAuthenticator.cc +++ b/src/gsiqt/qt5/QtNetwork/gsiDeclQSslPreSharedKeyAuthenticator.cc @@ -225,7 +225,7 @@ static void _call_f_swap_3567 (const qt_gsi::GenericMethod * /*decl*/, void *cls // bool ::operator!=(const QSslPreSharedKeyAuthenticator &lhs, const QSslPreSharedKeyAuthenticator &rhs) static bool op_QSslPreSharedKeyAuthenticator_operator_excl__eq__8416(const QSslPreSharedKeyAuthenticator *_self, const QSslPreSharedKeyAuthenticator &rhs) { - return ::operator!=(*_self, rhs); + return operator!=(*_self, rhs); }