From ca260217f9269b8bdb74e5609a98046cf9240de5 Mon Sep 17 00:00:00 2001 From: Ivailo Monev Date: Sun, 12 May 2019 18:19:43 +0000 Subject: [PATCH] Python bindings via Shiboken Signed-off-by: Ivailo Monev --- .gitignore | 4 +- CMakeLists.txt | 8 +- bindings/CMakeLists.txt | 50 +- bindings/KtCore.i | 163 - bindings/KtCore/katie_qbytearray_wrapper.cpp | 5810 +++++++++++ bindings/KtCore/katie_qbytearray_wrapper.h | 47 + bindings/KtCore/katie_qchar_wrapper.cpp | 3613 +++++++ bindings/KtCore/katie_qchar_wrapper.h | 47 + .../KtCore/katie_qcoreapplication_wrapper.cpp | 1712 ++++ .../KtCore/katie_qcoreapplication_wrapper.h | 85 + bindings/KtCore/katie_qlatin1char_wrapper.cpp | 339 + bindings/KtCore/katie_qlatin1char_wrapper.h | 47 + .../KtCore/katie_qlatin1string_wrapper.cpp | 458 + bindings/KtCore/katie_qlatin1string_wrapper.h | 47 + bindings/KtCore/katie_qobject_wrapper.cpp | 1699 +++ bindings/KtCore/katie_qobject_wrapper.h | 62 + bindings/KtCore/katie_qstring_wrapper.cpp | 9067 +++++++++++++++++ bindings/KtCore/katie_qstring_wrapper.h | 47 + bindings/KtCore/ktcore_module_wrapper.cpp | 5770 +++++++++++ bindings/KtCore/ktcore_python.h | 267 + bindings/KtCore_global.hpp | 8 + bindings/KtGui.i | 68 - bindings/NOTE | 2 - bindings/TODO | 5 - bindings/core/qbytearray.i | 232 - bindings/core/qchar.i | 255 - bindings/core/qcoreapplication.i | 110 - bindings/core/qeasingcurve.i | 60 - bindings/core/qjsonarray.i | 52 - bindings/core/qjsondocument.i | 81 - bindings/core/qjsonobject.i | 41 - bindings/core/qjsonvalue.i | 91 - bindings/core/qlist.i | 104 - bindings/core/qobject.i | 155 - bindings/core/qregexp.i | 66 - bindings/core/qset.i | 68 - bindings/core/qstring.i | 568 -- bindings/core/qstringlist.i | 55 - bindings/core/qvariant.i | 269 - bindings/core/qvector.i | 101 - bindings/gui/qfontinfo.i | 31 - bindings/gui/qfontmetrics.i | 115 - bindings/gui/qwidget.i | 533 - bindings/test.py | 7 +- bindings/tricks.i | 19 - bindings/typesystem_KtCore.xml | 282 + cmake/modules/FindShiboken.cmake | 82 + cmake/modules/KatieBuildMacros.cmake | 38 + 48 files changed, 29570 insertions(+), 3270 deletions(-) delete mode 100644 bindings/KtCore.i create mode 100644 bindings/KtCore/katie_qbytearray_wrapper.cpp create mode 100644 bindings/KtCore/katie_qbytearray_wrapper.h create mode 100644 bindings/KtCore/katie_qchar_wrapper.cpp create mode 100644 bindings/KtCore/katie_qchar_wrapper.h create mode 100644 bindings/KtCore/katie_qcoreapplication_wrapper.cpp create mode 100644 bindings/KtCore/katie_qcoreapplication_wrapper.h create mode 100644 bindings/KtCore/katie_qlatin1char_wrapper.cpp create mode 100644 bindings/KtCore/katie_qlatin1char_wrapper.h create mode 100644 bindings/KtCore/katie_qlatin1string_wrapper.cpp create mode 100644 bindings/KtCore/katie_qlatin1string_wrapper.h create mode 100644 bindings/KtCore/katie_qobject_wrapper.cpp create mode 100644 bindings/KtCore/katie_qobject_wrapper.h create mode 100644 bindings/KtCore/katie_qstring_wrapper.cpp create mode 100644 bindings/KtCore/katie_qstring_wrapper.h create mode 100644 bindings/KtCore/ktcore_module_wrapper.cpp create mode 100644 bindings/KtCore/ktcore_python.h create mode 100644 bindings/KtCore_global.hpp delete mode 100644 bindings/KtGui.i delete mode 100644 bindings/NOTE delete mode 100644 bindings/TODO delete mode 100644 bindings/core/qbytearray.i delete mode 100644 bindings/core/qchar.i delete mode 100644 bindings/core/qcoreapplication.i delete mode 100644 bindings/core/qeasingcurve.i delete mode 100644 bindings/core/qjsonarray.i delete mode 100644 bindings/core/qjsondocument.i delete mode 100644 bindings/core/qjsonobject.i delete mode 100644 bindings/core/qjsonvalue.i delete mode 100644 bindings/core/qlist.i delete mode 100644 bindings/core/qobject.i delete mode 100644 bindings/core/qregexp.i delete mode 100644 bindings/core/qset.i delete mode 100644 bindings/core/qstring.i delete mode 100644 bindings/core/qstringlist.i delete mode 100644 bindings/core/qvariant.i delete mode 100644 bindings/core/qvector.i delete mode 100644 bindings/gui/qfontinfo.i delete mode 100644 bindings/gui/qfontmetrics.i delete mode 100644 bindings/gui/qwidget.i delete mode 100644 bindings/tricks.i create mode 100644 bindings/typesystem_KtCore.xml create mode 100644 cmake/modules/FindShiboken.cmake diff --git a/.gitignore b/.gitignore index 4f117cc87..6013a4d73 100644 --- a/.gitignore +++ b/.gitignore @@ -12,9 +12,11 @@ # Vim temporary files *.swp +# Shiboken log files +bindings/*.log + # Directories to ignore # --------------------- - apidocs build minsize diff --git a/CMakeLists.txt b/CMakeLists.txt index ef252c5c7..d8aedd7ec 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -456,11 +456,11 @@ set_package_properties(MySQL PROPERTIES ) if(KATIE_BINDINGS) - find_package(SWIG) - set_package_properties(SWIG PROPERTIES + find_package(Shiboken) + set_package_properties(Shiboken PROPERTIES PURPOSE "Python bindings" - DESCRIPTION "Simplified Wrapper and Interface Generator" - URL "http://www.swig.org/" + DESCRIPTION "Generates bindings for C++ libraries using CPython source code" + URL "https://wiki.qt.io/PySide" TYPE REQUIRED ) diff --git a/bindings/CMakeLists.txt b/bindings/CMakeLists.txt index 90dc8723d..e67235359 100644 --- a/bindings/CMakeLists.txt +++ b/bindings/CMakeLists.txt @@ -1,4 +1,3 @@ - set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bindings") set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bindings") @@ -33,26 +32,45 @@ include_directories( ${CMAKE_BINARY_DIR}/privateinclude/QtTest ${CMAKE_BINARY_DIR}/include/QtUiTools ${CMAKE_BINARY_DIR}/privateinclude/QtUiTools + ${SHIBOKEN_INCLUDES} ${PYTHON_INCLUDE_DIRS} ) -set_property(SOURCE KtCore.i PROPERTY CPLUSPLUS ON) -swig_add_module(KtCore python KtCore.i) -swig_link_libraries(KtCore KtCore) - -set_property(SOURCE KtGui.i PROPERTY CPLUSPLUS ON) -swig_add_module(KtGui python KtGui.i) -swig_link_libraries(KtGui KtGui) - - -install( - FILES - ${CMAKE_BINARY_DIR}/bindings/KtCore.py - ${CMAKE_BINARY_DIR}/bindings/KtGui.py - DESTINATION ${KATIE_PYTHON_RELATIVE} +remove_definitions( + -DQT_ASCII_CAST_WARNINGS ) +set(PyKtCore_SOURCES + ${CMAKE_CURRENT_SOURCE_DIR}/KtCore/katie_qbytearray_wrapper.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/KtCore/katie_qbytearray_wrapper.h + ${CMAKE_CURRENT_SOURCE_DIR}/KtCore/katie_qchar_wrapper.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/KtCore/katie_qchar_wrapper.h + ${CMAKE_CURRENT_SOURCE_DIR}/KtCore/katie_qcoreapplication_wrapper.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/KtCore/katie_qcoreapplication_wrapper.h + ${CMAKE_CURRENT_SOURCE_DIR}/KtCore/katie_qobject_wrapper.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/KtCore/katie_qobject_wrapper.h + ${CMAKE_CURRENT_SOURCE_DIR}/KtCore/katie_qstring_wrapper.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/KtCore/katie_qstring_wrapper.h + ${CMAKE_CURRENT_SOURCE_DIR}/KtCore/katie_qlatin1char_wrapper.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/KtCore/katie_qlatin1char_wrapper.h + ${CMAKE_CURRENT_SOURCE_DIR}/KtCore/katie_qlatin1string_wrapper.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/KtCore/katie_qlatin1string_wrapper.h + ${CMAKE_CURRENT_SOURCE_DIR}/KtCore/ktcore_module_wrapper.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/KtCore/ktcore_python.h +) + +katana_generate_bindings(KtCore ${PyKtCore_SOURCES}) + +add_library(PyKtCore MODULE ${PyKtCore_SOURCES}) +target_link_libraries(PyKtCore + KtCore + ${SHIBOKEN_LIBRARIES} + ${PYTHON_LIBRARY} +) +set_target_properties(PyKtCore PROPERTIES PREFIX "") +set_target_properties(PyKtCore PROPERTIES OUTPUT_NAME KtCore) + install( - TARGETS _KtCore _KtGui + TARGETS PyKtCore DESTINATION ${KATIE_PYTHON_RELATIVE} ) \ No newline at end of file diff --git a/bindings/KtCore.i b/bindings/KtCore.i deleted file mode 100644 index f615093dd..000000000 --- a/bindings/KtCore.i +++ /dev/null @@ -1,163 +0,0 @@ -%module KtCore - -%include "tricks.i" - -%include "core/qbytearray.i" -%include "core/qchar.i" -%include "core/qcoreapplication.i" -%include "core/qeasingcurve.i" -%include "core/qjsonarray.i" -%include "core/qjsondocument.i" -%include "core/qjsonobject.i" -%include "core/qjsonvalue.i" -%include "core/qlist.i" -%include "core/qobject.i" -%include "core/qregexp.i" -%include "core/qset.i" -%include "core/qstring.i" -%include "core/qstringlist.i" -%include "core/qvariant.i" -%include "core/qvector.i" - -// maybe rename? (e.g. QCharList) -%template(QListInt) QList; -%template(QListQByteArray) QList; -%template(QListQChar) QList; -%template(QListQString) QList; - -%template(QSetInt) QSet; -%template(QSetQByteArray) QSet; -%template(QSetQChar) QSet; -%template(QSetQString) QSet; - -%template(QVectorInt) QVector; -%template(QVectorQByteArray) QVector; -%template(QVectorQChar) QVector; -%template(QVectorQString) QVector; - - -// %template(QVariantList) QList; -// %template(QVariantMap) QMap; -// %template(QVariantHash) QHash; - -%{ -#include "QtCore/QFile" -#include "QtCore/QBitArray" -#include "QtCore/QDataStream" -#include "QtCore/QDate" -#include "QtCore/QDateTime" -#include "QtCore/QLine" -#include "QtCore/QLineF" -#include "QtCore/QLocale" -#include "QtCore/QTime" -#include "QtCore/QPoint" -#include "QtCore/QPointF" -#include "QtCore/QSize" -#include "QtCore/QSizeF" -#include "QtCore/QRect" -#include "QtCore/QRectF" -#include "QtCore/QUrl" - -QT_USE_NAMESPACE -%} - -// temporary implementations for testing purposes -class QFile { -public: - QFile(QString filename); - ~QFile(); - - bool exists() const; -}; - - -// stub implementations for QVariant testing -class QBitArray { -public: - QBitArray(); - ~QBitArray(); -}; - -class QDataStream { -public: - QDataStream(); - ~QDataStream(); -}; - -class QDate { -public: - QDate(); - ~QDate(); -}; - -class QDateTime { -public: - QDateTime(); - ~QDateTime(); -}; - -class QLine { -public: - QLine(); - ~QLine(); -}; - -class QLineF { -public: - QLineF(); - ~QLineF(); -}; - -class QLocale { -public: - QLocale(); - ~QLocale(); -}; - -class QTime { -public: - QTime(); - ~QTime(); -}; - -class QPoint { -public: - QPoint(); - ~QPoint(); -}; - -class QPointF { -public: - QPointF(); - ~QPointF(); -}; - -class QSize { -public: - QSize(); - ~QSize(); -}; - -class QSizeF { -public: - QSizeF(); - ~QSizeF(); -}; - -class QRect { -public: - QRect(); - ~QRect(); -}; - -class QRectF { -public: - QRectF(); - ~QRectF(); -}; - -class QUrl { -public: - QUrl(); - ~QUrl(); -}; diff --git a/bindings/KtCore/katie_qbytearray_wrapper.cpp b/bindings/KtCore/katie_qbytearray_wrapper.cpp new file mode 100644 index 000000000..13b85fc7e --- /dev/null +++ b/bindings/KtCore/katie_qbytearray_wrapper.cpp @@ -0,0 +1,5810 @@ +/**************************************************************************** +** +** Copyright (C) 2015 The Qt Company Ltd. +** Contact: http://www.qt.io/licensing/ +** +** This file is part of the FOO module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of The Qt Company Ltd nor the names of its +** contributors may be used to endorse or promote products derived +** from this software without specific prior written permission. +** +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + +// default includes +#include +#include + +// module include +#include "ktcore_python.h" + +// main header +#include "katie_qbytearray_wrapper.h" + +// inner classes + +// Extra includes +#include +#include + + +#include +#include +using namespace Katie; + + + +template +static const char *typeNameOf(const T &t) +{ + const char *typeName = typeid(t).name(); + auto size = std::strlen(typeName); +#if defined(Q_CC_MSVC) // MSVC: "class QPaintDevice * __ptr64" + if (auto lastStar = strchr(typeName, '*')) { + // MSVC: "class QPaintDevice * __ptr64" + while (*--lastStar == ' ') { + } + size = lastStar - typeName + 1; + } +#else // g++, Clang: "QPaintDevice *" -> "P12QPaintDevice" + if (size > 2 && typeName[0] == 'P' && std::isdigit(typeName[1])) { + ++typeName; + --size; + } +#endif + char *result = new char[size + 1]; + result[size] = '\0'; + memcpy(result, typeName, size); + return result; +} + + +// Target --------------------------------------------------------- + +extern "C" { +static int +Sbk_Katie_QByteArray_Init(PyObject* self, PyObject* args, PyObject* kwds) +{ + SbkObject* sbkSelf = reinterpret_cast(self); + if (Shiboken::Object::isUserType(self) && !Shiboken::ObjectType::canCallConstructor(self->ob_type, Shiboken::SbkType< ::Katie::QByteArray >())) + return -1; + + ::Katie::QByteArray* cptr{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "QByteArray", 0, 2, &(pyArgs[0]), &(pyArgs[1]))) + return -1; + + + // Overloaded function decisor + // 0: QByteArray::QByteArray() + // 1: QByteArray::QByteArray(Katie::QByteArray) + // 2: QByteArray::QByteArray(const char*) + // 3: QByteArray::QByteArray(const char*,int) + // 4: QByteArray::QByteArray(int,Katie::Qt::Initialization) + // 5: QByteArray::QByteArray(int,char) + if (numArgs == 0) { + overloadId = 0; // QByteArray() + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 2 + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_INITIALIZATION_IDX])->converter, (pyArgs[1])))) { + overloadId = 4; // QByteArray(int,Katie::Qt::Initialization) + } else if (numArgs == 2 + && SbkChar_Check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 5; // QByteArray(int,char) + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 2; // QByteArray(const char*) + } else if (numArgs == 2 + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 3; // QByteArray(const char*,int) + } + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArgs[0])))) { + overloadId = 1; // QByteArray(Katie::QByteArray) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArray_Init_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // QByteArray() + { + + if (!PyErr_Occurred()) { + // QByteArray() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cptr = new ::Katie::QByteArray(); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 1: // QByteArray(const Katie::QByteArray & arg__1) + { + if (!Shiboken::Object::isValid(pyArgs[0])) + return -1; + ::Katie::QByteArray* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // QByteArray(Katie::QByteArray) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cptr = new ::Katie::QByteArray(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 2: // QByteArray(const char * arg__1) + { + const char* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // QByteArray(const char*) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cptr = new ::Katie::QByteArray(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 3: // QByteArray(const char * arg__1, int size) + { + const char* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // QByteArray(const char*,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cptr = new ::Katie::QByteArray(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 4: // QByteArray(int size, Katie::Qt::Initialization arg__2) + { + int cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + ::Katie::Qt::Initialization cppArg1{Katie::Qt::Uninitialized}; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // QByteArray(int,Katie::Qt::Initialization) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cptr = new ::Katie::QByteArray(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 5: // QByteArray(int size, char c) + { + int cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + char cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // QByteArray(int,char) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cptr = new ::Katie::QByteArray(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + } + + if (PyErr_Occurred() || !Shiboken::Object::setCppPointer(sbkSelf, Shiboken::SbkType< ::Katie::QByteArray >(), cptr)) { + delete cptr; + return -1; + } + if (!cptr) goto Sbk_Katie_QByteArray_Init_TypeError; + + Shiboken::Object::setValidCpp(sbkSelf, true); + if (Shiboken::BindingManager::instance().hasWrapper(cptr)) { + Shiboken::BindingManager::instance().releaseWrapper(Shiboken::BindingManager::instance().retrieveWrapper(cptr)); + } + Shiboken::BindingManager::instance().registerWrapper(sbkSelf, cptr); + + + return 1; + + Sbk_Katie_QByteArray_Init_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QByteArray"); + return -1; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_append(PyObject* self, PyObject* args) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "append", 1, 2, &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QByteArray::append(char) + // 1: QByteArray::append(Katie::QByteArray) + // 2: QByteArray::append(Katie::QString) + // 3: QByteArray::append(const char*) + // 4: QByteArray::append(const char*,int) + if (Shiboken::String::check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 3; // append(const char*) + } else if (numArgs == 2 + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 4; // append(const char*,int) + } + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArgs[0])))) { + overloadId = 2; // append(Katie::QString) + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArgs[0])))) { + overloadId = 1; // append(Katie::QByteArray) + } else if (numArgs == 1 + && SbkChar_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 0; // append(char) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_append_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // append(char c) + { + char cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // append(char) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->append(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + break; + } + case 1: // append(const Katie::QByteArray & a) + { + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QByteArray* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // append(Katie::QByteArray) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->append(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + break; + } + case 2: // append(const Katie::QString & s) + { + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // append(Katie::QString) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->append(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + break; + } + case 3: // append(const char * s) + { + const char* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // append(const char*) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->append(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + break; + } + case 4: // append(const char * s, int len) + { + const char* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // append(const char*,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->append(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_append_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QByteArray.append"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_at(PyObject* self, PyObject* pyArg) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QByteArray::at(int)const + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // at(int)const + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_at_TypeError; + + // Call function/method + { + int cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // at(int)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + char cppResult = const_cast(cppSelf)->at(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_at_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QByteArray.at"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_begin(PyObject* self) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // begin() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + char * cppResult = cppSelf->begin(); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_capacity(PyObject* self) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // capacity()const + int cppResult = const_cast(cppSelf)->capacity(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_chop(PyObject* self, PyObject* pyArg) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QByteArray::chop(int) + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // chop(int) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_chop_TypeError; + + // Call function/method + { + int cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // chop(int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cppSelf->chop(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; + + Sbk_Katie_QByteArrayFunc_chop_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QByteArray.chop"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_clear(PyObject* self) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + + // Call function/method + { + + if (!PyErr_Occurred()) { + // clear() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cppSelf->clear(); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_constBegin(PyObject* self) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // constBegin()const + const char * cppResult = const_cast(cppSelf)->constBegin(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_constData(PyObject* self) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // constData()const + const char * cppResult = const_cast(cppSelf)->constData(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_constEnd(PyObject* self) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // constEnd()const + const char * cppResult = const_cast(cppSelf)->constEnd(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_contains(PyObject* self, PyObject* pyArg) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QByteArray::contains(char)const + // 1: QByteArray::contains(Katie::QByteArray)const + // 2: QByteArray::contains(const char*)const + if (Shiboken::String::check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 2; // contains(const char*)const + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArg)))) { + overloadId = 1; // contains(Katie::QByteArray)const + } else if (SbkChar_Check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // contains(char)const + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_contains_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // contains(char c) const + { + char cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // contains(char)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + bool cppResult = const_cast(cppSelf)->contains(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 1: // contains(const Katie::QByteArray & a) const + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QByteArray* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // contains(Katie::QByteArray)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + bool cppResult = const_cast(cppSelf)->contains(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 2: // contains(const char * a) const + { + const char* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // contains(const char*)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + bool cppResult = const_cast(cppSelf)->contains(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_contains_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QByteArray.contains"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_count(PyObject* self, PyObject* args) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "count", 0, 1, &(pyArgs[0]))) + return {}; + + + // Overloaded function decisor + // 0: QByteArray::count()const + // 1: QByteArray::count(char)const + // 2: QByteArray::count(Katie::QByteArray)const + // 3: QByteArray::count(const char*)const + if (numArgs == 0) { + overloadId = 0; // count()const + } else if (numArgs == 1 + && Shiboken::String::check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 3; // count(const char*)const + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArgs[0])))) { + overloadId = 2; // count(Katie::QByteArray)const + } else if (numArgs == 1 + && SbkChar_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 1; // count(char)const + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_count_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // count() const + { + + if (!PyErr_Occurred()) { + // count()const + int cppResult = const_cast(cppSelf)->count(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 1: // count(char c) const + { + char cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // count(char)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + int cppResult = const_cast(cppSelf)->count(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 2: // count(const Katie::QByteArray & a) const + { + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QByteArray* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // count(Katie::QByteArray)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + int cppResult = const_cast(cppSelf)->count(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 3: // count(const char * a) const + { + const char* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // count(const char*)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + int cppResult = const_cast(cppSelf)->count(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_count_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QByteArray.count"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_data(PyObject* self) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // data() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + char * cppResult = cppSelf->data(); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_detach(PyObject* self) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + + // Call function/method + { + + if (!PyErr_Occurred()) { + // detach() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cppSelf->detach(); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_end(PyObject* self) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // end() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + char * cppResult = cppSelf->end(); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_endsWith(PyObject* self, PyObject* pyArg) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QByteArray::endsWith(char)const + // 1: QByteArray::endsWith(Katie::QByteArray)const + // 2: QByteArray::endsWith(const char*)const + if (Shiboken::String::check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 2; // endsWith(const char*)const + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArg)))) { + overloadId = 1; // endsWith(Katie::QByteArray)const + } else if (SbkChar_Check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // endsWith(char)const + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_endsWith_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // endsWith(char c) const + { + char cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // endsWith(char)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + bool cppResult = const_cast(cppSelf)->endsWith(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 1: // endsWith(const Katie::QByteArray & a) const + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QByteArray* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // endsWith(Katie::QByteArray)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + bool cppResult = const_cast(cppSelf)->endsWith(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 2: // endsWith(const char * c) const + { + const char* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // endsWith(const char*)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + bool cppResult = const_cast(cppSelf)->endsWith(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_endsWith_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QByteArray.endsWith"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_fill(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.fill(): too many arguments"); + return {}; + } else if (numArgs < 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.fill(): not enough arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OO:fill", &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QByteArray::fill(char,int) + if (SbkChar_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // fill(char,int) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // fill(char,int) + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_fill_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "size"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.fill(): got multiple values for keyword argument 'size'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QByteArrayFunc_fill_TypeError; + } + } + char cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = -1; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // fill(char,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->fill(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_fill_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QByteArray.fill"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_fromBase64(PyObject* self, PyObject* pyArg) +{ + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: static QByteArray::fromBase64(Katie::QByteArray) + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArg)))) { + overloadId = 0; // fromBase64(Katie::QByteArray) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_fromBase64_TypeError; + + // Call function/method + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QByteArray* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // fromBase64(Katie::QByteArray) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray* cppResult = new Katie::QByteArray(::Katie::QByteArray::fromBase64(*cppArg0)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_fromBase64_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QByteArray.fromBase64"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_fromHex(PyObject* self, PyObject* pyArg) +{ + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: static QByteArray::fromHex(Katie::QByteArray) + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArg)))) { + overloadId = 0; // fromHex(Katie::QByteArray) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_fromHex_TypeError; + + // Call function/method + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QByteArray* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // fromHex(Katie::QByteArray) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray* cppResult = new Katie::QByteArray(::Katie::QByteArray::fromHex(*cppArg0)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_fromHex_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QByteArray.fromHex"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_fromPercentEncoding(PyObject* self, PyObject* args, PyObject* kwds) +{ + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.fromPercentEncoding(): too many arguments"); + return {}; + } else if (numArgs < 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.fromPercentEncoding(): not enough arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OO:fromPercentEncoding", &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: static QByteArray::fromPercentEncoding(Katie::QByteArray,char) + if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // fromPercentEncoding(Katie::QByteArray,char) + } else if (SbkChar_Check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // fromPercentEncoding(Katie::QByteArray,char) + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_fromPercentEncoding_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "percent"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.fromPercentEncoding(): got multiple values for keyword argument 'percent'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!SbkChar_Check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QByteArrayFunc_fromPercentEncoding_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QByteArray* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + char cppArg1 = '%'; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // fromPercentEncoding(Katie::QByteArray,char) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray* cppResult = new Katie::QByteArray(::Katie::QByteArray::fromPercentEncoding(*cppArg0, cppArg1)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_fromPercentEncoding_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QByteArray.fromPercentEncoding"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_fromRawData(PyObject* self, PyObject* args) +{ + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "fromRawData", 2, 2, &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: static QByteArray::fromRawData(const char*,int) + if (numArgs == 2 + && Shiboken::String::check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0]))) + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // fromRawData(const char*,int) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_fromRawData_TypeError; + + // Call function/method + { + const char* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // fromRawData(const char*,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray* cppResult = new Katie::QByteArray(::Katie::QByteArray::fromRawData(cppArg0, cppArg1)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_fromRawData_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QByteArray.fromRawData"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_fromStdString(PyObject* self, PyObject* pyArg) +{ + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: static QByteArray::fromStdString(std::string) + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // fromStdString(std::string) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_fromStdString_TypeError; + + // Call function/method + { + ::std::string cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // fromStdString(std::string) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray* cppResult = new Katie::QByteArray(::Katie::QByteArray::fromStdString(cppArg0)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_fromStdString_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QByteArray.fromStdString"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_indexOf(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.indexOf(): too many arguments"); + return {}; + } else if (numArgs < 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.indexOf(): not enough arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OO:indexOf", &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QByteArray::indexOf(char,int)const + // 1: QByteArray::indexOf(Katie::QByteArray,int)const + // 2: QByteArray::indexOf(Katie::QString,int)const + // 3: QByteArray::indexOf(const char*,int)const + if (Shiboken::String::check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 3; // indexOf(const char*,int)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 3; // indexOf(const char*,int)const + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 2; // indexOf(Katie::QString,int)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 2; // indexOf(Katie::QString,int)const + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 1; // indexOf(Katie::QByteArray,int)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 1; // indexOf(Katie::QByteArray,int)const + } + } else if (SbkChar_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // indexOf(char,int)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // indexOf(char,int)const + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_indexOf_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // indexOf(char c, int from) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "from"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.indexOf(): got multiple values for keyword argument 'from'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QByteArrayFunc_indexOf_TypeError; + } + } + char cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 0; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // indexOf(char,int)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + int cppResult = const_cast(cppSelf)->indexOf(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 1: // indexOf(const Katie::QByteArray & a, const int from) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "from"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.indexOf(): got multiple values for keyword argument 'from'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QByteArrayFunc_indexOf_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QByteArray* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 0; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // indexOf(Katie::QByteArray,int)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + int cppResult = const_cast(cppSelf)->indexOf(*cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 2: // indexOf(const Katie::QString & s, const int from) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "from"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.indexOf(): got multiple values for keyword argument 'from'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QByteArrayFunc_indexOf_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 0; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // indexOf(Katie::QString,int)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + int cppResult = const_cast(cppSelf)->indexOf(*cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 3: // indexOf(const char * c, const int from) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "from"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.indexOf(): got multiple values for keyword argument 'from'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QByteArrayFunc_indexOf_TypeError; + } + } + const char* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 0; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // indexOf(const char*,int)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + int cppResult = const_cast(cppSelf)->indexOf(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_indexOf_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QByteArray.indexOf"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_insert(PyObject* self, PyObject* args) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0, 0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "insert", 2, 3, &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2]))) + return {}; + + + // Overloaded function decisor + // 0: QByteArray::insert(int,Katie::QString) + // 1: QByteArray::insert(int,char) + // 2: QByteArray::insert(int,Katie::QByteArray) + // 3: QByteArray::insert(int,const char*) + // 4: QByteArray::insert(int,const char*,int) + if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (Shiboken::String::check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 3; // insert(int,const char*) + } else if (numArgs == 3 + && (pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) { + overloadId = 4; // insert(int,const char*,int) + } + } else if (numArgs == 2 + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArgs[1])))) { + overloadId = 2; // insert(int,Katie::QByteArray) + } else if (numArgs == 2 + && SbkChar_Check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 1; // insert(int,char) + } else if (numArgs == 2 + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArgs[1])))) { + overloadId = 0; // insert(int,Katie::QString) + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_insert_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // insert(const int i, const Katie::QString & s) + { + int cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + if (!Shiboken::Object::isValid(pyArgs[1])) + return {}; + ::Katie::QString* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // insert(int,Katie::QString) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->insert(cppArg0, *cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + break; + } + case 1: // insert(int i, char c) + { + int cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + char cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // insert(int,char) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->insert(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + break; + } + case 2: // insert(int i, const Katie::QByteArray & a) + { + int cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + if (!Shiboken::Object::isValid(pyArgs[1])) + return {}; + ::Katie::QByteArray* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // insert(int,Katie::QByteArray) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->insert(cppArg0, *cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + break; + } + case 3: // insert(int i, const char * s) + { + int cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + const char* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // insert(int,const char*) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->insert(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + break; + } + case 4: // insert(int i, const char * s, int len) + { + int cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + const char* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + int cppArg2; + pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // insert(int,const char*,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->insert(cppArg0, cppArg1, cppArg2); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_insert_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QByteArray.insert"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_isDetached(PyObject* self) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // isDetached()const + bool cppResult = const_cast(cppSelf)->isDetached(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_isEmpty(PyObject* self) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // isEmpty()const + bool cppResult = const_cast(cppSelf)->isEmpty(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_isNull(PyObject* self) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // isNull()const + bool cppResult = const_cast(cppSelf)->isNull(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_isSharedWith(PyObject* self, PyObject* pyArg) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QByteArray::isSharedWith(Katie::QByteArray)const + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArg)))) { + overloadId = 0; // isSharedWith(Katie::QByteArray)const + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_isSharedWith_TypeError; + + // Call function/method + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QByteArray* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // isSharedWith(Katie::QByteArray)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + bool cppResult = const_cast(cppSelf)->isSharedWith(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_isSharedWith_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QByteArray.isSharedWith"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_lastIndexOf(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.lastIndexOf(): too many arguments"); + return {}; + } else if (numArgs < 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.lastIndexOf(): not enough arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OO:lastIndexOf", &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QByteArray::lastIndexOf(char,int)const + // 1: QByteArray::lastIndexOf(Katie::QByteArray,int)const + // 2: QByteArray::lastIndexOf(Katie::QString,int)const + // 3: QByteArray::lastIndexOf(const char*,int)const + if (Shiboken::String::check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 3; // lastIndexOf(const char*,int)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 3; // lastIndexOf(const char*,int)const + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 2; // lastIndexOf(Katie::QString,int)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 2; // lastIndexOf(Katie::QString,int)const + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 1; // lastIndexOf(Katie::QByteArray,int)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 1; // lastIndexOf(Katie::QByteArray,int)const + } + } else if (SbkChar_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // lastIndexOf(char,int)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // lastIndexOf(char,int)const + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_lastIndexOf_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // lastIndexOf(char c, const int from) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "from"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.lastIndexOf(): got multiple values for keyword argument 'from'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QByteArrayFunc_lastIndexOf_TypeError; + } + } + char cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = -1; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // lastIndexOf(char,int)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + int cppResult = const_cast(cppSelf)->lastIndexOf(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 1: // lastIndexOf(const Katie::QByteArray & a, const int from) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "from"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.lastIndexOf(): got multiple values for keyword argument 'from'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QByteArrayFunc_lastIndexOf_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QByteArray* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = -1; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // lastIndexOf(Katie::QByteArray,int)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + int cppResult = const_cast(cppSelf)->lastIndexOf(*cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 2: // lastIndexOf(const Katie::QString & s, const int from) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "from"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.lastIndexOf(): got multiple values for keyword argument 'from'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QByteArrayFunc_lastIndexOf_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = -1; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // lastIndexOf(Katie::QString,int)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + int cppResult = const_cast(cppSelf)->lastIndexOf(*cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 3: // lastIndexOf(const char * c, const int from) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "from"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.lastIndexOf(): got multiple values for keyword argument 'from'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QByteArrayFunc_lastIndexOf_TypeError; + } + } + const char* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = -1; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // lastIndexOf(const char*,int)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + int cppResult = const_cast(cppSelf)->lastIndexOf(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_lastIndexOf_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QByteArray.lastIndexOf"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_left(PyObject* self, PyObject* pyArg) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QByteArray::left(int)const + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // left(int)const + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_left_TypeError; + + // Call function/method + { + int cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // left(int)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray* cppResult = new Katie::QByteArray(const_cast(cppSelf)->left(cppArg0)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_left_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QByteArray.left"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_leftJustified(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 3) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.leftJustified(): too many arguments"); + return {}; + } else if (numArgs < 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.leftJustified(): not enough arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OOO:leftJustified", &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2]))) + return {}; + + + // Overloaded function decisor + // 0: QByteArray::leftJustified(int,char,bool)const + if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // leftJustified(int,char,bool)const + } else if (SbkChar_Check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 0; // leftJustified(int,char,bool)const + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) { + overloadId = 0; // leftJustified(int,char,bool)const + } + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_leftJustified_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "fill"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.leftJustified(): got multiple values for keyword argument 'fill'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!SbkChar_Check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QByteArrayFunc_leftJustified_TypeError; + } + value = PyDict_GetItemString(kwds, "truncate"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.leftJustified(): got multiple values for keyword argument 'truncate'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) + goto Sbk_Katie_QByteArrayFunc_leftJustified_TypeError; + } + } + int cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + char cppArg1 = ' '; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + bool cppArg2 = false; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // leftJustified(int,char,bool)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray* cppResult = new Katie::QByteArray(const_cast(cppSelf)->leftJustified(cppArg0, cppArg1, cppArg2)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_leftJustified_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QByteArray.leftJustified"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_length(PyObject* self) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // length()const + int cppResult = const_cast(cppSelf)->length(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_mid(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.mid(): too many arguments"); + return {}; + } else if (numArgs < 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.mid(): not enough arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OO:mid", &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QByteArray::mid(int,int)const + if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // mid(int,int)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // mid(int,int)const + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_mid_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "len"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.mid(): got multiple values for keyword argument 'len'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QByteArrayFunc_mid_TypeError; + } + } + int cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = -1; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // mid(int,int)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray* cppResult = new Katie::QByteArray(const_cast(cppSelf)->mid(cppArg0, cppArg1)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_mid_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QByteArray.mid"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_number(PyObject* self, PyObject* args, PyObject* kwds) +{ + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 3) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.number(): too many arguments"); + return {}; + } else if (numArgs < 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.number(): not enough arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OOO:number", &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2]))) + return {}; + + + // Overloaded function decisor + // 0: static QByteArray::number(double,char,int) + // 1: static QByteArray::number(int,int) + // 2: static QByteArray::number(long long,int) + // 3: static QByteArray::number(uint,int) + // 4: static QByteArray::number(unsigned long long,int) + if (PyLong_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 4; // number(unsigned long long,int) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 4; // number(unsigned long long,int) + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 3; // number(uint,int) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 3; // number(uint,int) + } + } else if (PyLong_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 2; // number(long long,int) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 2; // number(long long,int) + } + } else if (PyFloat_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // number(double,char,int) + } else if (SbkChar_Check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 0; // number(double,char,int) + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) { + overloadId = 0; // number(double,char,int) + } + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 1; // number(int,int) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 1; // number(int,int) + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_number_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // number(double arg__1, char f, int prec) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "f"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.number(): got multiple values for keyword argument 'f'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!SbkChar_Check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QByteArrayFunc_number_TypeError; + } + value = PyDict_GetItemString(kwds, "prec"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.number(): got multiple values for keyword argument 'prec'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) + goto Sbk_Katie_QByteArrayFunc_number_TypeError; + } + } + double cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + char cppArg1 = 'g'; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + int cppArg2 = 6; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // number(double,char,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray* cppResult = new Katie::QByteArray(::Katie::QByteArray::number(cppArg0, cppArg1, cppArg2)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), cppResult, true, true); + } + break; + } + case 1: // number(int arg__1, int base) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.number(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QByteArrayFunc_number_TypeError; + } + } + int cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // number(int,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray* cppResult = new Katie::QByteArray(::Katie::QByteArray::number(cppArg0, cppArg1)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), cppResult, true, true); + } + break; + } + case 2: // number(long long arg__1, int base) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.number(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QByteArrayFunc_number_TypeError; + } + } + long long cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // number(long long,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray* cppResult = new Katie::QByteArray(::Katie::QByteArray::number(cppArg0, cppArg1)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), cppResult, true, true); + } + break; + } + case 3: // number(uint arg__1, int base) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.number(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QByteArrayFunc_number_TypeError; + } + } + uint cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // number(uint,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray* cppResult = new Katie::QByteArray(::Katie::QByteArray::number(cppArg0, cppArg1)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), cppResult, true, true); + } + break; + } + case 4: // number(unsigned long long arg__1, int base) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.number(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QByteArrayFunc_number_TypeError; + } + } + unsigned long long cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // number(unsigned long long,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray* cppResult = new Katie::QByteArray(::Katie::QByteArray::number(cppArg0, cppArg1)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), cppResult, true, true); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_number_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QByteArray.number"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_prepend(PyObject* self, PyObject* args) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "prepend", 1, 2, &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QByteArray::prepend(char) + // 1: QByteArray::prepend(Katie::QByteArray) + // 2: QByteArray::prepend(const char*) + // 3: QByteArray::prepend(const char*,int) + if (Shiboken::String::check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 2; // prepend(const char*) + } else if (numArgs == 2 + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 3; // prepend(const char*,int) + } + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArgs[0])))) { + overloadId = 1; // prepend(Katie::QByteArray) + } else if (numArgs == 1 + && SbkChar_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 0; // prepend(char) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_prepend_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // prepend(char c) + { + char cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // prepend(char) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->prepend(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + break; + } + case 1: // prepend(const Katie::QByteArray & a) + { + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QByteArray* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // prepend(Katie::QByteArray) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->prepend(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + break; + } + case 2: // prepend(const char * s) + { + const char* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // prepend(const char*) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->prepend(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + break; + } + case 3: // prepend(const char * s, int len) + { + const char* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // prepend(const char*,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->prepend(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_prepend_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QByteArray.prepend"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_push_back(PyObject* self, PyObject* pyArg) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QByteArray::push_back(char) + // 1: QByteArray::push_back(Katie::QByteArray) + // 2: QByteArray::push_back(const char*) + if (Shiboken::String::check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 2; // push_back(const char*) + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArg)))) { + overloadId = 1; // push_back(Katie::QByteArray) + } else if (SbkChar_Check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // push_back(char) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_push_back_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // push_back(char c) + { + char cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // push_back(char) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cppSelf->push_back(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 1: // push_back(const Katie::QByteArray & a) + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QByteArray* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // push_back(Katie::QByteArray) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cppSelf->push_back(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 2: // push_back(const char * c) + { + const char* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // push_back(const char*) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cppSelf->push_back(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; + + Sbk_Katie_QByteArrayFunc_push_back_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QByteArray.push_back"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_push_front(PyObject* self, PyObject* pyArg) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QByteArray::push_front(char) + // 1: QByteArray::push_front(Katie::QByteArray) + // 2: QByteArray::push_front(const char*) + if (Shiboken::String::check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 2; // push_front(const char*) + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArg)))) { + overloadId = 1; // push_front(Katie::QByteArray) + } else if (SbkChar_Check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // push_front(char) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_push_front_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // push_front(char c) + { + char cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // push_front(char) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cppSelf->push_front(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 1: // push_front(const Katie::QByteArray & a) + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QByteArray* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // push_front(Katie::QByteArray) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cppSelf->push_front(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 2: // push_front(const char * c) + { + const char* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // push_front(const char*) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cppSelf->push_front(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; + + Sbk_Katie_QByteArrayFunc_push_front_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QByteArray.push_front"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_remove(PyObject* self, PyObject* args) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "remove", 2, 2, &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QByteArray::remove(int,int) + if (numArgs == 2 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0]))) + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // remove(int,int) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_remove_TypeError; + + // Call function/method + { + int cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // remove(int,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->remove(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_remove_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QByteArray.remove"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_repeated(PyObject* self, PyObject* pyArg) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QByteArray::repeated(int)const + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // repeated(int)const + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_repeated_TypeError; + + // Call function/method + { + int cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // repeated(int)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray* cppResult = new Katie::QByteArray(const_cast(cppSelf)->repeated(cppArg0)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_repeated_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QByteArray.repeated"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_replace(PyObject* self, PyObject* args) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr, nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0, 0, 0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "replace", 2, 4, &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2]), &(pyArgs[3]))) + return {}; + + + // Overloaded function decisor + // 0: QByteArray::replace(char,char) + // 1: QByteArray::replace(char,Katie::QByteArray) + // 2: QByteArray::replace(char,const char*) + // 3: QByteArray::replace(char,Katie::QString) + // 4: QByteArray::replace(Katie::QByteArray,Katie::QByteArray) + // 5: QByteArray::replace(Katie::QByteArray,const char*) + // 6: QByteArray::replace(Katie::QString,Katie::QByteArray) + // 7: QByteArray::replace(Katie::QString,const char*) + // 8: QByteArray::replace(const char*,Katie::QByteArray) + // 9: QByteArray::replace(const char*,const char*) + // 10: QByteArray::replace(const char*,int,const char*,int) + // 11: QByteArray::replace(int,int,Katie::QByteArray) + // 12: QByteArray::replace(int,int,const char*) + // 13: QByteArray::replace(int,int,const char*,int) + if (numArgs >= 2 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0]))) + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + if (Shiboken::String::check(pyArgs[2]) && (pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) { + if (numArgs == 3) { + overloadId = 12; // replace(int,int,const char*) + } else if (numArgs == 4 + && (pythonToCpp[3] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[3])))) { + overloadId = 13; // replace(int,int,const char*,int) + } + } else if (numArgs == 3 + && (pythonToCpp[2] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArgs[2])))) { + overloadId = 11; // replace(int,int,Katie::QByteArray) + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 4 + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1]))) + && Shiboken::String::check(pyArgs[2]) && (pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2]))) + && (pythonToCpp[3] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[3])))) { + overloadId = 10; // replace(const char*,int,const char*,int) + } else if (numArgs == 2 + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 9; // replace(const char*,const char*) + } else if (numArgs == 2 + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArgs[1])))) { + overloadId = 8; // replace(const char*,Katie::QByteArray) + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArgs[0])))) { + if (numArgs == 2 + && Shiboken::String::check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 7; // replace(Katie::QString,const char*) + } else if (numArgs == 2 + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArgs[1])))) { + overloadId = 6; // replace(Katie::QString,Katie::QByteArray) + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArgs[0])))) { + if (numArgs == 2 + && Shiboken::String::check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 5; // replace(Katie::QByteArray,const char*) + } else if (numArgs == 2 + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArgs[1])))) { + overloadId = 4; // replace(Katie::QByteArray,Katie::QByteArray) + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 2 + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArgs[1])))) { + overloadId = 3; // replace(char,Katie::QString) + } else if (numArgs == 2 + && Shiboken::String::check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 2; // replace(char,const char*) + } else if (numArgs == 2 + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArgs[1])))) { + overloadId = 1; // replace(char,Katie::QByteArray) + } else if (numArgs == 2 + && SbkChar_Check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // replace(char,char) + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_replace_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // replace(char before, char after) + { + char cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + char cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // replace(char,char) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->replace(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + break; + } + case 1: // replace(char before, const Katie::QByteArray & after) + { + char cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + if (!Shiboken::Object::isValid(pyArgs[1])) + return {}; + ::Katie::QByteArray* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // replace(char,Katie::QByteArray) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->replace(cppArg0, *cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + break; + } + case 2: // replace(char before, const char * after) + { + char cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + const char* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // replace(char,const char*) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->replace(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + break; + } + case 3: // replace(char c, const Katie::QString & after) + { + char cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + if (!Shiboken::Object::isValid(pyArgs[1])) + return {}; + ::Katie::QString* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // replace(char,Katie::QString) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->replace(cppArg0, *cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + break; + } + case 4: // replace(const Katie::QByteArray & before, const Katie::QByteArray & after) + { + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QByteArray* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + if (!Shiboken::Object::isValid(pyArgs[1])) + return {}; + ::Katie::QByteArray* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // replace(Katie::QByteArray,Katie::QByteArray) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->replace(*cppArg0, *cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + break; + } + case 5: // replace(const Katie::QByteArray & before, const char * after) + { + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QByteArray* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + const char* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // replace(Katie::QByteArray,const char*) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->replace(*cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + break; + } + case 6: // replace(const Katie::QString & before, const Katie::QByteArray & after) + { + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + if (!Shiboken::Object::isValid(pyArgs[1])) + return {}; + ::Katie::QByteArray* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // replace(Katie::QString,Katie::QByteArray) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->replace(*cppArg0, *cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + break; + } + case 7: // replace(const Katie::QString & before, const char * after) + { + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + const char* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // replace(Katie::QString,const char*) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->replace(*cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + break; + } + case 8: // replace(const char * before, const Katie::QByteArray & after) + { + const char* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + if (!Shiboken::Object::isValid(pyArgs[1])) + return {}; + ::Katie::QByteArray* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // replace(const char*,Katie::QByteArray) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->replace(cppArg0, *cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + break; + } + case 9: // replace(const char * before, const char * after) + { + const char* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + const char* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // replace(const char*,const char*) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->replace(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + break; + } + case 10: // replace(const char * before, int bsize, const char * after, int asize) + { + const char* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + const char* cppArg2; + pythonToCpp[2](pyArgs[2], &cppArg2); + int cppArg3; + pythonToCpp[3](pyArgs[3], &cppArg3); + + if (!PyErr_Occurred()) { + // replace(const char*,int,const char*,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->replace(cppArg0, cppArg1, cppArg2, cppArg3); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + break; + } + case 11: // replace(int index, int len, const Katie::QByteArray & s) + { + int cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + if (!Shiboken::Object::isValid(pyArgs[2])) + return {}; + ::Katie::QByteArray* cppArg2; + pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // replace(int,int,Katie::QByteArray) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->replace(cppArg0, cppArg1, *cppArg2); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + break; + } + case 12: // replace(int index, int len, const char * s) + { + int cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + const char* cppArg2; + pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // replace(int,int,const char*) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->replace(cppArg0, cppArg1, cppArg2); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + break; + } + case 13: // replace(int index, int len, const char * s, int alen) + { + int cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + const char* cppArg2; + pythonToCpp[2](pyArgs[2], &cppArg2); + int cppArg3; + pythonToCpp[3](pyArgs[3], &cppArg3); + + if (!PyErr_Occurred()) { + // replace(int,int,const char*,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->replace(cppArg0, cppArg1, cppArg2, cppArg3); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_replace_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QByteArray.replace"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_reserve(PyObject* self, PyObject* pyArg) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QByteArray::reserve(int) + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // reserve(int) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_reserve_TypeError; + + // Call function/method + { + int cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // reserve(int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cppSelf->reserve(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; + + Sbk_Katie_QByteArrayFunc_reserve_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QByteArray.reserve"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_resize(PyObject* self, PyObject* pyArg) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QByteArray::resize(int) + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // resize(int) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_resize_TypeError; + + // Call function/method + { + int cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // resize(int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cppSelf->resize(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; + + Sbk_Katie_QByteArrayFunc_resize_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QByteArray.resize"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_right(PyObject* self, PyObject* pyArg) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QByteArray::right(int)const + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // right(int)const + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_right_TypeError; + + // Call function/method + { + int cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // right(int)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray* cppResult = new Katie::QByteArray(const_cast(cppSelf)->right(cppArg0)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_right_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QByteArray.right"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_rightJustified(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 3) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.rightJustified(): too many arguments"); + return {}; + } else if (numArgs < 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.rightJustified(): not enough arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OOO:rightJustified", &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2]))) + return {}; + + + // Overloaded function decisor + // 0: QByteArray::rightJustified(int,char,bool)const + if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // rightJustified(int,char,bool)const + } else if (SbkChar_Check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 0; // rightJustified(int,char,bool)const + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) { + overloadId = 0; // rightJustified(int,char,bool)const + } + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_rightJustified_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "fill"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.rightJustified(): got multiple values for keyword argument 'fill'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!SbkChar_Check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QByteArrayFunc_rightJustified_TypeError; + } + value = PyDict_GetItemString(kwds, "truncate"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.rightJustified(): got multiple values for keyword argument 'truncate'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) + goto Sbk_Katie_QByteArrayFunc_rightJustified_TypeError; + } + } + int cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + char cppArg1 = ' '; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + bool cppArg2 = false; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // rightJustified(int,char,bool)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray* cppResult = new Katie::QByteArray(const_cast(cppSelf)->rightJustified(cppArg0, cppArg1, cppArg2)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_rightJustified_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QByteArray.rightJustified"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_setNum(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 3) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.setNum(): too many arguments"); + return {}; + } else if (numArgs < 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.setNum(): not enough arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OOO:setNum", &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2]))) + return {}; + + + // Overloaded function decisor + // 0: QByteArray::setNum(double,char,int) + // 1: QByteArray::setNum(float,char,int) + // 2: QByteArray::setNum(int,int) + // 3: QByteArray::setNum(long long,int) + // 4: QByteArray::setNum(short,int) + // 5: QByteArray::setNum(uint,int) + // 6: QByteArray::setNum(unsigned long long,int) + // 7: QByteArray::setNum(ushort,int) + if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 7; // setNum(ushort,int) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 7; // setNum(ushort,int) + } + } else if (PyLong_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 6; // setNum(unsigned long long,int) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 6; // setNum(unsigned long long,int) + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 5; // setNum(uint,int) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 5; // setNum(uint,int) + } + } else if (PyLong_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 3; // setNum(long long,int) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 3; // setNum(long long,int) + } + } else if (PyFloat_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 1; // setNum(float,char,int) + } else if (SbkChar_Check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 1; // setNum(float,char,int) + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) { + overloadId = 1; // setNum(float,char,int) + } + } + } else if (PyFloat_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // setNum(double,char,int) + } else if (SbkChar_Check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 0; // setNum(double,char,int) + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) { + overloadId = 0; // setNum(double,char,int) + } + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 4; // setNum(short,int) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 4; // setNum(short,int) + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 2; // setNum(int,int) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 2; // setNum(int,int) + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_setNum_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // setNum(double arg__1, char f, int prec) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "f"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.setNum(): got multiple values for keyword argument 'f'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!SbkChar_Check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QByteArrayFunc_setNum_TypeError; + } + value = PyDict_GetItemString(kwds, "prec"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.setNum(): got multiple values for keyword argument 'prec'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) + goto Sbk_Katie_QByteArrayFunc_setNum_TypeError; + } + } + double cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + char cppArg1 = 'g'; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + int cppArg2 = 6; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // setNum(double,char,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->setNum(cppArg0, cppArg1, cppArg2); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + break; + } + case 1: // setNum(float arg__1, char f, int prec) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "f"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.setNum(): got multiple values for keyword argument 'f'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!SbkChar_Check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QByteArrayFunc_setNum_TypeError; + } + value = PyDict_GetItemString(kwds, "prec"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.setNum(): got multiple values for keyword argument 'prec'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) + goto Sbk_Katie_QByteArrayFunc_setNum_TypeError; + } + } + float cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + char cppArg1 = 'g'; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + int cppArg2 = 6; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // setNum(float,char,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->setNum(cppArg0, cppArg1, cppArg2); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + break; + } + case 2: // setNum(int arg__1, int base) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.setNum(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QByteArrayFunc_setNum_TypeError; + } + } + int cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // setNum(int,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->setNum(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + break; + } + case 3: // setNum(long long arg__1, int base) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.setNum(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QByteArrayFunc_setNum_TypeError; + } + } + long long cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // setNum(long long,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->setNum(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + break; + } + case 4: // setNum(short arg__1, int base) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.setNum(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QByteArrayFunc_setNum_TypeError; + } + } + short cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // setNum(short,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->setNum(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + break; + } + case 5: // setNum(uint arg__1, int base) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.setNum(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QByteArrayFunc_setNum_TypeError; + } + } + uint cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // setNum(uint,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->setNum(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + break; + } + case 6: // setNum(unsigned long long arg__1, int base) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.setNum(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QByteArrayFunc_setNum_TypeError; + } + } + unsigned long long cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // setNum(unsigned long long,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->setNum(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + break; + } + case 7: // setNum(ushort arg__1, int base) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.setNum(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QByteArrayFunc_setNum_TypeError; + } + } + ::ushort cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // setNum(ushort,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->setNum(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_setNum_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QByteArray.setNum"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_setRawData(PyObject* self, PyObject* args) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "setRawData", 2, 2, &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QByteArray::setRawData(const char*,uint) + if (numArgs == 2 + && Shiboken::String::check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0]))) + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // setRawData(const char*,uint) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_setRawData_TypeError; + + // Call function/method + { + const char* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + uint cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // setRawData(const char*,uint) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray & cppResult = cppSelf->setRawData(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_setRawData_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QByteArray.setRawData"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_simplified(PyObject* self) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // simplified()const + Katie::QByteArray* cppResult = new Katie::QByteArray(const_cast(cppSelf)->simplified()); + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_size(PyObject* self) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // size()const + int cppResult = const_cast(cppSelf)->size(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_squeeze(PyObject* self) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + + // Call function/method + { + + if (!PyErr_Occurred()) { + // squeeze() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cppSelf->squeeze(); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_startsWith(PyObject* self, PyObject* pyArg) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QByteArray::startsWith(char)const + // 1: QByteArray::startsWith(Katie::QByteArray)const + // 2: QByteArray::startsWith(const char*)const + if (Shiboken::String::check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 2; // startsWith(const char*)const + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArg)))) { + overloadId = 1; // startsWith(Katie::QByteArray)const + } else if (SbkChar_Check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // startsWith(char)const + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_startsWith_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // startsWith(char c) const + { + char cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // startsWith(char)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + bool cppResult = const_cast(cppSelf)->startsWith(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 1: // startsWith(const Katie::QByteArray & a) const + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QByteArray* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // startsWith(Katie::QByteArray)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + bool cppResult = const_cast(cppSelf)->startsWith(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 2: // startsWith(const char * c) const + { + const char* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // startsWith(const char*)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + bool cppResult = const_cast(cppSelf)->startsWith(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_startsWith_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QByteArray.startsWith"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_swap(PyObject* self, PyObject* pyArg) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QByteArray::swap(Katie::QByteArray&) + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArg)))) { + overloadId = 0; // swap(Katie::QByteArray&) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_swap_TypeError; + + // Call function/method + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QByteArray* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // swap(Katie::QByteArray&) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cppSelf->swap(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; + + Sbk_Katie_QByteArrayFunc_swap_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QByteArray.swap"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_toBase64(PyObject* self) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // toBase64()const + Katie::QByteArray* cppResult = new Katie::QByteArray(const_cast(cppSelf)->toBase64()); + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_toDouble(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.toDouble(): too many arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|O:toDouble", &(pyArgs[0]))) + return {}; + + + // Overloaded function decisor + // 0: QByteArray::toDouble(bool*)const + if (numArgs == 0) { + overloadId = 0; // toDouble(bool*)const + } else if (PyBool_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 0; // toDouble(bool*)const + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_toDouble_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "ok"); + if (value && pyArgs[0]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.toDouble(): got multiple values for keyword argument 'ok'."); + return {}; + } else if (value) { + pyArgs[0] = value; + if (!(pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) + goto Sbk_Katie_QByteArrayFunc_toDouble_TypeError; + } + } + bool* cppArg0 = Q_NULLPTR; + if (pythonToCpp[0]) pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // toDouble(bool*)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + double cppResult = const_cast(cppSelf)->toDouble(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_toDouble_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QByteArray.toDouble"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_toFloat(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.toFloat(): too many arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|O:toFloat", &(pyArgs[0]))) + return {}; + + + // Overloaded function decisor + // 0: QByteArray::toFloat(bool*)const + if (numArgs == 0) { + overloadId = 0; // toFloat(bool*)const + } else if (PyBool_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 0; // toFloat(bool*)const + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_toFloat_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "ok"); + if (value && pyArgs[0]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.toFloat(): got multiple values for keyword argument 'ok'."); + return {}; + } else if (value) { + pyArgs[0] = value; + if (!(pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) + goto Sbk_Katie_QByteArrayFunc_toFloat_TypeError; + } + } + bool* cppArg0 = Q_NULLPTR; + if (pythonToCpp[0]) pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // toFloat(bool*)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + float cppResult = const_cast(cppSelf)->toFloat(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_toFloat_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QByteArray.toFloat"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_toHex(PyObject* self) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // toHex()const + Katie::QByteArray* cppResult = new Katie::QByteArray(const_cast(cppSelf)->toHex()); + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_toInt(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.toInt(): too many arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OO:toInt", &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QByteArray::toInt(bool*,int)const + if (numArgs == 0) { + overloadId = 0; // toInt(bool*,int)const + } else if (PyBool_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // toInt(bool*,int)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // toInt(bool*,int)const + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_toInt_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "ok"); + if (value && pyArgs[0]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.toInt(): got multiple values for keyword argument 'ok'."); + return {}; + } else if (value) { + pyArgs[0] = value; + if (!(pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) + goto Sbk_Katie_QByteArrayFunc_toInt_TypeError; + } + value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.toInt(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QByteArrayFunc_toInt_TypeError; + } + } + bool* cppArg0 = Q_NULLPTR; + if (pythonToCpp[0]) pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // toInt(bool*,int)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + int cppResult = const_cast(cppSelf)->toInt(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_toInt_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QByteArray.toInt"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_toLong(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.toLong(): too many arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OO:toLong", &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QByteArray::toLong(bool*,int)const + if (numArgs == 0) { + overloadId = 0; // toLong(bool*,int)const + } else if (PyBool_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // toLong(bool*,int)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // toLong(bool*,int)const + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_toLong_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "ok"); + if (value && pyArgs[0]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.toLong(): got multiple values for keyword argument 'ok'."); + return {}; + } else if (value) { + pyArgs[0] = value; + if (!(pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) + goto Sbk_Katie_QByteArrayFunc_toLong_TypeError; + } + value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.toLong(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QByteArrayFunc_toLong_TypeError; + } + } + bool* cppArg0 = Q_NULLPTR; + if (pythonToCpp[0]) pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // toLong(bool*,int)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + long cppResult = const_cast(cppSelf)->toLong(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_toLong_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QByteArray.toLong"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_toLongLong(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.toLongLong(): too many arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OO:toLongLong", &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QByteArray::toLongLong(bool*,int)const + if (numArgs == 0) { + overloadId = 0; // toLongLong(bool*,int)const + } else if (PyBool_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // toLongLong(bool*,int)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // toLongLong(bool*,int)const + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_toLongLong_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "ok"); + if (value && pyArgs[0]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.toLongLong(): got multiple values for keyword argument 'ok'."); + return {}; + } else if (value) { + pyArgs[0] = value; + if (!(pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) + goto Sbk_Katie_QByteArrayFunc_toLongLong_TypeError; + } + value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.toLongLong(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QByteArrayFunc_toLongLong_TypeError; + } + } + bool* cppArg0 = Q_NULLPTR; + if (pythonToCpp[0]) pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // toLongLong(bool*,int)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + long long cppResult = const_cast(cppSelf)->toLongLong(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_toLongLong_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QByteArray.toLongLong"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_toLower(PyObject* self) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // toLower()const + Katie::QByteArray* cppResult = new Katie::QByteArray(const_cast(cppSelf)->toLower()); + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_toPercentEncoding(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 3) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.toPercentEncoding(): too many arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OOO:toPercentEncoding", &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2]))) + return {}; + + + // Overloaded function decisor + // 0: QByteArray::toPercentEncoding(Katie::QByteArray,Katie::QByteArray,char)const + if (numArgs == 0) { + overloadId = 0; // toPercentEncoding(Katie::QByteArray,Katie::QByteArray,char)const + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // toPercentEncoding(Katie::QByteArray,Katie::QByteArray,char)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 0; // toPercentEncoding(Katie::QByteArray,Katie::QByteArray,char)const + } else if (SbkChar_Check(pyArgs[2]) && (pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) { + overloadId = 0; // toPercentEncoding(Katie::QByteArray,Katie::QByteArray,char)const + } + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_toPercentEncoding_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "exclude"); + if (value && pyArgs[0]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.toPercentEncoding(): got multiple values for keyword argument 'exclude'."); + return {}; + } else if (value) { + pyArgs[0] = value; + if (!(pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArgs[0])))) + goto Sbk_Katie_QByteArrayFunc_toPercentEncoding_TypeError; + } + value = PyDict_GetItemString(kwds, "include"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.toPercentEncoding(): got multiple values for keyword argument 'include'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArgs[1])))) + goto Sbk_Katie_QByteArrayFunc_toPercentEncoding_TypeError; + } + value = PyDict_GetItemString(kwds, "percent"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.toPercentEncoding(): got multiple values for keyword argument 'percent'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!SbkChar_Check(pyArgs[2]) && (pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) + goto Sbk_Katie_QByteArrayFunc_toPercentEncoding_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QByteArray* cppArg0 = Katie::QByteArray(); + if (pythonToCpp[0]) pythonToCpp[0](pyArgs[0], &cppArg0); + if (!Shiboken::Object::isValid(pyArgs[1])) + return {}; + ::Katie::QByteArray* cppArg1 = Katie::QByteArray(); + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + char cppArg2 = '%'; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // toPercentEncoding(Katie::QByteArray,Katie::QByteArray,char)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QByteArray* cppResult = new Katie::QByteArray(const_cast(cppSelf)->toPercentEncoding(*cppArg0, *cppArg1, cppArg2)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_toPercentEncoding_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QByteArray.toPercentEncoding"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_toShort(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.toShort(): too many arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OO:toShort", &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QByteArray::toShort(bool*,int)const + if (numArgs == 0) { + overloadId = 0; // toShort(bool*,int)const + } else if (PyBool_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // toShort(bool*,int)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // toShort(bool*,int)const + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_toShort_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "ok"); + if (value && pyArgs[0]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.toShort(): got multiple values for keyword argument 'ok'."); + return {}; + } else if (value) { + pyArgs[0] = value; + if (!(pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) + goto Sbk_Katie_QByteArrayFunc_toShort_TypeError; + } + value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.toShort(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QByteArrayFunc_toShort_TypeError; + } + } + bool* cppArg0 = Q_NULLPTR; + if (pythonToCpp[0]) pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // toShort(bool*,int)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + short cppResult = const_cast(cppSelf)->toShort(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_toShort_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QByteArray.toShort"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_toStdString(PyObject* self) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // toStdString()const + std::string cppResult = const_cast(cppSelf)->toStdString(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_toUInt(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.toUInt(): too many arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OO:toUInt", &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QByteArray::toUInt(bool*,int)const + if (numArgs == 0) { + overloadId = 0; // toUInt(bool*,int)const + } else if (PyBool_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // toUInt(bool*,int)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // toUInt(bool*,int)const + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_toUInt_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "ok"); + if (value && pyArgs[0]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.toUInt(): got multiple values for keyword argument 'ok'."); + return {}; + } else if (value) { + pyArgs[0] = value; + if (!(pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) + goto Sbk_Katie_QByteArrayFunc_toUInt_TypeError; + } + value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.toUInt(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QByteArrayFunc_toUInt_TypeError; + } + } + bool* cppArg0 = Q_NULLPTR; + if (pythonToCpp[0]) pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // toUInt(bool*,int)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + uint cppResult = const_cast(cppSelf)->toUInt(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_toUInt_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QByteArray.toUInt"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_toULong(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.toULong(): too many arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OO:toULong", &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QByteArray::toULong(bool*,int)const + if (numArgs == 0) { + overloadId = 0; // toULong(bool*,int)const + } else if (PyBool_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // toULong(bool*,int)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // toULong(bool*,int)const + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_toULong_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "ok"); + if (value && pyArgs[0]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.toULong(): got multiple values for keyword argument 'ok'."); + return {}; + } else if (value) { + pyArgs[0] = value; + if (!(pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) + goto Sbk_Katie_QByteArrayFunc_toULong_TypeError; + } + value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.toULong(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QByteArrayFunc_toULong_TypeError; + } + } + bool* cppArg0 = Q_NULLPTR; + if (pythonToCpp[0]) pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // toULong(bool*,int)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + ulong cppResult = const_cast(cppSelf)->toULong(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_toULong_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QByteArray.toULong"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_toULongLong(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.toULongLong(): too many arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OO:toULongLong", &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QByteArray::toULongLong(bool*,int)const + if (numArgs == 0) { + overloadId = 0; // toULongLong(bool*,int)const + } else if (PyBool_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // toULongLong(bool*,int)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // toULongLong(bool*,int)const + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_toULongLong_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "ok"); + if (value && pyArgs[0]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.toULongLong(): got multiple values for keyword argument 'ok'."); + return {}; + } else if (value) { + pyArgs[0] = value; + if (!(pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) + goto Sbk_Katie_QByteArrayFunc_toULongLong_TypeError; + } + value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.toULongLong(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QByteArrayFunc_toULongLong_TypeError; + } + } + bool* cppArg0 = Q_NULLPTR; + if (pythonToCpp[0]) pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // toULongLong(bool*,int)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + unsigned long long cppResult = const_cast(cppSelf)->toULongLong(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_toULongLong_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QByteArray.toULongLong"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_toUShort(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.toUShort(): too many arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OO:toUShort", &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QByteArray::toUShort(bool*,int)const + if (numArgs == 0) { + overloadId = 0; // toUShort(bool*,int)const + } else if (PyBool_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // toUShort(bool*,int)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // toUShort(bool*,int)const + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_toUShort_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "ok"); + if (value && pyArgs[0]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.toUShort(): got multiple values for keyword argument 'ok'."); + return {}; + } else if (value) { + pyArgs[0] = value; + if (!(pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) + goto Sbk_Katie_QByteArrayFunc_toUShort_TypeError; + } + value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QByteArray.toUShort(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QByteArrayFunc_toUShort_TypeError; + } + } + bool* cppArg0 = Q_NULLPTR; + if (pythonToCpp[0]) pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // toUShort(bool*,int)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + ushort cppResult = const_cast(cppSelf)->toUShort(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QByteArrayFunc_toUShort_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QByteArray.toUShort"); + return {}; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_toUpper(PyObject* self) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // toUpper()const + Katie::QByteArray* cppResult = new Katie::QByteArray(const_cast(cppSelf)->toUpper()); + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_trimmed(PyObject* self) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // trimmed()const + Katie::QByteArray* cppResult = new Katie::QByteArray(const_cast(cppSelf)->trimmed()); + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QByteArrayFunc_truncate(PyObject* self, PyObject* pyArg) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QByteArray::truncate(int) + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // truncate(int) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc_truncate_TypeError; + + // Call function/method + { + int cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // truncate(int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cppSelf->truncate(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; + + Sbk_Katie_QByteArrayFunc_truncate_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QByteArray.truncate"); + return {}; +} + +static PyMethodDef Sbk_Katie_QByteArray_methods[] = { + {"append", reinterpret_cast(Sbk_Katie_QByteArrayFunc_append), METH_VARARGS}, + {"at", reinterpret_cast(Sbk_Katie_QByteArrayFunc_at), METH_O}, + {"begin", reinterpret_cast(Sbk_Katie_QByteArrayFunc_begin), METH_NOARGS}, + {"capacity", reinterpret_cast(Sbk_Katie_QByteArrayFunc_capacity), METH_NOARGS}, + {"chop", reinterpret_cast(Sbk_Katie_QByteArrayFunc_chop), METH_O}, + {"clear", reinterpret_cast(Sbk_Katie_QByteArrayFunc_clear), METH_NOARGS}, + {"constBegin", reinterpret_cast(Sbk_Katie_QByteArrayFunc_constBegin), METH_NOARGS}, + {"constData", reinterpret_cast(Sbk_Katie_QByteArrayFunc_constData), METH_NOARGS}, + {"constEnd", reinterpret_cast(Sbk_Katie_QByteArrayFunc_constEnd), METH_NOARGS}, + {"contains", reinterpret_cast(Sbk_Katie_QByteArrayFunc_contains), METH_O}, + {"count", reinterpret_cast(Sbk_Katie_QByteArrayFunc_count), METH_VARARGS}, + {"data", reinterpret_cast(Sbk_Katie_QByteArrayFunc_data), METH_NOARGS}, + {"detach", reinterpret_cast(Sbk_Katie_QByteArrayFunc_detach), METH_NOARGS}, + {"end", reinterpret_cast(Sbk_Katie_QByteArrayFunc_end), METH_NOARGS}, + {"endsWith", reinterpret_cast(Sbk_Katie_QByteArrayFunc_endsWith), METH_O}, + {"fill", reinterpret_cast(Sbk_Katie_QByteArrayFunc_fill), METH_VARARGS|METH_KEYWORDS}, + {"fromBase64", reinterpret_cast(Sbk_Katie_QByteArrayFunc_fromBase64), METH_O|METH_STATIC}, + {"fromHex", reinterpret_cast(Sbk_Katie_QByteArrayFunc_fromHex), METH_O|METH_STATIC}, + {"fromPercentEncoding", reinterpret_cast(Sbk_Katie_QByteArrayFunc_fromPercentEncoding), METH_VARARGS|METH_KEYWORDS|METH_STATIC}, + {"fromRawData", reinterpret_cast(Sbk_Katie_QByteArrayFunc_fromRawData), METH_VARARGS|METH_STATIC}, + {"fromStdString", reinterpret_cast(Sbk_Katie_QByteArrayFunc_fromStdString), METH_O|METH_STATIC}, + {"indexOf", reinterpret_cast(Sbk_Katie_QByteArrayFunc_indexOf), METH_VARARGS|METH_KEYWORDS}, + {"insert", reinterpret_cast(Sbk_Katie_QByteArrayFunc_insert), METH_VARARGS}, + {"isDetached", reinterpret_cast(Sbk_Katie_QByteArrayFunc_isDetached), METH_NOARGS}, + {"isEmpty", reinterpret_cast(Sbk_Katie_QByteArrayFunc_isEmpty), METH_NOARGS}, + {"isNull", reinterpret_cast(Sbk_Katie_QByteArrayFunc_isNull), METH_NOARGS}, + {"isSharedWith", reinterpret_cast(Sbk_Katie_QByteArrayFunc_isSharedWith), METH_O}, + {"lastIndexOf", reinterpret_cast(Sbk_Katie_QByteArrayFunc_lastIndexOf), METH_VARARGS|METH_KEYWORDS}, + {"left", reinterpret_cast(Sbk_Katie_QByteArrayFunc_left), METH_O}, + {"leftJustified", reinterpret_cast(Sbk_Katie_QByteArrayFunc_leftJustified), METH_VARARGS|METH_KEYWORDS}, + {"length", reinterpret_cast(Sbk_Katie_QByteArrayFunc_length), METH_NOARGS}, + {"mid", reinterpret_cast(Sbk_Katie_QByteArrayFunc_mid), METH_VARARGS|METH_KEYWORDS}, + {"number", reinterpret_cast(Sbk_Katie_QByteArrayFunc_number), METH_VARARGS|METH_KEYWORDS|METH_STATIC}, + {"prepend", reinterpret_cast(Sbk_Katie_QByteArrayFunc_prepend), METH_VARARGS}, + {"push_back", reinterpret_cast(Sbk_Katie_QByteArrayFunc_push_back), METH_O}, + {"push_front", reinterpret_cast(Sbk_Katie_QByteArrayFunc_push_front), METH_O}, + {"remove", reinterpret_cast(Sbk_Katie_QByteArrayFunc_remove), METH_VARARGS}, + {"repeated", reinterpret_cast(Sbk_Katie_QByteArrayFunc_repeated), METH_O}, + {"replace", reinterpret_cast(Sbk_Katie_QByteArrayFunc_replace), METH_VARARGS}, + {"reserve", reinterpret_cast(Sbk_Katie_QByteArrayFunc_reserve), METH_O}, + {"resize", reinterpret_cast(Sbk_Katie_QByteArrayFunc_resize), METH_O}, + {"right", reinterpret_cast(Sbk_Katie_QByteArrayFunc_right), METH_O}, + {"rightJustified", reinterpret_cast(Sbk_Katie_QByteArrayFunc_rightJustified), METH_VARARGS|METH_KEYWORDS}, + {"setNum", reinterpret_cast(Sbk_Katie_QByteArrayFunc_setNum), METH_VARARGS|METH_KEYWORDS}, + {"setRawData", reinterpret_cast(Sbk_Katie_QByteArrayFunc_setRawData), METH_VARARGS}, + {"simplified", reinterpret_cast(Sbk_Katie_QByteArrayFunc_simplified), METH_NOARGS}, + {"size", reinterpret_cast(Sbk_Katie_QByteArrayFunc_size), METH_NOARGS}, + {"squeeze", reinterpret_cast(Sbk_Katie_QByteArrayFunc_squeeze), METH_NOARGS}, + {"startsWith", reinterpret_cast(Sbk_Katie_QByteArrayFunc_startsWith), METH_O}, + {"swap", reinterpret_cast(Sbk_Katie_QByteArrayFunc_swap), METH_O}, + {"toBase64", reinterpret_cast(Sbk_Katie_QByteArrayFunc_toBase64), METH_NOARGS}, + {"toDouble", reinterpret_cast(Sbk_Katie_QByteArrayFunc_toDouble), METH_VARARGS|METH_KEYWORDS}, + {"toFloat", reinterpret_cast(Sbk_Katie_QByteArrayFunc_toFloat), METH_VARARGS|METH_KEYWORDS}, + {"toHex", reinterpret_cast(Sbk_Katie_QByteArrayFunc_toHex), METH_NOARGS}, + {"toInt", reinterpret_cast(Sbk_Katie_QByteArrayFunc_toInt), METH_VARARGS|METH_KEYWORDS}, + {"toLong", reinterpret_cast(Sbk_Katie_QByteArrayFunc_toLong), METH_VARARGS|METH_KEYWORDS}, + {"toLongLong", reinterpret_cast(Sbk_Katie_QByteArrayFunc_toLongLong), METH_VARARGS|METH_KEYWORDS}, + {"toLower", reinterpret_cast(Sbk_Katie_QByteArrayFunc_toLower), METH_NOARGS}, + {"toPercentEncoding", reinterpret_cast(Sbk_Katie_QByteArrayFunc_toPercentEncoding), METH_VARARGS|METH_KEYWORDS}, + {"toShort", reinterpret_cast(Sbk_Katie_QByteArrayFunc_toShort), METH_VARARGS|METH_KEYWORDS}, + {"toStdString", reinterpret_cast(Sbk_Katie_QByteArrayFunc_toStdString), METH_NOARGS}, + {"toUInt", reinterpret_cast(Sbk_Katie_QByteArrayFunc_toUInt), METH_VARARGS|METH_KEYWORDS}, + {"toULong", reinterpret_cast(Sbk_Katie_QByteArrayFunc_toULong), METH_VARARGS|METH_KEYWORDS}, + {"toULongLong", reinterpret_cast(Sbk_Katie_QByteArrayFunc_toULongLong), METH_VARARGS|METH_KEYWORDS}, + {"toUShort", reinterpret_cast(Sbk_Katie_QByteArrayFunc_toUShort), METH_VARARGS|METH_KEYWORDS}, + {"toUpper", reinterpret_cast(Sbk_Katie_QByteArrayFunc_toUpper), METH_NOARGS}, + {"trimmed", reinterpret_cast(Sbk_Katie_QByteArrayFunc_trimmed), METH_NOARGS}, + {"truncate", reinterpret_cast(Sbk_Katie_QByteArrayFunc_truncate), METH_O}, + + {nullptr, nullptr} // Sentinel +}; + +static int Sbk_Katie_QByteArray___nb_bool(PyObject* self) +{ + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return -1; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + return !cppSelf->isNull(); +} + +static PyObject* Sbk_Katie_QByteArrayFunc___iadd__(PyObject* self, PyObject* pyArg) +{ + bool isReverse = SbkObject_TypeCheck(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], pyArg) + && !SbkObject_TypeCheck(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], self); + if (isReverse) + std::swap(self, pyArg); + ::Katie::QByteArray* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QByteArray::operator+=(char) + // 1: QByteArray::operator+=(Katie::QByteArray) + // 2: QByteArray::operator+=(Katie::QString) + // 3: QByteArray::operator+=(const char*) + if (!isReverse + && Shiboken::String::check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 3; // operator+=(const char*) + } else if (!isReverse + && (pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArg)))) { + overloadId = 2; // operator+=(Katie::QString) + } else if (!isReverse + && (pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArg)))) { + overloadId = 1; // operator+=(Katie::QByteArray) + } else if (!isReverse + && SbkChar_Check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // operator+=(char) + } + + if (isReverse && overloadId == -1) { + PyErr_SetString(PyExc_NotImplementedError, "reverse operator not implemented."); + return {}; + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QByteArrayFunc___iadd___TypeError; + + // Call function/method + switch (overloadId) { + case 0: // operator+=(char c) + { + char cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // operator+=(char) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + (*cppSelf) += cppArg0; + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 1: // operator+=(const Katie::QByteArray & a) + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QByteArray* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // operator+=(Katie::QByteArray) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + (*cppSelf) += (*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 2: // operator+=(const Katie::QString & s) + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // operator+=(Katie::QString) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + (*cppSelf) += (*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 3: // operator+=(const char * s) + { + const char* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // operator+=(const char*) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + (*cppSelf) += cppArg0; + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_INCREF(self); + return self; + + Sbk_Katie_QByteArrayFunc___iadd___TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QByteArray.__iadd__"); + return {}; +} + +// Rich comparison +static PyObject* Sbk_Katie_QByteArray_richcompare(PyObject* self, PyObject* pyArg, int op) +{ + if (!Shiboken::Object::isValid(self)) + return {}; + ::Katie::QByteArray& cppSelf = *reinterpret_cast< ::Katie::QByteArray *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX], reinterpret_cast(self))); + SBK_UNUSED(cppSelf) + PyObject* pyResult{}; + PythonToCppFunc pythonToCpp; + SBK_UNUSED(pythonToCpp) + + switch (op) { + case Py_NE: + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArg)))) { + // operator!=(const Katie::QString & s2) const + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf !=(*cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else { + pyResult = Py_True; + Py_INCREF(pyResult); + } + + break; + case Py_LT: + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArg)))) { + // operator<(const Katie::QString & s2) const + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf <(*cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else { + goto Sbk_Katie_QByteArray_RichComparison_TypeError; + } + + break; + case Py_LE: + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArg)))) { + // operator<=(const Katie::QString & s2) const + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf <=(*cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else { + goto Sbk_Katie_QByteArray_RichComparison_TypeError; + } + + break; + case Py_EQ: + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArg)))) { + // operator==(const Katie::QString & s2) const + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf ==(*cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else { + pyResult = Py_False; + Py_INCREF(pyResult); + } + + break; + case Py_GT: + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArg)))) { + // operator>(const Katie::QString & s2) const + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf >(*cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else { + goto Sbk_Katie_QByteArray_RichComparison_TypeError; + } + + break; + case Py_GE: + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArg)))) { + // operator>=(const Katie::QString & s2) const + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf >=(*cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else { + goto Sbk_Katie_QByteArray_RichComparison_TypeError; + } + + break; + default: + goto Sbk_Katie_QByteArray_RichComparison_TypeError; + } + + if (pyResult && !PyErr_Occurred()) + return pyResult; + Sbk_Katie_QByteArray_RichComparison_TypeError: + PyErr_SetString(PyExc_NotImplementedError, "operator not implemented."); + return {}; + +} + +} // extern "C" + +static int Sbk_Katie_QByteArray_traverse(PyObject* self, visitproc visit, void* arg) +{ + return reinterpret_cast(SbkObject_TypeF())->tp_traverse(self, visit, arg); +} +static int Sbk_Katie_QByteArray_clear(PyObject* self) +{ + return reinterpret_cast(SbkObject_TypeF())->tp_clear(self); +} +// Class Definition ----------------------------------------------- +extern "C" { +static SbkObjectType *_Sbk_Katie_QByteArray_Type = nullptr; +static SbkObjectType *Sbk_Katie_QByteArray_TypeF(void) +{ + return _Sbk_Katie_QByteArray_Type; +} + +static PyType_Slot Sbk_Katie_QByteArray_slots[] = { + {Py_tp_base, nullptr}, // inserted by introduceWrapperType + {Py_tp_dealloc, reinterpret_cast(&SbkDeallocWrapper)}, + {Py_tp_repr, nullptr}, + {Py_tp_hash, nullptr}, + {Py_tp_call, nullptr}, + {Py_tp_str, nullptr}, + {Py_tp_getattro, nullptr}, + {Py_tp_setattro, nullptr}, + {Py_tp_traverse, reinterpret_cast(Sbk_Katie_QByteArray_traverse)}, + {Py_tp_clear, reinterpret_cast(Sbk_Katie_QByteArray_clear)}, + {Py_tp_richcompare, reinterpret_cast(Sbk_Katie_QByteArray_richcompare)}, + {Py_tp_iter, nullptr}, + {Py_tp_iternext, nullptr}, + {Py_tp_methods, reinterpret_cast(Sbk_Katie_QByteArray_methods)}, + {Py_tp_getset, nullptr}, + {Py_tp_init, reinterpret_cast(Sbk_Katie_QByteArray_Init)}, + {Py_tp_new, reinterpret_cast(SbkObjectTpNew)}, + // type supports number protocol + {Py_nb_inplace_add, (void *)Sbk_Katie_QByteArrayFunc___iadd__}, +#ifdef IS_PY3K + {Py_nb_bool, (void *)Sbk_Katie_QByteArray___nb_bool}, +#else + {Py_nb_nonzero, (void *)Sbk_Katie_QByteArray___nb_bool}, +#endif + {0, nullptr} +}; +static PyType_Spec Sbk_Katie_QByteArray_spec = { + "KtCore.Katie.QByteArray", + sizeof(SbkObject), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_GC, + Sbk_Katie_QByteArray_slots +}; + +} //extern "C" + + +// Type conversion functions. + +// Python to C++ pointer conversion - returns the C++ object of the Python wrapper (keeps object identity). +static void QByteArray_PythonToCpp_QByteArray_PTR(PyObject* pyIn, void* cppOut) { + Shiboken::Conversions::pythonToCppPointer(Sbk_Katie_QByteArray_TypeF(), pyIn, cppOut); +} +static PythonToCppFunc is_QByteArray_PythonToCpp_QByteArray_PTR_Convertible(PyObject* pyIn) { + if (pyIn == Py_None) + return Shiboken::Conversions::nonePythonToCppNullPtr; + if (PyObject_TypeCheck(pyIn, reinterpret_cast(Sbk_Katie_QByteArray_TypeF()))) + return QByteArray_PythonToCpp_QByteArray_PTR; + return {}; +} + +// C++ to Python pointer conversion - tries to find the Python wrapper for the C++ object (keeps object identity). +static PyObject* QByteArray_PTR_CppToPython_QByteArray(const void* cppIn) { + auto pyOut = reinterpret_cast(Shiboken::BindingManager::instance().retrieveWrapper(cppIn)); + if (pyOut) { + Py_INCREF(pyOut); + return pyOut; + } + bool changedTypeName = false; + auto tCppIn = reinterpret_cast(cppIn); + const char *typeName = typeid(*tCppIn).name(); + auto sbkType = Shiboken::ObjectType::typeForTypeName(typeName); + if (sbkType && Shiboken::ObjectType::hasSpecialCastFunction(sbkType)) { + typeName = typeNameOf(tCppIn); + changedTypeName = true; + } + PyObject *result = Shiboken::Object::newObject(Sbk_Katie_QByteArray_TypeF(), const_cast(cppIn), false, /* exactType */ changedTypeName, typeName); + if (changedTypeName) + delete [] typeName; + return result; +} + +// The signatures string for the functions. +// Multiple signatures have their index "n:" in front. +static const char *Katie_QByteArray_SignatureStrings[] = { + "5:KtCore.Katie.QByteArray()", + "4:KtCore.Katie.QByteArray(arg__1:KtCore.Katie.QByteArray)", + "3:KtCore.Katie.QByteArray(arg__1:str)", + "2:KtCore.Katie.QByteArray(arg__1:str,size:int)", + "1:KtCore.Katie.QByteArray(size:int,arg__2:KtCore.Katie.Qt.Initialization)", + "0:KtCore.Katie.QByteArray(size:int,c:char)", + "4:KtCore.Katie.QByteArray.append(c:char)->KtCore.Katie.QByteArray", + "3:KtCore.Katie.QByteArray.append(a:KtCore.Katie.QByteArray)->KtCore.Katie.QByteArray", + "2:KtCore.Katie.QByteArray.append(s:KtCore.Katie.QString)->KtCore.Katie.QByteArray", + "1:KtCore.Katie.QByteArray.append(s:str)->KtCore.Katie.QByteArray", + "0:KtCore.Katie.QByteArray.append(s:str,len:int)->KtCore.Katie.QByteArray", + "KtCore.Katie.QByteArray.at(i:int)->char", + "1:KtCore.Katie.QByteArray.begin()->str", + "0:KtCore.Katie.QByteArray.begin()->str", + "KtCore.Katie.QByteArray.capacity()->int", + "KtCore.Katie.QByteArray.chop(n:int)", + "KtCore.Katie.QByteArray.clear()", + "KtCore.Katie.QByteArray.constBegin()->str", + "KtCore.Katie.QByteArray.constData()->str", + "KtCore.Katie.QByteArray.constEnd()->str", + "2:KtCore.Katie.QByteArray.contains(c:char)->bool", + "1:KtCore.Katie.QByteArray.contains(a:KtCore.Katie.QByteArray)->bool", + "0:KtCore.Katie.QByteArray.contains(a:str)->bool", + "3:KtCore.Katie.QByteArray.count()->int", + "2:KtCore.Katie.QByteArray.count(c:char)->int", + "1:KtCore.Katie.QByteArray.count(a:KtCore.Katie.QByteArray)->int", + "0:KtCore.Katie.QByteArray.count(a:str)->int", + "1:KtCore.Katie.QByteArray.data()->str", + "0:KtCore.Katie.QByteArray.data()->str", + "KtCore.Katie.QByteArray.detach()", + "1:KtCore.Katie.QByteArray.end()->str", + "0:KtCore.Katie.QByteArray.end()->str", + "2:KtCore.Katie.QByteArray.endsWith(c:char)->bool", + "1:KtCore.Katie.QByteArray.endsWith(a:KtCore.Katie.QByteArray)->bool", + "0:KtCore.Katie.QByteArray.endsWith(c:str)->bool", + "KtCore.Katie.QByteArray.fill(c:char,size:int=-1)->KtCore.Katie.QByteArray", + "KtCore.Katie.QByteArray.fromBase64(base64:KtCore.Katie.QByteArray)->KtCore.Katie.QByteArray", + "KtCore.Katie.QByteArray.fromHex(hexEncoded:KtCore.Katie.QByteArray)->KtCore.Katie.QByteArray", + "KtCore.Katie.QByteArray.fromPercentEncoding(pctEncoded:KtCore.Katie.QByteArray,percent:char='%')->KtCore.Katie.QByteArray", + "KtCore.Katie.QByteArray.fromRawData(arg__1:str,size:int)->KtCore.Katie.QByteArray", + "KtCore.Katie.QByteArray.fromStdString(s:std.string)->KtCore.Katie.QByteArray", + "3:KtCore.Katie.QByteArray.indexOf(c:char,from:int=0)->int", + "2:KtCore.Katie.QByteArray.indexOf(a:KtCore.Katie.QByteArray,from:int=0)->int", + "1:KtCore.Katie.QByteArray.indexOf(s:KtCore.Katie.QString,from:int=0)->int", + "0:KtCore.Katie.QByteArray.indexOf(c:str,from:int=0)->int", + "4:KtCore.Katie.QByteArray.insert(i:int,s:KtCore.Katie.QString)->KtCore.Katie.QByteArray", + "3:KtCore.Katie.QByteArray.insert(i:int,c:char)->KtCore.Katie.QByteArray", + "2:KtCore.Katie.QByteArray.insert(i:int,a:KtCore.Katie.QByteArray)->KtCore.Katie.QByteArray", + "1:KtCore.Katie.QByteArray.insert(i:int,s:str)->KtCore.Katie.QByteArray", + "0:KtCore.Katie.QByteArray.insert(i:int,s:str,len:int)->KtCore.Katie.QByteArray", + "KtCore.Katie.QByteArray.isDetached()->bool", + "KtCore.Katie.QByteArray.isEmpty()->bool", + "KtCore.Katie.QByteArray.isNull()->bool", + "KtCore.Katie.QByteArray.isSharedWith(other:KtCore.Katie.QByteArray)->bool", + "3:KtCore.Katie.QByteArray.lastIndexOf(c:char,from:int=-1)->int", + "2:KtCore.Katie.QByteArray.lastIndexOf(a:KtCore.Katie.QByteArray,from:int=-1)->int", + "1:KtCore.Katie.QByteArray.lastIndexOf(s:KtCore.Katie.QString,from:int=-1)->int", + "0:KtCore.Katie.QByteArray.lastIndexOf(c:str,from:int=-1)->int", + "KtCore.Katie.QByteArray.left(len:int)->KtCore.Katie.QByteArray", + "KtCore.Katie.QByteArray.leftJustified(width:int,fill:char=' ',truncate:bool=false)->KtCore.Katie.QByteArray", + "KtCore.Katie.QByteArray.length()->int", + "KtCore.Katie.QByteArray.mid(index:int,len:int=-1)->KtCore.Katie.QByteArray", + "4:KtCore.Katie.QByteArray.number(arg__1:double,f:char='g',prec:int=6)->KtCore.Katie.QByteArray", + "3:KtCore.Katie.QByteArray.number(arg__1:int,base:int=10)->KtCore.Katie.QByteArray", + "2:KtCore.Katie.QByteArray.number(arg__1:long long,base:int=10)->KtCore.Katie.QByteArray", + "1:KtCore.Katie.QByteArray.number(arg__1:unsigned int,base:int=10)->KtCore.Katie.QByteArray", + "0:KtCore.Katie.QByteArray.number(arg__1:unsigned long long,base:int=10)->KtCore.Katie.QByteArray", + "3:KtCore.Katie.QByteArray.prepend(c:char)->KtCore.Katie.QByteArray", + "2:KtCore.Katie.QByteArray.prepend(a:KtCore.Katie.QByteArray)->KtCore.Katie.QByteArray", + "1:KtCore.Katie.QByteArray.prepend(s:str)->KtCore.Katie.QByteArray", + "0:KtCore.Katie.QByteArray.prepend(s:str,len:int)->KtCore.Katie.QByteArray", + "2:KtCore.Katie.QByteArray.push_back(c:char)", + "1:KtCore.Katie.QByteArray.push_back(a:KtCore.Katie.QByteArray)", + "0:KtCore.Katie.QByteArray.push_back(c:str)", + "2:KtCore.Katie.QByteArray.push_front(c:char)", + "1:KtCore.Katie.QByteArray.push_front(a:KtCore.Katie.QByteArray)", + "0:KtCore.Katie.QByteArray.push_front(c:str)", + "KtCore.Katie.QByteArray.remove(index:int,len:int)->KtCore.Katie.QByteArray", + "KtCore.Katie.QByteArray.repeated(times:int)->KtCore.Katie.QByteArray", + "13:KtCore.Katie.QByteArray.replace(before:char,after:char)->KtCore.Katie.QByteArray", + "12:KtCore.Katie.QByteArray.replace(before:char,after:KtCore.Katie.QByteArray)->KtCore.Katie.QByteArray", + "11:KtCore.Katie.QByteArray.replace(before:char,after:str)->KtCore.Katie.QByteArray", + "10:KtCore.Katie.QByteArray.replace(c:char,after:KtCore.Katie.QString)->KtCore.Katie.QByteArray", + "9:KtCore.Katie.QByteArray.replace(before:KtCore.Katie.QByteArray,after:KtCore.Katie.QByteArray)->KtCore.Katie.QByteArray", + "8:KtCore.Katie.QByteArray.replace(before:KtCore.Katie.QByteArray,after:str)->KtCore.Katie.QByteArray", + "7:KtCore.Katie.QByteArray.replace(before:KtCore.Katie.QString,after:KtCore.Katie.QByteArray)->KtCore.Katie.QByteArray", + "6:KtCore.Katie.QByteArray.replace(before:KtCore.Katie.QString,after:str)->KtCore.Katie.QByteArray", + "5:KtCore.Katie.QByteArray.replace(before:str,after:KtCore.Katie.QByteArray)->KtCore.Katie.QByteArray", + "4:KtCore.Katie.QByteArray.replace(before:str,after:str)->KtCore.Katie.QByteArray", + "3:KtCore.Katie.QByteArray.replace(before:str,bsize:int,after:str,asize:int)->KtCore.Katie.QByteArray", + "2:KtCore.Katie.QByteArray.replace(index:int,len:int,s:KtCore.Katie.QByteArray)->KtCore.Katie.QByteArray", + "1:KtCore.Katie.QByteArray.replace(index:int,len:int,s:str)->KtCore.Katie.QByteArray", + "0:KtCore.Katie.QByteArray.replace(index:int,len:int,s:str,alen:int)->KtCore.Katie.QByteArray", + "KtCore.Katie.QByteArray.reserve(size:int)", + "KtCore.Katie.QByteArray.resize(size:int)", + "KtCore.Katie.QByteArray.right(len:int)->KtCore.Katie.QByteArray", + "KtCore.Katie.QByteArray.rightJustified(width:int,fill:char=' ',truncate:bool=false)->KtCore.Katie.QByteArray", + "7:KtCore.Katie.QByteArray.setNum(arg__1:double,f:char='g',prec:int=6)->KtCore.Katie.QByteArray", + "6:KtCore.Katie.QByteArray.setNum(arg__1:float,f:char='g',prec:int=6)->KtCore.Katie.QByteArray", + "5:KtCore.Katie.QByteArray.setNum(arg__1:int,base:int=10)->KtCore.Katie.QByteArray", + "4:KtCore.Katie.QByteArray.setNum(arg__1:long long,base:int=10)->KtCore.Katie.QByteArray", + "3:KtCore.Katie.QByteArray.setNum(arg__1:short,base:int=10)->KtCore.Katie.QByteArray", + "2:KtCore.Katie.QByteArray.setNum(arg__1:unsigned int,base:int=10)->KtCore.Katie.QByteArray", + "1:KtCore.Katie.QByteArray.setNum(arg__1:unsigned long long,base:int=10)->KtCore.Katie.QByteArray", + "0:KtCore.Katie.QByteArray.setNum(arg__1:ushort,base:int=10)->KtCore.Katie.QByteArray", + "KtCore.Katie.QByteArray.setRawData(a:str,n:unsigned int)->KtCore.Katie.QByteArray", + "KtCore.Katie.QByteArray.simplified()->KtCore.Katie.QByteArray", + "KtCore.Katie.QByteArray.size()->int", + "KtCore.Katie.QByteArray.squeeze()", + "2:KtCore.Katie.QByteArray.startsWith(c:char)->bool", + "1:KtCore.Katie.QByteArray.startsWith(a:KtCore.Katie.QByteArray)->bool", + "0:KtCore.Katie.QByteArray.startsWith(c:str)->bool", + "KtCore.Katie.QByteArray.swap(other:KtCore.Katie.QByteArray)", + "KtCore.Katie.QByteArray.toBase64()->KtCore.Katie.QByteArray", + "KtCore.Katie.QByteArray.toDouble(ok:KtCore.bool=Q_NULLPTR)->double", + "KtCore.Katie.QByteArray.toFloat(ok:KtCore.bool=Q_NULLPTR)->float", + "KtCore.Katie.QByteArray.toHex()->KtCore.Katie.QByteArray", + "KtCore.Katie.QByteArray.toInt(ok:KtCore.bool=Q_NULLPTR,base:int=10)->int", + "KtCore.Katie.QByteArray.toLong(ok:KtCore.bool=Q_NULLPTR,base:int=10)->long", + "KtCore.Katie.QByteArray.toLongLong(ok:KtCore.bool=Q_NULLPTR,base:int=10)->long long", + "KtCore.Katie.QByteArray.toLower()->KtCore.Katie.QByteArray", + "KtCore.Katie.QByteArray.toPercentEncoding(exclude:KtCore.Katie.QByteArray=Katie.QByteArray(),include:KtCore.Katie.QByteArray=Katie.QByteArray(),percent:char='%')->KtCore.Katie.QByteArray", + "KtCore.Katie.QByteArray.toShort(ok:KtCore.bool=Q_NULLPTR,base:int=10)->short", + "KtCore.Katie.QByteArray.toStdString()->std.string", + "KtCore.Katie.QByteArray.toUInt(ok:KtCore.bool=Q_NULLPTR,base:int=10)->unsigned int", + "KtCore.Katie.QByteArray.toULong(ok:KtCore.bool=Q_NULLPTR,base:int=10)->ulong", + "KtCore.Katie.QByteArray.toULongLong(ok:KtCore.bool=Q_NULLPTR,base:int=10)->unsigned long long", + "KtCore.Katie.QByteArray.toUShort(ok:KtCore.bool=Q_NULLPTR,base:int=10)->ushort", + "KtCore.Katie.QByteArray.toUpper()->KtCore.Katie.QByteArray", + "KtCore.Katie.QByteArray.trimmed()->KtCore.Katie.QByteArray", + "KtCore.Katie.QByteArray.truncate(pos:int)", + "3:KtCore.Katie.QByteArray.__iadd__(c:char)->KtCore.Katie.QByteArray", + "2:KtCore.Katie.QByteArray.__iadd__(a:KtCore.Katie.QByteArray)->KtCore.Katie.QByteArray", + "1:KtCore.Katie.QByteArray.__iadd__(s:KtCore.Katie.QString)->KtCore.Katie.QByteArray", + "0:KtCore.Katie.QByteArray.__iadd__(s:str)->KtCore.Katie.QByteArray", + nullptr}; // Sentinel + +void init_Katie_QByteArray(PyObject* module) +{ + _Sbk_Katie_QByteArray_Type = Shiboken::ObjectType::introduceWrapperType( + module, + "QByteArray", + "Katie::QByteArray*", + &Sbk_Katie_QByteArray_spec, + Katie_QByteArray_SignatureStrings, + &Shiboken::callCppDestructor< ::Katie::QByteArray >, + 0, + 0, + 0 ); + + SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX] + = reinterpret_cast(Sbk_Katie_QByteArray_TypeF()); + + // Register Converter + SbkConverter* converter = Shiboken::Conversions::createConverter(Sbk_Katie_QByteArray_TypeF(), + QByteArray_PythonToCpp_QByteArray_PTR, + is_QByteArray_PythonToCpp_QByteArray_PTR_Convertible, + QByteArray_PTR_CppToPython_QByteArray); + + Shiboken::Conversions::registerConverterName(converter, "Katie::QByteArray"); + Shiboken::Conversions::registerConverterName(converter, "Katie::QByteArray*"); + Shiboken::Conversions::registerConverterName(converter, "Katie::QByteArray&"); + Shiboken::Conversions::registerConverterName(converter, "QByteArray"); + Shiboken::Conversions::registerConverterName(converter, "QByteArray*"); + Shiboken::Conversions::registerConverterName(converter, "QByteArray&"); + Shiboken::Conversions::registerConverterName(converter, typeid(::Katie::QByteArray).name()); + + + +} diff --git a/bindings/KtCore/katie_qbytearray_wrapper.h b/bindings/KtCore/katie_qbytearray_wrapper.h new file mode 100644 index 000000000..19143bcbb --- /dev/null +++ b/bindings/KtCore/katie_qbytearray_wrapper.h @@ -0,0 +1,47 @@ +/**************************************************************************** +** +** Copyright (C) 2015 The Qt Company Ltd. +** Contact: http://www.qt.io/licensing/ +** +** This file is part of the FOO module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of The Qt Company Ltd nor the names of its +** contributors may be used to endorse or promote products derived +** from this software without specific prior written permission. +** +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef SBK_KATIE_QBYTEARRAY_H +#define SBK_KATIE_QBYTEARRAY_H + +#include + +#endif // SBK_KATIE_QBYTEARRAY_H + diff --git a/bindings/KtCore/katie_qchar_wrapper.cpp b/bindings/KtCore/katie_qchar_wrapper.cpp new file mode 100644 index 000000000..0dfc2aa5a --- /dev/null +++ b/bindings/KtCore/katie_qchar_wrapper.cpp @@ -0,0 +1,3613 @@ +/**************************************************************************** +** +** Copyright (C) 2015 The Qt Company Ltd. +** Contact: http://www.qt.io/licensing/ +** +** This file is part of the FOO module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of The Qt Company Ltd nor the names of its +** contributors may be used to endorse or promote products derived +** from this software without specific prior written permission. +** +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + +// default includes +#include +#include + +// module include +#include "ktcore_python.h" + +// main header +#include "katie_qchar_wrapper.h" + +// inner classes + +// Extra includes +#include +#include + + +#include +#include +using namespace Katie; + + + +template +static const char *typeNameOf(const T &t) +{ + const char *typeName = typeid(t).name(); + auto size = std::strlen(typeName); +#if defined(Q_CC_MSVC) // MSVC: "class QPaintDevice * __ptr64" + if (auto lastStar = strchr(typeName, '*')) { + // MSVC: "class QPaintDevice * __ptr64" + while (*--lastStar == ' ') { + } + size = lastStar - typeName + 1; + } +#else // g++, Clang: "QPaintDevice *" -> "P12QPaintDevice" + if (size > 2 && typeName[0] == 'P' && std::isdigit(typeName[1])) { + ++typeName; + --size; + } +#endif + char *result = new char[size + 1]; + result[size] = '\0'; + memcpy(result, typeName, size); + return result; +} + + +// Target --------------------------------------------------------- + +extern "C" { +static int +Sbk_Katie_QChar_Init(PyObject* self, PyObject* args, PyObject* kwds) +{ + SbkObject* sbkSelf = reinterpret_cast(self); + if (Shiboken::Object::isUserType(self) && !Shiboken::ObjectType::canCallConstructor(self->ob_type, Shiboken::SbkType< ::Katie::QChar >())) + return -1; + + ::Katie::QChar* cptr{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "QChar", 0, 2, &(pyArgs[0]), &(pyArgs[1]))) + return -1; + + + // Overloaded function decisor + // 0: QChar::QChar() + // 1: QChar::QChar(Katie::QChar::SpecialCharacter) + // 2: QChar::QChar(Katie::QLatin1Char) + // 3: QChar::QChar(char) + // 4: QChar::QChar(int) + // 5: QChar::QChar(short) + // 6: QChar::QChar(uchar) + // 7: QChar::QChar(uchar,uchar) + // 8: QChar::QChar(uint) + // 9: QChar::QChar(ushort) + if (numArgs == 0) { + overloadId = 0; // QChar() + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 9; // QChar(ushort) + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppValueConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QLATIN1CHAR_IDX]), (pyArgs[0])))) { + overloadId = 2; // QChar(Katie::QLatin1Char) + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QCHAR_SPECIALCHARACTER_IDX])->converter, (pyArgs[0])))) { + overloadId = 1; // QChar(Katie::QChar::SpecialCharacter) + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 8; // QChar(uint) + } else if (SbkChar_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 6; // QChar(uchar) + } else if (numArgs == 2 + && SbkChar_Check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 7; // QChar(uchar,uchar) + } + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 5; // QChar(short) + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 4; // QChar(int) + } else if (numArgs == 1 + && SbkChar_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 3; // QChar(char) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QChar_Init_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // QChar() + { + + if (!PyErr_Occurred()) { + // QChar() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cptr = new ::Katie::QChar(); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 1: // QChar(const Katie::QChar::SpecialCharacter sc) + { + ::Katie::QChar::SpecialCharacter cppArg0{Katie::QChar::Null}; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // QChar(Katie::QChar::SpecialCharacter) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cptr = new ::Katie::QChar(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 2: // QChar(const Katie::QLatin1Char ch) + { + if (!Shiboken::Object::isValid(pyArgs[0])) + return -1; + ::Katie::QLatin1Char* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // QChar(Katie::QLatin1Char) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cptr = new ::Katie::QChar(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 3: // QChar(const char c) + { + char cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // QChar(char) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cptr = new ::Katie::QChar(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 4: // QChar(const int rc) + { + int cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // QChar(int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cptr = new ::Katie::QChar(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 5: // QChar(const short rc) + { + short cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // QChar(short) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cptr = new ::Katie::QChar(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 6: // QChar(const uchar c) + { + uchar cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // QChar(uchar) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cptr = new ::Katie::QChar(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 7: // QChar(const uchar c, uchar r) + { + uchar cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + uchar cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // QChar(uchar,uchar) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cptr = new ::Katie::QChar(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 8: // QChar(const uint rc) + { + uint cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // QChar(uint) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cptr = new ::Katie::QChar(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 9: // QChar(const ushort rc) + { + ::ushort cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // QChar(ushort) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cptr = new ::Katie::QChar(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + } + + if (PyErr_Occurred() || !Shiboken::Object::setCppPointer(sbkSelf, Shiboken::SbkType< ::Katie::QChar >(), cptr)) { + delete cptr; + return -1; + } + if (!cptr) goto Sbk_Katie_QChar_Init_TypeError; + + Shiboken::Object::setValidCpp(sbkSelf, true); + if (Shiboken::BindingManager::instance().hasWrapper(cptr)) { + Shiboken::BindingManager::instance().releaseWrapper(Shiboken::BindingManager::instance().retrieveWrapper(cptr)); + } + Shiboken::BindingManager::instance().registerWrapper(sbkSelf, cptr); + + + return 1; + + Sbk_Katie_QChar_Init_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QChar"); + return -1; +} + +static PyObject* Sbk_Katie_QCharFunc_category(PyObject* self, PyObject* args) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (self) { + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + } + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "category", 0, 1, &(pyArgs[0]))) + return {}; + + + // Overloaded function decisor + // 0: QChar::category()const + // 1: static QChar::category(uint) + // 2: static QChar::category(ushort) + if (numArgs == 0) { + overloadId = 0; // category()const + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 2; // category(ushort) + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 1; // category(uint) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCharFunc_category_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // category() const + { + + if (!PyErr_Occurred()) { + // category()const + Katie::QChar::Category cppResult = Katie::QChar::Category(const_cast(cppSelf)->category()); + pyResult = Shiboken::Conversions::copyToPython(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX])->converter, &cppResult); + } + break; + } + case 1: // category(const uint ucs4) + { + uint cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // category(uint) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QChar::Category cppResult = Katie::QChar::Category(::Katie::QChar::category(cppArg0)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX])->converter, &cppResult); + } + break; + } + case 2: // category(const ushort ucs2) + { + ::ushort cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // category(ushort) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QChar::Category cppResult = Katie::QChar::Category(::Katie::QChar::category(cppArg0)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX])->converter, &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QCharFunc_category_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QChar.category"); + return {}; +} + +static PyObject* Sbk_Katie_QCharFunc_cell(PyObject* self) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // cell()const + uchar cppResult = const_cast(cppSelf)->cell(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QCharFunc_combiningClass(PyObject* self, PyObject* args) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (self) { + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + } + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "combiningClass", 0, 1, &(pyArgs[0]))) + return {}; + + + // Overloaded function decisor + // 0: QChar::combiningClass()const + // 1: static QChar::combiningClass(uint) + // 2: static QChar::combiningClass(ushort) + if (numArgs == 0) { + overloadId = 0; // combiningClass()const + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 2; // combiningClass(ushort) + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 1; // combiningClass(uint) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCharFunc_combiningClass_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // combiningClass() const + { + + if (!PyErr_Occurred()) { + // combiningClass()const + unsigned char cppResult = const_cast(cppSelf)->combiningClass(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 1: // combiningClass(const uint ucs4) + { + uint cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // combiningClass(uint) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + unsigned char cppResult = ::Katie::QChar::combiningClass(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 2: // combiningClass(const ushort ucs2) + { + ::ushort cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // combiningClass(ushort) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + unsigned char cppResult = ::Katie::QChar::combiningClass(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QCharFunc_combiningClass_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QChar.combiningClass"); + return {}; +} + +static PyObject* Sbk_Katie_QCharFunc_currentUnicodeVersion(PyObject* self) +{ + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // currentUnicodeVersion() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QChar::UnicodeVersion cppResult = Katie::QChar::UnicodeVersion(::Katie::QChar::currentUnicodeVersion()); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QCHAR_UNICODEVERSION_IDX])->converter, &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QCharFunc_decomposition(PyObject* self, PyObject* args) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (self) { + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + } + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "decomposition", 0, 1, &(pyArgs[0]))) + return {}; + + + // Overloaded function decisor + // 0: QChar::decomposition()const + // 1: static QChar::decomposition(uint) + if (numArgs == 0) { + overloadId = 0; // decomposition()const + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 1; // decomposition(uint) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCharFunc_decomposition_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // decomposition() const + { + + if (!PyErr_Occurred()) { + // decomposition()const + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->decomposition()); + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + break; + } + case 1: // decomposition(uint ucs4) + { + uint cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // decomposition(uint) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(::Katie::QChar::decomposition(cppArg0)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QCharFunc_decomposition_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QChar.decomposition"); + return {}; +} + +static PyObject* Sbk_Katie_QCharFunc_decompositionTag(PyObject* self, PyObject* args) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (self) { + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + } + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "decompositionTag", 0, 1, &(pyArgs[0]))) + return {}; + + + // Overloaded function decisor + // 0: QChar::decompositionTag()const + // 1: static QChar::decompositionTag(uint) + if (numArgs == 0) { + overloadId = 0; // decompositionTag()const + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 1; // decompositionTag(uint) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCharFunc_decompositionTag_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // decompositionTag() const + { + + if (!PyErr_Occurred()) { + // decompositionTag()const + Katie::QChar::Decomposition cppResult = Katie::QChar::Decomposition(const_cast(cppSelf)->decompositionTag()); + pyResult = Shiboken::Conversions::copyToPython(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QCHAR_DECOMPOSITION_IDX])->converter, &cppResult); + } + break; + } + case 1: // decompositionTag(const uint ucs4) + { + uint cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // decompositionTag(uint) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QChar::Decomposition cppResult = Katie::QChar::Decomposition(::Katie::QChar::decompositionTag(cppArg0)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QCHAR_DECOMPOSITION_IDX])->converter, &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QCharFunc_decompositionTag_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QChar.decompositionTag"); + return {}; +} + +static PyObject* Sbk_Katie_QCharFunc_digitValue(PyObject* self, PyObject* args) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (self) { + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + } + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "digitValue", 0, 1, &(pyArgs[0]))) + return {}; + + + // Overloaded function decisor + // 0: QChar::digitValue()const + // 1: static QChar::digitValue(uint) + // 2: static QChar::digitValue(ushort) + if (numArgs == 0) { + overloadId = 0; // digitValue()const + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 2; // digitValue(ushort) + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 1; // digitValue(uint) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCharFunc_digitValue_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // digitValue() const + { + + if (!PyErr_Occurred()) { + // digitValue()const + int cppResult = const_cast(cppSelf)->digitValue(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 1: // digitValue(const uint ucs4) + { + uint cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // digitValue(uint) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + int cppResult = ::Katie::QChar::digitValue(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 2: // digitValue(const ushort ucs2) + { + ::ushort cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // digitValue(ushort) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + int cppResult = ::Katie::QChar::digitValue(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QCharFunc_digitValue_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QChar.digitValue"); + return {}; +} + +static PyObject* Sbk_Katie_QCharFunc_direction(PyObject* self, PyObject* args) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (self) { + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + } + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "direction", 0, 1, &(pyArgs[0]))) + return {}; + + + // Overloaded function decisor + // 0: QChar::direction()const + // 1: static QChar::direction(uint) + // 2: static QChar::direction(ushort) + if (numArgs == 0) { + overloadId = 0; // direction()const + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 2; // direction(ushort) + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 1; // direction(uint) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCharFunc_direction_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // direction() const + { + + if (!PyErr_Occurred()) { + // direction()const + Katie::QChar::Direction cppResult = Katie::QChar::Direction(const_cast(cppSelf)->direction()); + pyResult = Shiboken::Conversions::copyToPython(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QCHAR_DIRECTION_IDX])->converter, &cppResult); + } + break; + } + case 1: // direction(const uint ucs4) + { + uint cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // direction(uint) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QChar::Direction cppResult = Katie::QChar::Direction(::Katie::QChar::direction(cppArg0)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QCHAR_DIRECTION_IDX])->converter, &cppResult); + } + break; + } + case 2: // direction(const ushort ucs2) + { + ::ushort cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // direction(ushort) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QChar::Direction cppResult = Katie::QChar::Direction(::Katie::QChar::direction(cppArg0)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QCHAR_DIRECTION_IDX])->converter, &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QCharFunc_direction_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QChar.direction"); + return {}; +} + +static PyObject* Sbk_Katie_QCharFunc_fromAscii(PyObject* self, PyObject* pyArg) +{ + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: static QChar::fromAscii(char) + if (SbkChar_Check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // fromAscii(char) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCharFunc_fromAscii_TypeError; + + // Call function/method + { + char cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // fromAscii(char) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QChar* cppResult = new Katie::QChar(::Katie::QChar::fromAscii(cppArg0)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QCharFunc_fromAscii_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QChar.fromAscii"); + return {}; +} + +static PyObject* Sbk_Katie_QCharFunc_fromLatin1(PyObject* self, PyObject* pyArg) +{ + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: static QChar::fromLatin1(char) + if (SbkChar_Check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // fromLatin1(char) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCharFunc_fromLatin1_TypeError; + + // Call function/method + { + char cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // fromLatin1(char) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QChar* cppResult = new Katie::QChar(::Katie::QChar::fromLatin1(cppArg0)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QCharFunc_fromLatin1_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QChar.fromLatin1"); + return {}; +} + +static PyObject* Sbk_Katie_QCharFunc_hasMirrored(PyObject* self) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // hasMirrored()const + bool cppResult = const_cast(cppSelf)->hasMirrored(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QCharFunc_highSurrogate(PyObject* self, PyObject* pyArg) +{ + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: static QChar::highSurrogate(uint) + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // highSurrogate(uint) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCharFunc_highSurrogate_TypeError; + + // Call function/method + { + uint cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // highSurrogate(uint) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + ushort cppResult = ::Katie::QChar::highSurrogate(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QCharFunc_highSurrogate_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QChar.highSurrogate"); + return {}; +} + +static PyObject* Sbk_Katie_QCharFunc_isDigit(PyObject* self) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // isDigit()const + bool cppResult = const_cast(cppSelf)->isDigit(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QCharFunc_isHighSurrogate(PyObject* self, PyObject* args) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (self) { + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + } + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "isHighSurrogate", 0, 1, &(pyArgs[0]))) + return {}; + + + // Overloaded function decisor + // 0: QChar::isHighSurrogate()const + // 1: static QChar::isHighSurrogate(uint) + if (numArgs == 0) { + overloadId = 0; // isHighSurrogate()const + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 1; // isHighSurrogate(uint) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCharFunc_isHighSurrogate_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // isHighSurrogate() const + { + + if (!PyErr_Occurred()) { + // isHighSurrogate()const + bool cppResult = const_cast(cppSelf)->isHighSurrogate(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 1: // isHighSurrogate(uint ucs4) + { + uint cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // isHighSurrogate(uint) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + bool cppResult = ::Katie::QChar::isHighSurrogate(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QCharFunc_isHighSurrogate_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QChar.isHighSurrogate"); + return {}; +} + +static PyObject* Sbk_Katie_QCharFunc_isLetter(PyObject* self) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // isLetter()const + bool cppResult = const_cast(cppSelf)->isLetter(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QCharFunc_isLetterOrNumber(PyObject* self) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // isLetterOrNumber()const + bool cppResult = const_cast(cppSelf)->isLetterOrNumber(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QCharFunc_isLowSurrogate(PyObject* self, PyObject* args) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (self) { + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + } + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "isLowSurrogate", 0, 1, &(pyArgs[0]))) + return {}; + + + // Overloaded function decisor + // 0: QChar::isLowSurrogate()const + // 1: static QChar::isLowSurrogate(uint) + if (numArgs == 0) { + overloadId = 0; // isLowSurrogate()const + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 1; // isLowSurrogate(uint) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCharFunc_isLowSurrogate_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // isLowSurrogate() const + { + + if (!PyErr_Occurred()) { + // isLowSurrogate()const + bool cppResult = const_cast(cppSelf)->isLowSurrogate(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 1: // isLowSurrogate(uint ucs4) + { + uint cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // isLowSurrogate(uint) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + bool cppResult = ::Katie::QChar::isLowSurrogate(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QCharFunc_isLowSurrogate_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QChar.isLowSurrogate"); + return {}; +} + +static PyObject* Sbk_Katie_QCharFunc_isLower(PyObject* self) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // isLower()const + bool cppResult = const_cast(cppSelf)->isLower(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QCharFunc_isMark(PyObject* self) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // isMark()const + bool cppResult = const_cast(cppSelf)->isMark(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QCharFunc_isNull(PyObject* self) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // isNull()const + bool cppResult = const_cast(cppSelf)->isNull(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QCharFunc_isNumber(PyObject* self) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // isNumber()const + bool cppResult = const_cast(cppSelf)->isNumber(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QCharFunc_isPrint(PyObject* self) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // isPrint()const + bool cppResult = const_cast(cppSelf)->isPrint(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QCharFunc_isPunct(PyObject* self) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // isPunct()const + bool cppResult = const_cast(cppSelf)->isPunct(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QCharFunc_isSpace(PyObject* self) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // isSpace()const + bool cppResult = const_cast(cppSelf)->isSpace(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QCharFunc_isSymbol(PyObject* self) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // isSymbol()const + bool cppResult = const_cast(cppSelf)->isSymbol(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QCharFunc_isTitleCase(PyObject* self) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // isTitleCase()const + bool cppResult = const_cast(cppSelf)->isTitleCase(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QCharFunc_isUpper(PyObject* self) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // isUpper()const + bool cppResult = const_cast(cppSelf)->isUpper(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QCharFunc_joining(PyObject* self, PyObject* args) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (self) { + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + } + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "joining", 0, 1, &(pyArgs[0]))) + return {}; + + + // Overloaded function decisor + // 0: QChar::joining()const + // 1: static QChar::joining(uint) + // 2: static QChar::joining(ushort) + if (numArgs == 0) { + overloadId = 0; // joining()const + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 2; // joining(ushort) + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 1; // joining(uint) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCharFunc_joining_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // joining() const + { + + if (!PyErr_Occurred()) { + // joining()const + Katie::QChar::Joining cppResult = Katie::QChar::Joining(const_cast(cppSelf)->joining()); + pyResult = Shiboken::Conversions::copyToPython(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QCHAR_JOINING_IDX])->converter, &cppResult); + } + break; + } + case 1: // joining(const uint ucs4) + { + uint cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // joining(uint) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QChar::Joining cppResult = Katie::QChar::Joining(::Katie::QChar::joining(cppArg0)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QCHAR_JOINING_IDX])->converter, &cppResult); + } + break; + } + case 2: // joining(const ushort ucs2) + { + ::ushort cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // joining(ushort) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QChar::Joining cppResult = Katie::QChar::Joining(::Katie::QChar::joining(cppArg0)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QCHAR_JOINING_IDX])->converter, &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QCharFunc_joining_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QChar.joining"); + return {}; +} + +static PyObject* Sbk_Katie_QCharFunc_lowSurrogate(PyObject* self, PyObject* pyArg) +{ + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: static QChar::lowSurrogate(uint) + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // lowSurrogate(uint) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCharFunc_lowSurrogate_TypeError; + + // Call function/method + { + uint cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // lowSurrogate(uint) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + ushort cppResult = ::Katie::QChar::lowSurrogate(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QCharFunc_lowSurrogate_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QChar.lowSurrogate"); + return {}; +} + +static PyObject* Sbk_Katie_QCharFunc_mirroredChar(PyObject* self, PyObject* args) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (self) { + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + } + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "mirroredChar", 0, 1, &(pyArgs[0]))) + return {}; + + + // Overloaded function decisor + // 0: QChar::mirroredChar()const + // 1: static QChar::mirroredChar(uint) + // 2: static QChar::mirroredChar(ushort) + if (numArgs == 0) { + overloadId = 0; // mirroredChar()const + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 2; // mirroredChar(ushort) + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 1; // mirroredChar(uint) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCharFunc_mirroredChar_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // mirroredChar() const + { + + if (!PyErr_Occurred()) { + // mirroredChar()const + Katie::QChar* cppResult = new Katie::QChar(const_cast(cppSelf)->mirroredChar()); + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), cppResult, true, true); + } + break; + } + case 1: // mirroredChar(const uint ucs4) + { + uint cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // mirroredChar(uint) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + uint cppResult = ::Katie::QChar::mirroredChar(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 2: // mirroredChar(const ushort ucs2) + { + ::ushort cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // mirroredChar(ushort) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + ushort cppResult = ::Katie::QChar::mirroredChar(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QCharFunc_mirroredChar_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QChar.mirroredChar"); + return {}; +} + +static PyObject* Sbk_Katie_QCharFunc_requiresSurrogates(PyObject* self, PyObject* pyArg) +{ + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: static QChar::requiresSurrogates(uint) + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // requiresSurrogates(uint) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCharFunc_requiresSurrogates_TypeError; + + // Call function/method + { + uint cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // requiresSurrogates(uint) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + bool cppResult = ::Katie::QChar::requiresSurrogates(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QCharFunc_requiresSurrogates_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QChar.requiresSurrogates"); + return {}; +} + +static PyObject* Sbk_Katie_QCharFunc_row(PyObject* self) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // row()const + uchar cppResult = const_cast(cppSelf)->row(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QCharFunc_setCell(PyObject* self, PyObject* pyArg) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QChar::setCell(uchar) + if (SbkChar_Check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // setCell(uchar) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCharFunc_setCell_TypeError; + + // Call function/method + { + uchar cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // setCell(uchar) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cppSelf->setCell(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; + + Sbk_Katie_QCharFunc_setCell_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QChar.setCell"); + return {}; +} + +static PyObject* Sbk_Katie_QCharFunc_setRow(PyObject* self, PyObject* pyArg) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QChar::setRow(uchar) + if (SbkChar_Check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // setRow(uchar) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCharFunc_setRow_TypeError; + + // Call function/method + { + uchar cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // setRow(uchar) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cppSelf->setRow(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; + + Sbk_Katie_QCharFunc_setRow_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QChar.setRow"); + return {}; +} + +static PyObject* Sbk_Katie_QCharFunc_surrogateToUcs4(PyObject* self, PyObject* args) +{ + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "surrogateToUcs4", 2, 2, &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: static QChar::surrogateToUcs4(Katie::QChar,Katie::QChar) + // 1: static QChar::surrogateToUcs4(ushort,ushort) + if (numArgs == 2 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0]))) + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 1; // surrogateToUcs4(ushort,ushort) + } else if (numArgs == 2 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppValueConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[0]))) + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppValueConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[1])))) { + overloadId = 0; // surrogateToUcs4(Katie::QChar,Katie::QChar) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCharFunc_surrogateToUcs4_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // surrogateToUcs4(Katie::QChar high, Katie::QChar low) + { + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QChar* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + if (!Shiboken::Object::isValid(pyArgs[1])) + return {}; + ::Katie::QChar* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // surrogateToUcs4(Katie::QChar,Katie::QChar) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + uint cppResult = ::Katie::QChar::surrogateToUcs4(*cppArg0, *cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 1: // surrogateToUcs4(ushort high, ushort low) + { + ::ushort cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + ::ushort cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // surrogateToUcs4(ushort,ushort) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + uint cppResult = ::Katie::QChar::surrogateToUcs4(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QCharFunc_surrogateToUcs4_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QChar.surrogateToUcs4"); + return {}; +} + +static PyObject* Sbk_Katie_QCharFunc_toAscii(PyObject* self) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // toAscii()const + char cppResult = const_cast(cppSelf)->toAscii(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QCharFunc_toCaseFolded(PyObject* self, PyObject* args) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (self) { + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + } + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "toCaseFolded", 0, 1, &(pyArgs[0]))) + return {}; + + + // Overloaded function decisor + // 0: QChar::toCaseFolded()const + // 1: static QChar::toCaseFolded(uint) + // 2: static QChar::toCaseFolded(ushort) + if (numArgs == 0) { + overloadId = 0; // toCaseFolded()const + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 2; // toCaseFolded(ushort) + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 1; // toCaseFolded(uint) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCharFunc_toCaseFolded_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // toCaseFolded() const + { + + if (!PyErr_Occurred()) { + // toCaseFolded()const + Katie::QChar* cppResult = new Katie::QChar(const_cast(cppSelf)->toCaseFolded()); + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), cppResult, true, true); + } + break; + } + case 1: // toCaseFolded(const uint ucs4) + { + uint cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // toCaseFolded(uint) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + uint cppResult = ::Katie::QChar::toCaseFolded(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 2: // toCaseFolded(const ushort ucs2) + { + ::ushort cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // toCaseFolded(ushort) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + ushort cppResult = ::Katie::QChar::toCaseFolded(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QCharFunc_toCaseFolded_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QChar.toCaseFolded"); + return {}; +} + +static PyObject* Sbk_Katie_QCharFunc_toLatin1(PyObject* self) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // toLatin1()const + char cppResult = const_cast(cppSelf)->toLatin1(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QCharFunc_toLower(PyObject* self, PyObject* args) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (self) { + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + } + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "toLower", 0, 1, &(pyArgs[0]))) + return {}; + + + // Overloaded function decisor + // 0: QChar::toLower()const + // 1: static QChar::toLower(uint) + // 2: static QChar::toLower(ushort) + if (numArgs == 0) { + overloadId = 0; // toLower()const + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 2; // toLower(ushort) + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 1; // toLower(uint) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCharFunc_toLower_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // toLower() const + { + + if (!PyErr_Occurred()) { + // toLower()const + Katie::QChar* cppResult = new Katie::QChar(const_cast(cppSelf)->toLower()); + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), cppResult, true, true); + } + break; + } + case 1: // toLower(const uint ucs4) + { + uint cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // toLower(uint) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + uint cppResult = ::Katie::QChar::toLower(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 2: // toLower(const ushort ucs2) + { + ::ushort cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // toLower(ushort) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + ushort cppResult = ::Katie::QChar::toLower(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QCharFunc_toLower_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QChar.toLower"); + return {}; +} + +static PyObject* Sbk_Katie_QCharFunc_toTitleCase(PyObject* self, PyObject* args) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (self) { + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + } + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "toTitleCase", 0, 1, &(pyArgs[0]))) + return {}; + + + // Overloaded function decisor + // 0: QChar::toTitleCase()const + // 1: static QChar::toTitleCase(uint) + // 2: static QChar::toTitleCase(ushort) + if (numArgs == 0) { + overloadId = 0; // toTitleCase()const + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 2; // toTitleCase(ushort) + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 1; // toTitleCase(uint) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCharFunc_toTitleCase_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // toTitleCase() const + { + + if (!PyErr_Occurred()) { + // toTitleCase()const + Katie::QChar* cppResult = new Katie::QChar(const_cast(cppSelf)->toTitleCase()); + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), cppResult, true, true); + } + break; + } + case 1: // toTitleCase(const uint ucs4) + { + uint cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // toTitleCase(uint) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + uint cppResult = ::Katie::QChar::toTitleCase(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 2: // toTitleCase(const ushort ucs2) + { + ::ushort cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // toTitleCase(ushort) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + ushort cppResult = ::Katie::QChar::toTitleCase(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QCharFunc_toTitleCase_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QChar.toTitleCase"); + return {}; +} + +static PyObject* Sbk_Katie_QCharFunc_toUpper(PyObject* self, PyObject* args) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (self) { + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + } + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "toUpper", 0, 1, &(pyArgs[0]))) + return {}; + + + // Overloaded function decisor + // 0: QChar::toUpper()const + // 1: static QChar::toUpper(uint) + // 2: static QChar::toUpper(ushort) + if (numArgs == 0) { + overloadId = 0; // toUpper()const + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 2; // toUpper(ushort) + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 1; // toUpper(uint) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCharFunc_toUpper_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // toUpper() const + { + + if (!PyErr_Occurred()) { + // toUpper()const + Katie::QChar* cppResult = new Katie::QChar(const_cast(cppSelf)->toUpper()); + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), cppResult, true, true); + } + break; + } + case 1: // toUpper(const uint ucs4) + { + uint cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // toUpper(uint) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + uint cppResult = ::Katie::QChar::toUpper(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 2: // toUpper(const ushort ucs2) + { + ::ushort cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // toUpper(ushort) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + ushort cppResult = ::Katie::QChar::toUpper(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QCharFunc_toUpper_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QChar.toUpper"); + return {}; +} + +static PyObject* Sbk_Katie_QCharFunc_unicode(PyObject* self) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // unicode() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + ushort & cppResult = cppSelf->unicode(); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QCharFunc_unicodeVersion(PyObject* self, PyObject* args) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (self) { + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + } + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "unicodeVersion", 0, 1, &(pyArgs[0]))) + return {}; + + + // Overloaded function decisor + // 0: QChar::unicodeVersion()const + // 1: static QChar::unicodeVersion(uint) + // 2: static QChar::unicodeVersion(ushort) + if (numArgs == 0) { + overloadId = 0; // unicodeVersion()const + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 2; // unicodeVersion(ushort) + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 1; // unicodeVersion(uint) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCharFunc_unicodeVersion_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // unicodeVersion() const + { + + if (!PyErr_Occurred()) { + // unicodeVersion()const + Katie::QChar::UnicodeVersion cppResult = Katie::QChar::UnicodeVersion(const_cast(cppSelf)->unicodeVersion()); + pyResult = Shiboken::Conversions::copyToPython(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QCHAR_UNICODEVERSION_IDX])->converter, &cppResult); + } + break; + } + case 1: // unicodeVersion(const uint ucs4) + { + uint cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // unicodeVersion(uint) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QChar::UnicodeVersion cppResult = Katie::QChar::UnicodeVersion(::Katie::QChar::unicodeVersion(cppArg0)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QCHAR_UNICODEVERSION_IDX])->converter, &cppResult); + } + break; + } + case 2: // unicodeVersion(const ushort ucs2) + { + ::ushort cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // unicodeVersion(ushort) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QChar::UnicodeVersion cppResult = Katie::QChar::UnicodeVersion(::Katie::QChar::unicodeVersion(cppArg0)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QCHAR_UNICODEVERSION_IDX])->converter, &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QCharFunc_unicodeVersion_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QChar.unicodeVersion"); + return {}; +} + +static PyMethodDef Sbk_Katie_QCharMethod_category = { + "category", reinterpret_cast(Sbk_Katie_QCharFunc_category), METH_VARARGS|METH_STATIC +}; + +static PyMethodDef Sbk_Katie_QCharMethod_combiningClass = { + "combiningClass", reinterpret_cast(Sbk_Katie_QCharFunc_combiningClass), METH_VARARGS|METH_STATIC +}; + +static PyMethodDef Sbk_Katie_QCharMethod_decomposition = { + "decomposition", reinterpret_cast(Sbk_Katie_QCharFunc_decomposition), METH_VARARGS|METH_STATIC +}; + +static PyMethodDef Sbk_Katie_QCharMethod_decompositionTag = { + "decompositionTag", reinterpret_cast(Sbk_Katie_QCharFunc_decompositionTag), METH_VARARGS|METH_STATIC +}; + +static PyMethodDef Sbk_Katie_QCharMethod_digitValue = { + "digitValue", reinterpret_cast(Sbk_Katie_QCharFunc_digitValue), METH_VARARGS|METH_STATIC +}; + +static PyMethodDef Sbk_Katie_QCharMethod_direction = { + "direction", reinterpret_cast(Sbk_Katie_QCharFunc_direction), METH_VARARGS|METH_STATIC +}; + +static PyMethodDef Sbk_Katie_QCharMethod_isHighSurrogate = { + "isHighSurrogate", reinterpret_cast(Sbk_Katie_QCharFunc_isHighSurrogate), METH_VARARGS|METH_STATIC +}; + +static PyMethodDef Sbk_Katie_QCharMethod_isLowSurrogate = { + "isLowSurrogate", reinterpret_cast(Sbk_Katie_QCharFunc_isLowSurrogate), METH_VARARGS|METH_STATIC +}; + +static PyMethodDef Sbk_Katie_QCharMethod_joining = { + "joining", reinterpret_cast(Sbk_Katie_QCharFunc_joining), METH_VARARGS|METH_STATIC +}; + +static PyMethodDef Sbk_Katie_QCharMethod_mirroredChar = { + "mirroredChar", reinterpret_cast(Sbk_Katie_QCharFunc_mirroredChar), METH_VARARGS|METH_STATIC +}; + +static PyMethodDef Sbk_Katie_QCharMethod_toCaseFolded = { + "toCaseFolded", reinterpret_cast(Sbk_Katie_QCharFunc_toCaseFolded), METH_VARARGS|METH_STATIC +}; + +static PyMethodDef Sbk_Katie_QCharMethod_toLower = { + "toLower", reinterpret_cast(Sbk_Katie_QCharFunc_toLower), METH_VARARGS|METH_STATIC +}; + +static PyMethodDef Sbk_Katie_QCharMethod_toTitleCase = { + "toTitleCase", reinterpret_cast(Sbk_Katie_QCharFunc_toTitleCase), METH_VARARGS|METH_STATIC +}; + +static PyMethodDef Sbk_Katie_QCharMethod_toUpper = { + "toUpper", reinterpret_cast(Sbk_Katie_QCharFunc_toUpper), METH_VARARGS|METH_STATIC +}; + +static PyMethodDef Sbk_Katie_QCharMethod_unicodeVersion = { + "unicodeVersion", reinterpret_cast(Sbk_Katie_QCharFunc_unicodeVersion), METH_VARARGS|METH_STATIC +}; + +static PyMethodDef Sbk_Katie_QChar_methods[] = { + Sbk_Katie_QCharMethod_category, + {"cell", reinterpret_cast(Sbk_Katie_QCharFunc_cell), METH_NOARGS}, + Sbk_Katie_QCharMethod_combiningClass, + {"currentUnicodeVersion", reinterpret_cast(Sbk_Katie_QCharFunc_currentUnicodeVersion), METH_NOARGS|METH_STATIC}, + Sbk_Katie_QCharMethod_decomposition, + Sbk_Katie_QCharMethod_decompositionTag, + Sbk_Katie_QCharMethod_digitValue, + Sbk_Katie_QCharMethod_direction, + {"fromAscii", reinterpret_cast(Sbk_Katie_QCharFunc_fromAscii), METH_O|METH_STATIC}, + {"fromLatin1", reinterpret_cast(Sbk_Katie_QCharFunc_fromLatin1), METH_O|METH_STATIC}, + {"hasMirrored", reinterpret_cast(Sbk_Katie_QCharFunc_hasMirrored), METH_NOARGS}, + {"highSurrogate", reinterpret_cast(Sbk_Katie_QCharFunc_highSurrogate), METH_O|METH_STATIC}, + {"isDigit", reinterpret_cast(Sbk_Katie_QCharFunc_isDigit), METH_NOARGS}, + Sbk_Katie_QCharMethod_isHighSurrogate, + {"isLetter", reinterpret_cast(Sbk_Katie_QCharFunc_isLetter), METH_NOARGS}, + {"isLetterOrNumber", reinterpret_cast(Sbk_Katie_QCharFunc_isLetterOrNumber), METH_NOARGS}, + Sbk_Katie_QCharMethod_isLowSurrogate, + {"isLower", reinterpret_cast(Sbk_Katie_QCharFunc_isLower), METH_NOARGS}, + {"isMark", reinterpret_cast(Sbk_Katie_QCharFunc_isMark), METH_NOARGS}, + {"isNull", reinterpret_cast(Sbk_Katie_QCharFunc_isNull), METH_NOARGS}, + {"isNumber", reinterpret_cast(Sbk_Katie_QCharFunc_isNumber), METH_NOARGS}, + {"isPrint", reinterpret_cast(Sbk_Katie_QCharFunc_isPrint), METH_NOARGS}, + {"isPunct", reinterpret_cast(Sbk_Katie_QCharFunc_isPunct), METH_NOARGS}, + {"isSpace", reinterpret_cast(Sbk_Katie_QCharFunc_isSpace), METH_NOARGS}, + {"isSymbol", reinterpret_cast(Sbk_Katie_QCharFunc_isSymbol), METH_NOARGS}, + {"isTitleCase", reinterpret_cast(Sbk_Katie_QCharFunc_isTitleCase), METH_NOARGS}, + {"isUpper", reinterpret_cast(Sbk_Katie_QCharFunc_isUpper), METH_NOARGS}, + Sbk_Katie_QCharMethod_joining, + {"lowSurrogate", reinterpret_cast(Sbk_Katie_QCharFunc_lowSurrogate), METH_O|METH_STATIC}, + Sbk_Katie_QCharMethod_mirroredChar, + {"requiresSurrogates", reinterpret_cast(Sbk_Katie_QCharFunc_requiresSurrogates), METH_O|METH_STATIC}, + {"row", reinterpret_cast(Sbk_Katie_QCharFunc_row), METH_NOARGS}, + {"setCell", reinterpret_cast(Sbk_Katie_QCharFunc_setCell), METH_O}, + {"setRow", reinterpret_cast(Sbk_Katie_QCharFunc_setRow), METH_O}, + {"surrogateToUcs4", reinterpret_cast(Sbk_Katie_QCharFunc_surrogateToUcs4), METH_VARARGS|METH_STATIC}, + {"toAscii", reinterpret_cast(Sbk_Katie_QCharFunc_toAscii), METH_NOARGS}, + Sbk_Katie_QCharMethod_toCaseFolded, + {"toLatin1", reinterpret_cast(Sbk_Katie_QCharFunc_toLatin1), METH_NOARGS}, + Sbk_Katie_QCharMethod_toLower, + Sbk_Katie_QCharMethod_toTitleCase, + Sbk_Katie_QCharMethod_toUpper, + {"unicode", reinterpret_cast(Sbk_Katie_QCharFunc_unicode), METH_NOARGS}, + Sbk_Katie_QCharMethod_unicodeVersion, + + {nullptr, nullptr} // Sentinel +}; + +static PyObject* Sbk_Katie_QChar_getattro(PyObject* self, PyObject* name) +{ + if (self) { + // Search the method in the instance dict + if (reinterpret_cast(self)->ob_dict) { + PyObject* meth = PyDict_GetItem(reinterpret_cast(self)->ob_dict, name); + if (meth) { + Py_INCREF(meth); + return meth; + } + } + // Search the method in the type dict + if (Shiboken::Object::isUserType(self)) { + Shiboken::AutoDecRef tmp(_Pep_PrivateMangle(self, name)); + PyObject *meth = PyDict_GetItem(Py_TYPE(self)->tp_dict, tmp); + if (meth) + return PyFunction_Check(meth) ? SBK_PyMethod_New(meth, self) : PyObject_GenericGetAttr(self, name); + } + static PyMethodDef non_static_Sbk_Katie_QCharMethod_category = { + Sbk_Katie_QCharMethod_category.ml_name, + Sbk_Katie_QCharMethod_category.ml_meth, + Sbk_Katie_QCharMethod_category.ml_flags & (~METH_STATIC), + Sbk_Katie_QCharMethod_category.ml_doc, + }; + if (Shiboken::String::compare(name, "category") == 0) + return PyCFunction_NewEx(&non_static_Sbk_Katie_QCharMethod_category, self, 0); + static PyMethodDef non_static_Sbk_Katie_QCharMethod_combiningClass = { + Sbk_Katie_QCharMethod_combiningClass.ml_name, + Sbk_Katie_QCharMethod_combiningClass.ml_meth, + Sbk_Katie_QCharMethod_combiningClass.ml_flags & (~METH_STATIC), + Sbk_Katie_QCharMethod_combiningClass.ml_doc, + }; + if (Shiboken::String::compare(name, "combiningClass") == 0) + return PyCFunction_NewEx(&non_static_Sbk_Katie_QCharMethod_combiningClass, self, 0); + static PyMethodDef non_static_Sbk_Katie_QCharMethod_decomposition = { + Sbk_Katie_QCharMethod_decomposition.ml_name, + Sbk_Katie_QCharMethod_decomposition.ml_meth, + Sbk_Katie_QCharMethod_decomposition.ml_flags & (~METH_STATIC), + Sbk_Katie_QCharMethod_decomposition.ml_doc, + }; + if (Shiboken::String::compare(name, "decomposition") == 0) + return PyCFunction_NewEx(&non_static_Sbk_Katie_QCharMethod_decomposition, self, 0); + static PyMethodDef non_static_Sbk_Katie_QCharMethod_decompositionTag = { + Sbk_Katie_QCharMethod_decompositionTag.ml_name, + Sbk_Katie_QCharMethod_decompositionTag.ml_meth, + Sbk_Katie_QCharMethod_decompositionTag.ml_flags & (~METH_STATIC), + Sbk_Katie_QCharMethod_decompositionTag.ml_doc, + }; + if (Shiboken::String::compare(name, "decompositionTag") == 0) + return PyCFunction_NewEx(&non_static_Sbk_Katie_QCharMethod_decompositionTag, self, 0); + static PyMethodDef non_static_Sbk_Katie_QCharMethod_digitValue = { + Sbk_Katie_QCharMethod_digitValue.ml_name, + Sbk_Katie_QCharMethod_digitValue.ml_meth, + Sbk_Katie_QCharMethod_digitValue.ml_flags & (~METH_STATIC), + Sbk_Katie_QCharMethod_digitValue.ml_doc, + }; + if (Shiboken::String::compare(name, "digitValue") == 0) + return PyCFunction_NewEx(&non_static_Sbk_Katie_QCharMethod_digitValue, self, 0); + static PyMethodDef non_static_Sbk_Katie_QCharMethod_direction = { + Sbk_Katie_QCharMethod_direction.ml_name, + Sbk_Katie_QCharMethod_direction.ml_meth, + Sbk_Katie_QCharMethod_direction.ml_flags & (~METH_STATIC), + Sbk_Katie_QCharMethod_direction.ml_doc, + }; + if (Shiboken::String::compare(name, "direction") == 0) + return PyCFunction_NewEx(&non_static_Sbk_Katie_QCharMethod_direction, self, 0); + static PyMethodDef non_static_Sbk_Katie_QCharMethod_isHighSurrogate = { + Sbk_Katie_QCharMethod_isHighSurrogate.ml_name, + Sbk_Katie_QCharMethod_isHighSurrogate.ml_meth, + Sbk_Katie_QCharMethod_isHighSurrogate.ml_flags & (~METH_STATIC), + Sbk_Katie_QCharMethod_isHighSurrogate.ml_doc, + }; + if (Shiboken::String::compare(name, "isHighSurrogate") == 0) + return PyCFunction_NewEx(&non_static_Sbk_Katie_QCharMethod_isHighSurrogate, self, 0); + static PyMethodDef non_static_Sbk_Katie_QCharMethod_isLowSurrogate = { + Sbk_Katie_QCharMethod_isLowSurrogate.ml_name, + Sbk_Katie_QCharMethod_isLowSurrogate.ml_meth, + Sbk_Katie_QCharMethod_isLowSurrogate.ml_flags & (~METH_STATIC), + Sbk_Katie_QCharMethod_isLowSurrogate.ml_doc, + }; + if (Shiboken::String::compare(name, "isLowSurrogate") == 0) + return PyCFunction_NewEx(&non_static_Sbk_Katie_QCharMethod_isLowSurrogate, self, 0); + static PyMethodDef non_static_Sbk_Katie_QCharMethod_joining = { + Sbk_Katie_QCharMethod_joining.ml_name, + Sbk_Katie_QCharMethod_joining.ml_meth, + Sbk_Katie_QCharMethod_joining.ml_flags & (~METH_STATIC), + Sbk_Katie_QCharMethod_joining.ml_doc, + }; + if (Shiboken::String::compare(name, "joining") == 0) + return PyCFunction_NewEx(&non_static_Sbk_Katie_QCharMethod_joining, self, 0); + static PyMethodDef non_static_Sbk_Katie_QCharMethod_mirroredChar = { + Sbk_Katie_QCharMethod_mirroredChar.ml_name, + Sbk_Katie_QCharMethod_mirroredChar.ml_meth, + Sbk_Katie_QCharMethod_mirroredChar.ml_flags & (~METH_STATIC), + Sbk_Katie_QCharMethod_mirroredChar.ml_doc, + }; + if (Shiboken::String::compare(name, "mirroredChar") == 0) + return PyCFunction_NewEx(&non_static_Sbk_Katie_QCharMethod_mirroredChar, self, 0); + static PyMethodDef non_static_Sbk_Katie_QCharMethod_toCaseFolded = { + Sbk_Katie_QCharMethod_toCaseFolded.ml_name, + Sbk_Katie_QCharMethod_toCaseFolded.ml_meth, + Sbk_Katie_QCharMethod_toCaseFolded.ml_flags & (~METH_STATIC), + Sbk_Katie_QCharMethod_toCaseFolded.ml_doc, + }; + if (Shiboken::String::compare(name, "toCaseFolded") == 0) + return PyCFunction_NewEx(&non_static_Sbk_Katie_QCharMethod_toCaseFolded, self, 0); + static PyMethodDef non_static_Sbk_Katie_QCharMethod_toLower = { + Sbk_Katie_QCharMethod_toLower.ml_name, + Sbk_Katie_QCharMethod_toLower.ml_meth, + Sbk_Katie_QCharMethod_toLower.ml_flags & (~METH_STATIC), + Sbk_Katie_QCharMethod_toLower.ml_doc, + }; + if (Shiboken::String::compare(name, "toLower") == 0) + return PyCFunction_NewEx(&non_static_Sbk_Katie_QCharMethod_toLower, self, 0); + static PyMethodDef non_static_Sbk_Katie_QCharMethod_toTitleCase = { + Sbk_Katie_QCharMethod_toTitleCase.ml_name, + Sbk_Katie_QCharMethod_toTitleCase.ml_meth, + Sbk_Katie_QCharMethod_toTitleCase.ml_flags & (~METH_STATIC), + Sbk_Katie_QCharMethod_toTitleCase.ml_doc, + }; + if (Shiboken::String::compare(name, "toTitleCase") == 0) + return PyCFunction_NewEx(&non_static_Sbk_Katie_QCharMethod_toTitleCase, self, 0); + static PyMethodDef non_static_Sbk_Katie_QCharMethod_toUpper = { + Sbk_Katie_QCharMethod_toUpper.ml_name, + Sbk_Katie_QCharMethod_toUpper.ml_meth, + Sbk_Katie_QCharMethod_toUpper.ml_flags & (~METH_STATIC), + Sbk_Katie_QCharMethod_toUpper.ml_doc, + }; + if (Shiboken::String::compare(name, "toUpper") == 0) + return PyCFunction_NewEx(&non_static_Sbk_Katie_QCharMethod_toUpper, self, 0); + static PyMethodDef non_static_Sbk_Katie_QCharMethod_unicodeVersion = { + Sbk_Katie_QCharMethod_unicodeVersion.ml_name, + Sbk_Katie_QCharMethod_unicodeVersion.ml_meth, + Sbk_Katie_QCharMethod_unicodeVersion.ml_flags & (~METH_STATIC), + Sbk_Katie_QCharMethod_unicodeVersion.ml_doc, + }; + if (Shiboken::String::compare(name, "unicodeVersion") == 0) + return PyCFunction_NewEx(&non_static_Sbk_Katie_QCharMethod_unicodeVersion, self, 0); + } + return PyObject_GenericGetAttr(self, name); +} + +static int Sbk_Katie_QChar___nb_bool(PyObject* self) +{ + ::Katie::QChar* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return -1; + cppSelf = reinterpret_cast< ::Katie::QChar *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX], reinterpret_cast(self))); + return !cppSelf->isNull(); +} + +} // extern "C" + +static int Sbk_Katie_QChar_traverse(PyObject* self, visitproc visit, void* arg) +{ + return reinterpret_cast(SbkObject_TypeF())->tp_traverse(self, visit, arg); +} +static int Sbk_Katie_QChar_clear(PyObject* self) +{ + return reinterpret_cast(SbkObject_TypeF())->tp_clear(self); +} +// Class Definition ----------------------------------------------- +extern "C" { +static SbkObjectType *_Sbk_Katie_QChar_Type = nullptr; +static SbkObjectType *Sbk_Katie_QChar_TypeF(void) +{ + return _Sbk_Katie_QChar_Type; +} + +static PyType_Slot Sbk_Katie_QChar_slots[] = { + {Py_tp_base, nullptr}, // inserted by introduceWrapperType + {Py_tp_dealloc, reinterpret_cast(&SbkDeallocWrapper)}, + {Py_tp_repr, nullptr}, + {Py_tp_hash, nullptr}, + {Py_tp_call, nullptr}, + {Py_tp_str, nullptr}, + {Py_tp_getattro, reinterpret_cast(Sbk_Katie_QChar_getattro)}, + {Py_tp_setattro, nullptr}, + {Py_tp_traverse, reinterpret_cast(Sbk_Katie_QChar_traverse)}, + {Py_tp_clear, reinterpret_cast(Sbk_Katie_QChar_clear)}, + {Py_tp_richcompare, nullptr}, + {Py_tp_iter, nullptr}, + {Py_tp_iternext, nullptr}, + {Py_tp_methods, reinterpret_cast(Sbk_Katie_QChar_methods)}, + {Py_tp_getset, nullptr}, + {Py_tp_init, reinterpret_cast(Sbk_Katie_QChar_Init)}, + {Py_tp_new, reinterpret_cast(SbkObjectTpNew)}, + // type supports number protocol +#ifdef IS_PY3K + {Py_nb_bool, (void *)Sbk_Katie_QChar___nb_bool}, +#else + {Py_nb_nonzero, (void *)Sbk_Katie_QChar___nb_bool}, +#endif + {0, nullptr} +}; +static PyType_Spec Sbk_Katie_QChar_spec = { + "KtCore.Katie.QChar", + sizeof(SbkObject), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_GC, + Sbk_Katie_QChar_slots +}; + +} //extern "C" + + +// Type conversion functions. + +// Python to C++ enum conversion. +static void Katie_QChar_SpecialCharacter_PythonToCpp_Katie_QChar_SpecialCharacter(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::QChar::SpecialCharacter*>(cppOut) = + static_cast<::Katie::QChar::SpecialCharacter>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_QChar_SpecialCharacter_PythonToCpp_Katie_QChar_SpecialCharacter_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QCHAR_SPECIALCHARACTER_IDX])) + return Katie_QChar_SpecialCharacter_PythonToCpp_Katie_QChar_SpecialCharacter; + return {}; +} +static PyObject* Katie_QChar_SpecialCharacter_CppToPython_Katie_QChar_SpecialCharacter(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_SPECIALCHARACTER_IDX], castCppIn); + +} + +static void Katie_QChar_Category_PythonToCpp_Katie_QChar_Category(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::QChar::Category*>(cppOut) = + static_cast<::Katie::QChar::Category>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_QChar_Category_PythonToCpp_Katie_QChar_Category_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX])) + return Katie_QChar_Category_PythonToCpp_Katie_QChar_Category; + return {}; +} +static PyObject* Katie_QChar_Category_CppToPython_Katie_QChar_Category(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX], castCppIn); + +} + +static void Katie_QChar_Direction_PythonToCpp_Katie_QChar_Direction(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::QChar::Direction*>(cppOut) = + static_cast<::Katie::QChar::Direction>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_QChar_Direction_PythonToCpp_Katie_QChar_Direction_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QCHAR_DIRECTION_IDX])) + return Katie_QChar_Direction_PythonToCpp_Katie_QChar_Direction; + return {}; +} +static PyObject* Katie_QChar_Direction_CppToPython_Katie_QChar_Direction(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DIRECTION_IDX], castCppIn); + +} + +static void Katie_QChar_Decomposition_PythonToCpp_Katie_QChar_Decomposition(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::QChar::Decomposition*>(cppOut) = + static_cast<::Katie::QChar::Decomposition>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_QChar_Decomposition_PythonToCpp_Katie_QChar_Decomposition_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QCHAR_DECOMPOSITION_IDX])) + return Katie_QChar_Decomposition_PythonToCpp_Katie_QChar_Decomposition; + return {}; +} +static PyObject* Katie_QChar_Decomposition_CppToPython_Katie_QChar_Decomposition(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DECOMPOSITION_IDX], castCppIn); + +} + +static void Katie_QChar_Joining_PythonToCpp_Katie_QChar_Joining(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::QChar::Joining*>(cppOut) = + static_cast<::Katie::QChar::Joining>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_QChar_Joining_PythonToCpp_Katie_QChar_Joining_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QCHAR_JOINING_IDX])) + return Katie_QChar_Joining_PythonToCpp_Katie_QChar_Joining; + return {}; +} +static PyObject* Katie_QChar_Joining_CppToPython_Katie_QChar_Joining(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_JOINING_IDX], castCppIn); + +} + +static void Katie_QChar_CombiningClass_PythonToCpp_Katie_QChar_CombiningClass(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::QChar::CombiningClass*>(cppOut) = + static_cast<::Katie::QChar::CombiningClass>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_QChar_CombiningClass_PythonToCpp_Katie_QChar_CombiningClass_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QCHAR_COMBININGCLASS_IDX])) + return Katie_QChar_CombiningClass_PythonToCpp_Katie_QChar_CombiningClass; + return {}; +} +static PyObject* Katie_QChar_CombiningClass_CppToPython_Katie_QChar_CombiningClass(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_COMBININGCLASS_IDX], castCppIn); + +} + +static void Katie_QChar_UnicodeVersion_PythonToCpp_Katie_QChar_UnicodeVersion(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::QChar::UnicodeVersion*>(cppOut) = + static_cast<::Katie::QChar::UnicodeVersion>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_QChar_UnicodeVersion_PythonToCpp_Katie_QChar_UnicodeVersion_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QCHAR_UNICODEVERSION_IDX])) + return Katie_QChar_UnicodeVersion_PythonToCpp_Katie_QChar_UnicodeVersion; + return {}; +} +static PyObject* Katie_QChar_UnicodeVersion_CppToPython_Katie_QChar_UnicodeVersion(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_UNICODEVERSION_IDX], castCppIn); + +} + +// Python to C++ pointer conversion - returns the C++ object of the Python wrapper (keeps object identity). +static void QChar_PythonToCpp_QChar_PTR(PyObject* pyIn, void* cppOut) { + Shiboken::Conversions::pythonToCppPointer(Sbk_Katie_QChar_TypeF(), pyIn, cppOut); +} +static PythonToCppFunc is_QChar_PythonToCpp_QChar_PTR_Convertible(PyObject* pyIn) { + if (pyIn == Py_None) + return Shiboken::Conversions::nonePythonToCppNullPtr; + if (PyObject_TypeCheck(pyIn, reinterpret_cast(Sbk_Katie_QChar_TypeF()))) + return QChar_PythonToCpp_QChar_PTR; + return {}; +} + +// C++ to Python pointer conversion - tries to find the Python wrapper for the C++ object (keeps object identity). +static PyObject* QChar_PTR_CppToPython_QChar(const void* cppIn) { + auto pyOut = reinterpret_cast(Shiboken::BindingManager::instance().retrieveWrapper(cppIn)); + if (pyOut) { + Py_INCREF(pyOut); + return pyOut; + } + bool changedTypeName = false; + auto tCppIn = reinterpret_cast(cppIn); + const char *typeName = typeid(*tCppIn).name(); + auto sbkType = Shiboken::ObjectType::typeForTypeName(typeName); + if (sbkType && Shiboken::ObjectType::hasSpecialCastFunction(sbkType)) { + typeName = typeNameOf(tCppIn); + changedTypeName = true; + } + PyObject *result = Shiboken::Object::newObject(Sbk_Katie_QChar_TypeF(), const_cast(cppIn), false, /* exactType */ changedTypeName, typeName); + if (changedTypeName) + delete [] typeName; + return result; +} + +// The signatures string for the functions. +// Multiple signatures have their index "n:" in front. +static const char *Katie_QChar_SignatureStrings[] = { + "9:KtCore.Katie.QChar()", + "8:KtCore.Katie.QChar(sc:KtCore.Katie.QChar.SpecialCharacter)", + "7:KtCore.Katie.QChar(ch:KtCore.Katie.QLatin1Char)", + "6:KtCore.Katie.QChar(c:char)", + "5:KtCore.Katie.QChar(rc:int)", + "4:KtCore.Katie.QChar(rc:short)", + "3:KtCore.Katie.QChar(c:unsigned char)", + "2:KtCore.Katie.QChar(c:unsigned char,r:unsigned char)", + "1:KtCore.Katie.QChar(rc:unsigned int)", + "0:KtCore.Katie.QChar(rc:ushort)", + "2:KtCore.Katie.QChar.category()->KtCore.Katie.QChar.Category", + "1:KtCore.Katie.QChar.category(ucs4:unsigned int)->KtCore.Katie.QChar.Category", + "0:KtCore.Katie.QChar.category(ucs2:ushort)->KtCore.Katie.QChar.Category", + "KtCore.Katie.QChar.cell()->unsigned char", + "2:KtCore.Katie.QChar.combiningClass()->unsigned char", + "1:KtCore.Katie.QChar.combiningClass(ucs4:unsigned int)->unsigned char", + "0:KtCore.Katie.QChar.combiningClass(ucs2:ushort)->unsigned char", + "KtCore.Katie.QChar.currentUnicodeVersion()->KtCore.Katie.QChar.UnicodeVersion", + "1:KtCore.Katie.QChar.decomposition()->KtCore.Katie.QString", + "0:KtCore.Katie.QChar.decomposition(ucs4:unsigned int)->KtCore.Katie.QString", + "1:KtCore.Katie.QChar.decompositionTag()->KtCore.Katie.QChar.Decomposition", + "0:KtCore.Katie.QChar.decompositionTag(ucs4:unsigned int)->KtCore.Katie.QChar.Decomposition", + "2:KtCore.Katie.QChar.digitValue()->int", + "1:KtCore.Katie.QChar.digitValue(ucs4:unsigned int)->int", + "0:KtCore.Katie.QChar.digitValue(ucs2:ushort)->int", + "2:KtCore.Katie.QChar.direction()->KtCore.Katie.QChar.Direction", + "1:KtCore.Katie.QChar.direction(ucs4:unsigned int)->KtCore.Katie.QChar.Direction", + "0:KtCore.Katie.QChar.direction(ucs2:ushort)->KtCore.Katie.QChar.Direction", + "KtCore.Katie.QChar.fromAscii(c:char)->KtCore.Katie.QChar", + "KtCore.Katie.QChar.fromLatin1(c:char)->KtCore.Katie.QChar", + "KtCore.Katie.QChar.hasMirrored()->bool", + "KtCore.Katie.QChar.highSurrogate(ucs4:unsigned int)->ushort", + "KtCore.Katie.QChar.isDigit()->bool", + "1:KtCore.Katie.QChar.isHighSurrogate()->bool", + "0:KtCore.Katie.QChar.isHighSurrogate(ucs4:unsigned int)->bool", + "KtCore.Katie.QChar.isLetter()->bool", + "KtCore.Katie.QChar.isLetterOrNumber()->bool", + "1:KtCore.Katie.QChar.isLowSurrogate()->bool", + "0:KtCore.Katie.QChar.isLowSurrogate(ucs4:unsigned int)->bool", + "KtCore.Katie.QChar.isLower()->bool", + "KtCore.Katie.QChar.isMark()->bool", + "KtCore.Katie.QChar.isNull()->bool", + "KtCore.Katie.QChar.isNumber()->bool", + "KtCore.Katie.QChar.isPrint()->bool", + "KtCore.Katie.QChar.isPunct()->bool", + "KtCore.Katie.QChar.isSpace()->bool", + "KtCore.Katie.QChar.isSymbol()->bool", + "KtCore.Katie.QChar.isTitleCase()->bool", + "KtCore.Katie.QChar.isUpper()->bool", + "2:KtCore.Katie.QChar.joining()->KtCore.Katie.QChar.Joining", + "1:KtCore.Katie.QChar.joining(ucs4:unsigned int)->KtCore.Katie.QChar.Joining", + "0:KtCore.Katie.QChar.joining(ucs2:ushort)->KtCore.Katie.QChar.Joining", + "KtCore.Katie.QChar.lowSurrogate(ucs4:unsigned int)->ushort", + "2:KtCore.Katie.QChar.mirroredChar()->KtCore.Katie.QChar", + "1:KtCore.Katie.QChar.mirroredChar(ucs4:unsigned int)->unsigned int", + "0:KtCore.Katie.QChar.mirroredChar(ucs2:ushort)->ushort", + "KtCore.Katie.QChar.requiresSurrogates(ucs4:unsigned int)->bool", + "KtCore.Katie.QChar.row()->unsigned char", + "KtCore.Katie.QChar.setCell(cell:unsigned char)", + "KtCore.Katie.QChar.setRow(row:unsigned char)", + "1:KtCore.Katie.QChar.surrogateToUcs4(high:KtCore.Katie.QChar,low:KtCore.Katie.QChar)->unsigned int", + "0:KtCore.Katie.QChar.surrogateToUcs4(high:ushort,low:ushort)->unsigned int", + "KtCore.Katie.QChar.toAscii()->char", + "2:KtCore.Katie.QChar.toCaseFolded()->KtCore.Katie.QChar", + "1:KtCore.Katie.QChar.toCaseFolded(ucs4:unsigned int)->unsigned int", + "0:KtCore.Katie.QChar.toCaseFolded(ucs2:ushort)->ushort", + "KtCore.Katie.QChar.toLatin1()->char", + "2:KtCore.Katie.QChar.toLower()->KtCore.Katie.QChar", + "1:KtCore.Katie.QChar.toLower(ucs4:unsigned int)->unsigned int", + "0:KtCore.Katie.QChar.toLower(ucs2:ushort)->ushort", + "2:KtCore.Katie.QChar.toTitleCase()->KtCore.Katie.QChar", + "1:KtCore.Katie.QChar.toTitleCase(ucs4:unsigned int)->unsigned int", + "0:KtCore.Katie.QChar.toTitleCase(ucs2:ushort)->ushort", + "2:KtCore.Katie.QChar.toUpper()->KtCore.Katie.QChar", + "1:KtCore.Katie.QChar.toUpper(ucs4:unsigned int)->unsigned int", + "0:KtCore.Katie.QChar.toUpper(ucs2:ushort)->ushort", + "1:KtCore.Katie.QChar.unicode()->KtCore.ushort", + "0:KtCore.Katie.QChar.unicode()->ushort", + "2:KtCore.Katie.QChar.unicodeVersion()->KtCore.Katie.QChar.UnicodeVersion", + "1:KtCore.Katie.QChar.unicodeVersion(ucs4:unsigned int)->KtCore.Katie.QChar.UnicodeVersion", + "0:KtCore.Katie.QChar.unicodeVersion(ucs2:ushort)->KtCore.Katie.QChar.UnicodeVersion", + nullptr}; // Sentinel + +void init_Katie_QChar(PyObject* module) +{ + _Sbk_Katie_QChar_Type = Shiboken::ObjectType::introduceWrapperType( + module, + "QChar", + "Katie::QChar*", + &Sbk_Katie_QChar_spec, + Katie_QChar_SignatureStrings, + &Shiboken::callCppDestructor< ::Katie::QChar >, + 0, + 0, + 0 ); + + SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX] + = reinterpret_cast(Sbk_Katie_QChar_TypeF()); + + // Register Converter + SbkConverter* converter = Shiboken::Conversions::createConverter(Sbk_Katie_QChar_TypeF(), + QChar_PythonToCpp_QChar_PTR, + is_QChar_PythonToCpp_QChar_PTR_Convertible, + QChar_PTR_CppToPython_QChar); + + Shiboken::Conversions::registerConverterName(converter, "Katie::QChar"); + Shiboken::Conversions::registerConverterName(converter, "Katie::QChar*"); + Shiboken::Conversions::registerConverterName(converter, "Katie::QChar&"); + Shiboken::Conversions::registerConverterName(converter, "QChar"); + Shiboken::Conversions::registerConverterName(converter, "QChar*"); + Shiboken::Conversions::registerConverterName(converter, "QChar&"); + Shiboken::Conversions::registerConverterName(converter, typeid(::Katie::QChar).name()); + + + // Initialization of enums. + + // Initialization of enum 'SpecialCharacter'. + SbkKtCoreTypes[SBK_KATIE_QCHAR_SPECIALCHARACTER_IDX] = Shiboken::Enum::createScopedEnum(Sbk_Katie_QChar_TypeF(), + "SpecialCharacter", + "KtCore.Katie.QChar.SpecialCharacter", + "Katie::QChar::SpecialCharacter"); + if (!SbkKtCoreTypes[SBK_KATIE_QCHAR_SPECIALCHARACTER_IDX]) + return; + + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_SPECIALCHARACTER_IDX], + Sbk_Katie_QChar_TypeF(), "Null", (long) Katie::QChar::SpecialCharacter::Null)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_SPECIALCHARACTER_IDX], + Sbk_Katie_QChar_TypeF(), "Nbsp", (long) Katie::QChar::SpecialCharacter::Nbsp)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_SPECIALCHARACTER_IDX], + Sbk_Katie_QChar_TypeF(), "ReplacementCharacter", (long) Katie::QChar::SpecialCharacter::ReplacementCharacter)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_SPECIALCHARACTER_IDX], + Sbk_Katie_QChar_TypeF(), "ObjectReplacementCharacter", (long) Katie::QChar::SpecialCharacter::ObjectReplacementCharacter)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_SPECIALCHARACTER_IDX], + Sbk_Katie_QChar_TypeF(), "ByteOrderMark", (long) Katie::QChar::SpecialCharacter::ByteOrderMark)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_SPECIALCHARACTER_IDX], + Sbk_Katie_QChar_TypeF(), "ByteOrderSwapped", (long) Katie::QChar::SpecialCharacter::ByteOrderSwapped)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_SPECIALCHARACTER_IDX], + Sbk_Katie_QChar_TypeF(), "ParagraphSeparator", (long) Katie::QChar::SpecialCharacter::ParagraphSeparator)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_SPECIALCHARACTER_IDX], + Sbk_Katie_QChar_TypeF(), "LineSeparator", (long) Katie::QChar::SpecialCharacter::LineSeparator)) + return; + // Register converter for enum 'Katie::QChar::SpecialCharacter'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QCHAR_SPECIALCHARACTER_IDX], + Katie_QChar_SpecialCharacter_CppToPython_Katie_QChar_SpecialCharacter); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_QChar_SpecialCharacter_PythonToCpp_Katie_QChar_SpecialCharacter, + is_Katie_QChar_SpecialCharacter_PythonToCpp_Katie_QChar_SpecialCharacter_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QCHAR_SPECIALCHARACTER_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::QChar::SpecialCharacter"); + Shiboken::Conversions::registerConverterName(converter, "QChar::SpecialCharacter"); + Shiboken::Conversions::registerConverterName(converter, "SpecialCharacter"); + } + // End of 'SpecialCharacter' enum. + + // Initialization of enum 'Category'. + SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX] = Shiboken::Enum::createScopedEnum(Sbk_Katie_QChar_TypeF(), + "Category", + "KtCore.Katie.QChar.Category", + "Katie::QChar::Category"); + if (!SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX]) + return; + + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX], + Sbk_Katie_QChar_TypeF(), "NoCategory", (long) Katie::QChar::Category::NoCategory)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX], + Sbk_Katie_QChar_TypeF(), "Mark_NonSpacing", (long) Katie::QChar::Category::Mark_NonSpacing)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX], + Sbk_Katie_QChar_TypeF(), "Mark_SpacingCombining", (long) Katie::QChar::Category::Mark_SpacingCombining)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX], + Sbk_Katie_QChar_TypeF(), "Mark_Enclosing", (long) Katie::QChar::Category::Mark_Enclosing)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX], + Sbk_Katie_QChar_TypeF(), "Number_DecimalDigit", (long) Katie::QChar::Category::Number_DecimalDigit)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX], + Sbk_Katie_QChar_TypeF(), "Number_Letter", (long) Katie::QChar::Category::Number_Letter)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX], + Sbk_Katie_QChar_TypeF(), "Number_Other", (long) Katie::QChar::Category::Number_Other)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX], + Sbk_Katie_QChar_TypeF(), "Separator_Space", (long) Katie::QChar::Category::Separator_Space)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX], + Sbk_Katie_QChar_TypeF(), "Separator_Line", (long) Katie::QChar::Category::Separator_Line)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX], + Sbk_Katie_QChar_TypeF(), "Separator_Paragraph", (long) Katie::QChar::Category::Separator_Paragraph)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX], + Sbk_Katie_QChar_TypeF(), "Other_Control", (long) Katie::QChar::Category::Other_Control)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX], + Sbk_Katie_QChar_TypeF(), "Other_Format", (long) Katie::QChar::Category::Other_Format)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX], + Sbk_Katie_QChar_TypeF(), "Other_Surrogate", (long) Katie::QChar::Category::Other_Surrogate)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX], + Sbk_Katie_QChar_TypeF(), "Other_PrivateUse", (long) Katie::QChar::Category::Other_PrivateUse)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX], + Sbk_Katie_QChar_TypeF(), "Other_NotAssigned", (long) Katie::QChar::Category::Other_NotAssigned)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX], + Sbk_Katie_QChar_TypeF(), "Letter_Uppercase", (long) Katie::QChar::Category::Letter_Uppercase)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX], + Sbk_Katie_QChar_TypeF(), "Letter_Lowercase", (long) Katie::QChar::Category::Letter_Lowercase)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX], + Sbk_Katie_QChar_TypeF(), "Letter_Titlecase", (long) Katie::QChar::Category::Letter_Titlecase)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX], + Sbk_Katie_QChar_TypeF(), "Letter_Modifier", (long) Katie::QChar::Category::Letter_Modifier)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX], + Sbk_Katie_QChar_TypeF(), "Letter_Other", (long) Katie::QChar::Category::Letter_Other)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX], + Sbk_Katie_QChar_TypeF(), "Punctuation_Connector", (long) Katie::QChar::Category::Punctuation_Connector)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX], + Sbk_Katie_QChar_TypeF(), "Punctuation_Dash", (long) Katie::QChar::Category::Punctuation_Dash)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX], + Sbk_Katie_QChar_TypeF(), "Punctuation_Open", (long) Katie::QChar::Category::Punctuation_Open)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX], + Sbk_Katie_QChar_TypeF(), "Punctuation_Close", (long) Katie::QChar::Category::Punctuation_Close)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX], + Sbk_Katie_QChar_TypeF(), "Punctuation_InitialQuote", (long) Katie::QChar::Category::Punctuation_InitialQuote)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX], + Sbk_Katie_QChar_TypeF(), "Punctuation_FinalQuote", (long) Katie::QChar::Category::Punctuation_FinalQuote)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX], + Sbk_Katie_QChar_TypeF(), "Punctuation_Other", (long) Katie::QChar::Category::Punctuation_Other)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX], + Sbk_Katie_QChar_TypeF(), "Symbol_Math", (long) Katie::QChar::Category::Symbol_Math)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX], + Sbk_Katie_QChar_TypeF(), "Symbol_Currency", (long) Katie::QChar::Category::Symbol_Currency)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX], + Sbk_Katie_QChar_TypeF(), "Symbol_Modifier", (long) Katie::QChar::Category::Symbol_Modifier)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX], + Sbk_Katie_QChar_TypeF(), "Symbol_Other", (long) Katie::QChar::Category::Symbol_Other)) + return; + // Register converter for enum 'Katie::QChar::Category'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX], + Katie_QChar_Category_CppToPython_Katie_QChar_Category); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_QChar_Category_PythonToCpp_Katie_QChar_Category, + is_Katie_QChar_Category_PythonToCpp_Katie_QChar_Category_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::QChar::Category"); + Shiboken::Conversions::registerConverterName(converter, "QChar::Category"); + Shiboken::Conversions::registerConverterName(converter, "Category"); + } + // End of 'Category' enum. + + // Initialization of enum 'Direction'. + SbkKtCoreTypes[SBK_KATIE_QCHAR_DIRECTION_IDX] = Shiboken::Enum::createScopedEnum(Sbk_Katie_QChar_TypeF(), + "Direction", + "KtCore.Katie.QChar.Direction", + "Katie::QChar::Direction"); + if (!SbkKtCoreTypes[SBK_KATIE_QCHAR_DIRECTION_IDX]) + return; + + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DIRECTION_IDX], + Sbk_Katie_QChar_TypeF(), "DirL", (long) Katie::QChar::Direction::DirL)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DIRECTION_IDX], + Sbk_Katie_QChar_TypeF(), "DirR", (long) Katie::QChar::Direction::DirR)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DIRECTION_IDX], + Sbk_Katie_QChar_TypeF(), "DirEN", (long) Katie::QChar::Direction::DirEN)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DIRECTION_IDX], + Sbk_Katie_QChar_TypeF(), "DirES", (long) Katie::QChar::Direction::DirES)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DIRECTION_IDX], + Sbk_Katie_QChar_TypeF(), "DirET", (long) Katie::QChar::Direction::DirET)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DIRECTION_IDX], + Sbk_Katie_QChar_TypeF(), "DirAN", (long) Katie::QChar::Direction::DirAN)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DIRECTION_IDX], + Sbk_Katie_QChar_TypeF(), "DirCS", (long) Katie::QChar::Direction::DirCS)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DIRECTION_IDX], + Sbk_Katie_QChar_TypeF(), "DirB", (long) Katie::QChar::Direction::DirB)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DIRECTION_IDX], + Sbk_Katie_QChar_TypeF(), "DirS", (long) Katie::QChar::Direction::DirS)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DIRECTION_IDX], + Sbk_Katie_QChar_TypeF(), "DirWS", (long) Katie::QChar::Direction::DirWS)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DIRECTION_IDX], + Sbk_Katie_QChar_TypeF(), "DirON", (long) Katie::QChar::Direction::DirON)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DIRECTION_IDX], + Sbk_Katie_QChar_TypeF(), "DirLRE", (long) Katie::QChar::Direction::DirLRE)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DIRECTION_IDX], + Sbk_Katie_QChar_TypeF(), "DirLRO", (long) Katie::QChar::Direction::DirLRO)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DIRECTION_IDX], + Sbk_Katie_QChar_TypeF(), "DirAL", (long) Katie::QChar::Direction::DirAL)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DIRECTION_IDX], + Sbk_Katie_QChar_TypeF(), "DirRLE", (long) Katie::QChar::Direction::DirRLE)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DIRECTION_IDX], + Sbk_Katie_QChar_TypeF(), "DirRLO", (long) Katie::QChar::Direction::DirRLO)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DIRECTION_IDX], + Sbk_Katie_QChar_TypeF(), "DirPDF", (long) Katie::QChar::Direction::DirPDF)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DIRECTION_IDX], + Sbk_Katie_QChar_TypeF(), "DirNSM", (long) Katie::QChar::Direction::DirNSM)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DIRECTION_IDX], + Sbk_Katie_QChar_TypeF(), "DirBN", (long) Katie::QChar::Direction::DirBN)) + return; + // Register converter for enum 'Katie::QChar::Direction'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QCHAR_DIRECTION_IDX], + Katie_QChar_Direction_CppToPython_Katie_QChar_Direction); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_QChar_Direction_PythonToCpp_Katie_QChar_Direction, + is_Katie_QChar_Direction_PythonToCpp_Katie_QChar_Direction_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QCHAR_DIRECTION_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::QChar::Direction"); + Shiboken::Conversions::registerConverterName(converter, "QChar::Direction"); + Shiboken::Conversions::registerConverterName(converter, "Direction"); + } + // End of 'Direction' enum. + + // Initialization of enum 'Decomposition'. + SbkKtCoreTypes[SBK_KATIE_QCHAR_DECOMPOSITION_IDX] = Shiboken::Enum::createScopedEnum(Sbk_Katie_QChar_TypeF(), + "Decomposition", + "KtCore.Katie.QChar.Decomposition", + "Katie::QChar::Decomposition"); + if (!SbkKtCoreTypes[SBK_KATIE_QCHAR_DECOMPOSITION_IDX]) + return; + + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DECOMPOSITION_IDX], + Sbk_Katie_QChar_TypeF(), "NoDecomposition", (long) Katie::QChar::Decomposition::NoDecomposition)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DECOMPOSITION_IDX], + Sbk_Katie_QChar_TypeF(), "Canonical", (long) Katie::QChar::Decomposition::Canonical)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DECOMPOSITION_IDX], + Sbk_Katie_QChar_TypeF(), "Font", (long) Katie::QChar::Decomposition::Font)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DECOMPOSITION_IDX], + Sbk_Katie_QChar_TypeF(), "NoBreak", (long) Katie::QChar::Decomposition::NoBreak)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DECOMPOSITION_IDX], + Sbk_Katie_QChar_TypeF(), "Initial", (long) Katie::QChar::Decomposition::Initial)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DECOMPOSITION_IDX], + Sbk_Katie_QChar_TypeF(), "Medial", (long) Katie::QChar::Decomposition::Medial)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DECOMPOSITION_IDX], + Sbk_Katie_QChar_TypeF(), "Final", (long) Katie::QChar::Decomposition::Final)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DECOMPOSITION_IDX], + Sbk_Katie_QChar_TypeF(), "Isolated", (long) Katie::QChar::Decomposition::Isolated)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DECOMPOSITION_IDX], + Sbk_Katie_QChar_TypeF(), "Circle", (long) Katie::QChar::Decomposition::Circle)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DECOMPOSITION_IDX], + Sbk_Katie_QChar_TypeF(), "Super", (long) Katie::QChar::Decomposition::Super)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DECOMPOSITION_IDX], + Sbk_Katie_QChar_TypeF(), "Sub", (long) Katie::QChar::Decomposition::Sub)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DECOMPOSITION_IDX], + Sbk_Katie_QChar_TypeF(), "Vertical", (long) Katie::QChar::Decomposition::Vertical)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DECOMPOSITION_IDX], + Sbk_Katie_QChar_TypeF(), "Wide", (long) Katie::QChar::Decomposition::Wide)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DECOMPOSITION_IDX], + Sbk_Katie_QChar_TypeF(), "Narrow", (long) Katie::QChar::Decomposition::Narrow)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DECOMPOSITION_IDX], + Sbk_Katie_QChar_TypeF(), "Small", (long) Katie::QChar::Decomposition::Small)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DECOMPOSITION_IDX], + Sbk_Katie_QChar_TypeF(), "Square", (long) Katie::QChar::Decomposition::Square)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DECOMPOSITION_IDX], + Sbk_Katie_QChar_TypeF(), "Compat", (long) Katie::QChar::Decomposition::Compat)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_DECOMPOSITION_IDX], + Sbk_Katie_QChar_TypeF(), "Fraction", (long) Katie::QChar::Decomposition::Fraction)) + return; + // Register converter for enum 'Katie::QChar::Decomposition'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QCHAR_DECOMPOSITION_IDX], + Katie_QChar_Decomposition_CppToPython_Katie_QChar_Decomposition); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_QChar_Decomposition_PythonToCpp_Katie_QChar_Decomposition, + is_Katie_QChar_Decomposition_PythonToCpp_Katie_QChar_Decomposition_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QCHAR_DECOMPOSITION_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::QChar::Decomposition"); + Shiboken::Conversions::registerConverterName(converter, "QChar::Decomposition"); + Shiboken::Conversions::registerConverterName(converter, "Decomposition"); + } + // End of 'Decomposition' enum. + + // Initialization of enum 'Joining'. + SbkKtCoreTypes[SBK_KATIE_QCHAR_JOINING_IDX] = Shiboken::Enum::createScopedEnum(Sbk_Katie_QChar_TypeF(), + "Joining", + "KtCore.Katie.QChar.Joining", + "Katie::QChar::Joining"); + if (!SbkKtCoreTypes[SBK_KATIE_QCHAR_JOINING_IDX]) + return; + + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_JOINING_IDX], + Sbk_Katie_QChar_TypeF(), "OtherJoining", (long) Katie::QChar::Joining::OtherJoining)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_JOINING_IDX], + Sbk_Katie_QChar_TypeF(), "Dual", (long) Katie::QChar::Joining::Dual)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_JOINING_IDX], + Sbk_Katie_QChar_TypeF(), "Right", (long) Katie::QChar::Joining::Right)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_JOINING_IDX], + Sbk_Katie_QChar_TypeF(), "Center", (long) Katie::QChar::Joining::Center)) + return; + // Register converter for enum 'Katie::QChar::Joining'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QCHAR_JOINING_IDX], + Katie_QChar_Joining_CppToPython_Katie_QChar_Joining); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_QChar_Joining_PythonToCpp_Katie_QChar_Joining, + is_Katie_QChar_Joining_PythonToCpp_Katie_QChar_Joining_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QCHAR_JOINING_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::QChar::Joining"); + Shiboken::Conversions::registerConverterName(converter, "QChar::Joining"); + Shiboken::Conversions::registerConverterName(converter, "Joining"); + } + // End of 'Joining' enum. + + // Initialization of enum 'CombiningClass'. + SbkKtCoreTypes[SBK_KATIE_QCHAR_COMBININGCLASS_IDX] = Shiboken::Enum::createScopedEnum(Sbk_Katie_QChar_TypeF(), + "CombiningClass", + "KtCore.Katie.QChar.CombiningClass", + "Katie::QChar::CombiningClass"); + if (!SbkKtCoreTypes[SBK_KATIE_QCHAR_COMBININGCLASS_IDX]) + return; + + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_COMBININGCLASS_IDX], + Sbk_Katie_QChar_TypeF(), "Combining_BelowLeftAttached", (long) Katie::QChar::CombiningClass::Combining_BelowLeftAttached)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_COMBININGCLASS_IDX], + Sbk_Katie_QChar_TypeF(), "Combining_BelowAttached", (long) Katie::QChar::CombiningClass::Combining_BelowAttached)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_COMBININGCLASS_IDX], + Sbk_Katie_QChar_TypeF(), "Combining_BelowRightAttached", (long) Katie::QChar::CombiningClass::Combining_BelowRightAttached)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_COMBININGCLASS_IDX], + Sbk_Katie_QChar_TypeF(), "Combining_LeftAttached", (long) Katie::QChar::CombiningClass::Combining_LeftAttached)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_COMBININGCLASS_IDX], + Sbk_Katie_QChar_TypeF(), "Combining_RightAttached", (long) Katie::QChar::CombiningClass::Combining_RightAttached)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_COMBININGCLASS_IDX], + Sbk_Katie_QChar_TypeF(), "Combining_AboveLeftAttached", (long) Katie::QChar::CombiningClass::Combining_AboveLeftAttached)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_COMBININGCLASS_IDX], + Sbk_Katie_QChar_TypeF(), "Combining_AboveAttached", (long) Katie::QChar::CombiningClass::Combining_AboveAttached)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_COMBININGCLASS_IDX], + Sbk_Katie_QChar_TypeF(), "Combining_AboveRightAttached", (long) Katie::QChar::CombiningClass::Combining_AboveRightAttached)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_COMBININGCLASS_IDX], + Sbk_Katie_QChar_TypeF(), "Combining_BelowLeft", (long) Katie::QChar::CombiningClass::Combining_BelowLeft)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_COMBININGCLASS_IDX], + Sbk_Katie_QChar_TypeF(), "Combining_Below", (long) Katie::QChar::CombiningClass::Combining_Below)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_COMBININGCLASS_IDX], + Sbk_Katie_QChar_TypeF(), "Combining_BelowRight", (long) Katie::QChar::CombiningClass::Combining_BelowRight)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_COMBININGCLASS_IDX], + Sbk_Katie_QChar_TypeF(), "Combining_Left", (long) Katie::QChar::CombiningClass::Combining_Left)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_COMBININGCLASS_IDX], + Sbk_Katie_QChar_TypeF(), "Combining_Right", (long) Katie::QChar::CombiningClass::Combining_Right)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_COMBININGCLASS_IDX], + Sbk_Katie_QChar_TypeF(), "Combining_AboveLeft", (long) Katie::QChar::CombiningClass::Combining_AboveLeft)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_COMBININGCLASS_IDX], + Sbk_Katie_QChar_TypeF(), "Combining_Above", (long) Katie::QChar::CombiningClass::Combining_Above)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_COMBININGCLASS_IDX], + Sbk_Katie_QChar_TypeF(), "Combining_AboveRight", (long) Katie::QChar::CombiningClass::Combining_AboveRight)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_COMBININGCLASS_IDX], + Sbk_Katie_QChar_TypeF(), "Combining_DoubleBelow", (long) Katie::QChar::CombiningClass::Combining_DoubleBelow)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_COMBININGCLASS_IDX], + Sbk_Katie_QChar_TypeF(), "Combining_DoubleAbove", (long) Katie::QChar::CombiningClass::Combining_DoubleAbove)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_COMBININGCLASS_IDX], + Sbk_Katie_QChar_TypeF(), "Combining_IotaSubscript", (long) Katie::QChar::CombiningClass::Combining_IotaSubscript)) + return; + // Register converter for enum 'Katie::QChar::CombiningClass'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QCHAR_COMBININGCLASS_IDX], + Katie_QChar_CombiningClass_CppToPython_Katie_QChar_CombiningClass); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_QChar_CombiningClass_PythonToCpp_Katie_QChar_CombiningClass, + is_Katie_QChar_CombiningClass_PythonToCpp_Katie_QChar_CombiningClass_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QCHAR_COMBININGCLASS_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::QChar::CombiningClass"); + Shiboken::Conversions::registerConverterName(converter, "QChar::CombiningClass"); + Shiboken::Conversions::registerConverterName(converter, "CombiningClass"); + } + // End of 'CombiningClass' enum. + + // Initialization of enum 'UnicodeVersion'. + SbkKtCoreTypes[SBK_KATIE_QCHAR_UNICODEVERSION_IDX] = Shiboken::Enum::createScopedEnum(Sbk_Katie_QChar_TypeF(), + "UnicodeVersion", + "KtCore.Katie.QChar.UnicodeVersion", + "Katie::QChar::UnicodeVersion"); + if (!SbkKtCoreTypes[SBK_KATIE_QCHAR_UNICODEVERSION_IDX]) + return; + + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_UNICODEVERSION_IDX], + Sbk_Katie_QChar_TypeF(), "Unicode_Unassigned", (long) Katie::QChar::UnicodeVersion::Unicode_Unassigned)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_UNICODEVERSION_IDX], + Sbk_Katie_QChar_TypeF(), "Unicode_1_1", (long) Katie::QChar::UnicodeVersion::Unicode_1_1)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_UNICODEVERSION_IDX], + Sbk_Katie_QChar_TypeF(), "Unicode_2_0", (long) Katie::QChar::UnicodeVersion::Unicode_2_0)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_UNICODEVERSION_IDX], + Sbk_Katie_QChar_TypeF(), "Unicode_2_1_2", (long) Katie::QChar::UnicodeVersion::Unicode_2_1_2)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_UNICODEVERSION_IDX], + Sbk_Katie_QChar_TypeF(), "Unicode_3_0", (long) Katie::QChar::UnicodeVersion::Unicode_3_0)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_UNICODEVERSION_IDX], + Sbk_Katie_QChar_TypeF(), "Unicode_3_1", (long) Katie::QChar::UnicodeVersion::Unicode_3_1)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_UNICODEVERSION_IDX], + Sbk_Katie_QChar_TypeF(), "Unicode_3_2", (long) Katie::QChar::UnicodeVersion::Unicode_3_2)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_UNICODEVERSION_IDX], + Sbk_Katie_QChar_TypeF(), "Unicode_4_0", (long) Katie::QChar::UnicodeVersion::Unicode_4_0)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_UNICODEVERSION_IDX], + Sbk_Katie_QChar_TypeF(), "Unicode_4_1", (long) Katie::QChar::UnicodeVersion::Unicode_4_1)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QCHAR_UNICODEVERSION_IDX], + Sbk_Katie_QChar_TypeF(), "Unicode_5_0", (long) Katie::QChar::UnicodeVersion::Unicode_5_0)) + return; + // Register converter for enum 'Katie::QChar::UnicodeVersion'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QCHAR_UNICODEVERSION_IDX], + Katie_QChar_UnicodeVersion_CppToPython_Katie_QChar_UnicodeVersion); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_QChar_UnicodeVersion_PythonToCpp_Katie_QChar_UnicodeVersion, + is_Katie_QChar_UnicodeVersion_PythonToCpp_Katie_QChar_UnicodeVersion_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QCHAR_UNICODEVERSION_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::QChar::UnicodeVersion"); + Shiboken::Conversions::registerConverterName(converter, "QChar::UnicodeVersion"); + Shiboken::Conversions::registerConverterName(converter, "UnicodeVersion"); + } + // End of 'UnicodeVersion' enum. + + +} diff --git a/bindings/KtCore/katie_qchar_wrapper.h b/bindings/KtCore/katie_qchar_wrapper.h new file mode 100644 index 000000000..e2aee3515 --- /dev/null +++ b/bindings/KtCore/katie_qchar_wrapper.h @@ -0,0 +1,47 @@ +/**************************************************************************** +** +** Copyright (C) 2015 The Qt Company Ltd. +** Contact: http://www.qt.io/licensing/ +** +** This file is part of the FOO module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of The Qt Company Ltd nor the names of its +** contributors may be used to endorse or promote products derived +** from this software without specific prior written permission. +** +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef SBK_KATIE_QCHAR_H +#define SBK_KATIE_QCHAR_H + +#include + +#endif // SBK_KATIE_QCHAR_H + diff --git a/bindings/KtCore/katie_qcoreapplication_wrapper.cpp b/bindings/KtCore/katie_qcoreapplication_wrapper.cpp new file mode 100644 index 000000000..e118959ff --- /dev/null +++ b/bindings/KtCore/katie_qcoreapplication_wrapper.cpp @@ -0,0 +1,1712 @@ +/**************************************************************************** +** +** Copyright (C) 2015 The Qt Company Ltd. +** Contact: http://www.qt.io/licensing/ +** +** This file is part of the FOO module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of The Qt Company Ltd nor the names of its +** contributors may be used to endorse or promote products derived +** from this software without specific prior written permission. +** +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + +// default includes +#include +#include + +// module include +#include "ktcore_python.h" + +// main header +#include "katie_qcoreapplication_wrapper.h" + +// inner classes + +// Extra includes +#include +#include +#include + + +#include +#include +using namespace Katie; + + + +template +static const char *typeNameOf(const T &t) +{ + const char *typeName = typeid(t).name(); + auto size = std::strlen(typeName); +#if defined(Q_CC_MSVC) // MSVC: "class QPaintDevice * __ptr64" + if (auto lastStar = strchr(typeName, '*')) { + // MSVC: "class QPaintDevice * __ptr64" + while (*--lastStar == ' ') { + } + size = lastStar - typeName + 1; + } +#else // g++, Clang: "QPaintDevice *" -> "P12QPaintDevice" + if (size > 2 && typeName[0] == 'P' && std::isdigit(typeName[1])) { + ++typeName; + --size; + } +#endif + char *result = new char[size + 1]; + result[size] = '\0'; + memcpy(result, typeName, size); + return result; +} + +// Native --------------------------------------------------------- + +QCoreApplicationWrapper::QCoreApplicationWrapper(int & argc, char ** argv) : Katie::QCoreApplication(argc, argv) +{ + // ... middle +} + +void QCoreApplicationWrapper::connectNotify(const char * signal) +{ + Shiboken::GilState gil; + if (PyErr_Occurred()) + return; + Shiboken::AutoDecRef pyOverride(Shiboken::BindingManager::instance().getOverride(this, "connectNotify")); + if (pyOverride.isNull()) { + gil.release(); + this->::Katie::QObject::connectNotify(signal); + return; + } + + Shiboken::AutoDecRef pyArgs(Py_BuildValue("(N)", + Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), signal) + )); + + Shiboken::AutoDecRef pyResult(PyObject_Call(pyOverride, pyArgs, nullptr)); + // An error happened in python code! + if (pyResult.isNull()) { + PyErr_Print(); + return; + } +} + +void QCoreApplicationWrapper::disconnectNotify(const char * signal) +{ + Shiboken::GilState gil; + if (PyErr_Occurred()) + return; + Shiboken::AutoDecRef pyOverride(Shiboken::BindingManager::instance().getOverride(this, "disconnectNotify")); + if (pyOverride.isNull()) { + gil.release(); + this->::Katie::QObject::disconnectNotify(signal); + return; + } + + Shiboken::AutoDecRef pyArgs(Py_BuildValue("(N)", + Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), signal) + )); + + Shiboken::AutoDecRef pyResult(PyObject_Call(pyOverride, pyArgs, nullptr)); + // An error happened in python code! + if (pyResult.isNull()) { + PyErr_Print(); + return; + } +} + +QCoreApplicationWrapper::~QCoreApplicationWrapper() +{ + SbkObject* wrapper = Shiboken::BindingManager::instance().retrieveWrapper(this); + Shiboken::Object::destroy(wrapper, this); +} + +// Target --------------------------------------------------------- + +extern "C" { +static int +Sbk_Katie_QCoreApplication_Init(PyObject* self, PyObject* args, PyObject* kwds) +{ + SbkObject* sbkSelf = reinterpret_cast(self); + if (Shiboken::Object::isUserType(self) && !Shiboken::ObjectType::canCallConstructor(self->ob_type, Shiboken::SbkType< ::Katie::QCoreApplication >())) + return -1; + + ::QCoreApplicationWrapper* cptr{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "QCoreApplication", 1, 1, &(pyArgs[0]))) + return -1; + + + // Overloaded function decisor + // 0: QCoreApplication::QCoreApplication(int&,char**) + if (numArgs == 1 + && PySequence_Check(pyArgs[0])) { + overloadId = 0; // QCoreApplication(int&,char**) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCoreApplication_Init_TypeError; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // QCoreApplication(int&,char**) + // Begin code injection + + int argc_out = PySequence_Size(pyArgs[1-1]); + + + Shiboken::AutoArrayPointer argv_out(argc_out); + for (int i = 0; i < argc_out; ++i) + Shiboken::Conversions::pythonToCppCopy(Shiboken::Conversions::PrimitiveTypeConverter(), PySequence_Fast_GET_ITEM(pyArgs[1-1], i), &(argv_out[i])); + + // End of code injection + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cptr = new ::QCoreApplicationWrapper(argc_out, argv_out); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred() || !Shiboken::Object::setCppPointer(sbkSelf, Shiboken::SbkType< ::Katie::QCoreApplication >(), cptr)) { + delete cptr; + return -1; + } + if (!cptr) goto Sbk_Katie_QCoreApplication_Init_TypeError; + + Shiboken::Object::setValidCpp(sbkSelf, true); + Shiboken::Object::setHasCppWrapper(sbkSelf, true); + if (Shiboken::BindingManager::instance().hasWrapper(cptr)) { + Shiboken::BindingManager::instance().releaseWrapper(Shiboken::BindingManager::instance().retrieveWrapper(cptr)); + } + Shiboken::BindingManager::instance().registerWrapper(sbkSelf, cptr); + + + return 1; + + Sbk_Katie_QCoreApplication_Init_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QCoreApplication"); + return -1; +} + +static PyObject* Sbk_Katie_QCoreApplicationFunc_aboutToQuit(PyObject* self) +{ + QCoreApplicationWrapper* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = static_cast(reinterpret_cast< ::Katie::QCoreApplication *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCOREAPPLICATION_IDX], reinterpret_cast(self)))); + + // Call function/method + { + + if (!PyErr_Occurred()) { + // aboutToQuit() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + static_cast<::QCoreApplicationWrapper*>(cppSelf)->QCoreApplicationWrapper::aboutToQuit_protected(); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; +} + +static PyObject* Sbk_Katie_QCoreApplicationFunc_addLibraryPath(PyObject* self, PyObject* pyArg) +{ + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: static QCoreApplication::addLibraryPath(Katie::QString) + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArg)))) { + overloadId = 0; // addLibraryPath(Katie::QString) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCoreApplicationFunc_addLibraryPath_TypeError; + + // Call function/method + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // addLibraryPath(Katie::QString) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + ::Katie::QCoreApplication::addLibraryPath(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; + + Sbk_Katie_QCoreApplicationFunc_addLibraryPath_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QCoreApplication.addLibraryPath"); + return {}; +} + +static PyObject* Sbk_Katie_QCoreApplicationFunc_applicationDirPath(PyObject* self) +{ + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // applicationDirPath() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(::Katie::QCoreApplication::applicationDirPath()); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QCoreApplicationFunc_applicationFilePath(PyObject* self) +{ + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // applicationFilePath() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(::Katie::QCoreApplication::applicationFilePath()); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QCoreApplicationFunc_applicationName(PyObject* self) +{ + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // applicationName() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(::Katie::QCoreApplication::applicationName()); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QCoreApplicationFunc_applicationPid(PyObject* self) +{ + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // applicationPid() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + long long cppResult = ::Katie::QCoreApplication::applicationPid(); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QCoreApplicationFunc_applicationVersion(PyObject* self) +{ + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // applicationVersion() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(::Katie::QCoreApplication::applicationVersion()); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QCoreApplicationFunc_closingDown(PyObject* self) +{ + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // closingDown() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + bool cppResult = ::Katie::QCoreApplication::closingDown(); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QCoreApplicationFunc_exec(PyObject* self) +{ + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // exec() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + int cppResult = ::Katie::QCoreApplication::exec(); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QCoreApplicationFunc_exit(PyObject* self, PyObject* args, PyObject* kwds) +{ + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QCoreApplication.exit(): too many arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|O:exit", &(pyArgs[0]))) + return {}; + + + // Overloaded function decisor + // 0: static QCoreApplication::exit(int) + if (numArgs == 0) { + overloadId = 0; // exit(int) + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 0; // exit(int) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCoreApplicationFunc_exit_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "retcode"); + if (value && pyArgs[0]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QCoreApplication.exit(): got multiple values for keyword argument 'retcode'."); + return {}; + } else if (value) { + pyArgs[0] = value; + if (!(pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) + goto Sbk_Katie_QCoreApplicationFunc_exit_TypeError; + } + } + int cppArg0 = 0; + if (pythonToCpp[0]) pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // exit(int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + ::Katie::QCoreApplication::exit(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; + + Sbk_Katie_QCoreApplicationFunc_exit_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QCoreApplication.exit"); + return {}; +} + +static PyObject* Sbk_Katie_QCoreApplicationFunc_filterEvent(PyObject* self, PyObject* args) +{ + QCoreApplicationWrapper* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = static_cast(reinterpret_cast< ::Katie::QCoreApplication *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCOREAPPLICATION_IDX], reinterpret_cast(self)))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "filterEvent", 2, 2, &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QCoreApplication::filterEvent(void*,long*) + if (numArgs == 2 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0]))) + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // filterEvent(void*,long*) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCoreApplicationFunc_filterEvent_TypeError; + + // Call function/method + { + void* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + long* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // filterEvent(void*,long*) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + bool cppResult = cppSelf->filterEvent(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QCoreApplicationFunc_filterEvent_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QCoreApplication.filterEvent"); + return {}; +} + +static PyObject* Sbk_Katie_QCoreApplicationFunc_flush(PyObject* self) +{ + + // Call function/method + { + + if (!PyErr_Occurred()) { + // flush() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + ::Katie::QCoreApplication::flush(); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; +} + +static PyObject* Sbk_Katie_QCoreApplicationFunc_hasPendingEvents(PyObject* self) +{ + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // hasPendingEvents() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + bool cppResult = ::Katie::QCoreApplication::hasPendingEvents(); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QCoreApplicationFunc_instance(PyObject* self) +{ + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // instance() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QCoreApplication * cppResult = ::Katie::QCoreApplication::instance(); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::pointerToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCOREAPPLICATION_IDX]), cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QCoreApplicationFunc_organizationDomain(PyObject* self) +{ + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // organizationDomain() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(::Katie::QCoreApplication::organizationDomain()); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QCoreApplicationFunc_organizationName(PyObject* self) +{ + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // organizationName() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(::Katie::QCoreApplication::organizationName()); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QCoreApplicationFunc_processEvents(PyObject* self) +{ + + // Call function/method + { + + if (!PyErr_Occurred()) { + // processEvents() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + ::Katie::QCoreApplication::processEvents(); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; +} + +static PyObject* Sbk_Katie_QCoreApplicationFunc_quit(PyObject* self) +{ + + // Call function/method + { + + if (!PyErr_Occurred()) { + // quit() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + ::Katie::QCoreApplication::quit(); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; +} + +static PyObject* Sbk_Katie_QCoreApplicationFunc_removeLibraryPath(PyObject* self, PyObject* pyArg) +{ + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: static QCoreApplication::removeLibraryPath(Katie::QString) + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArg)))) { + overloadId = 0; // removeLibraryPath(Katie::QString) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCoreApplicationFunc_removeLibraryPath_TypeError; + + // Call function/method + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // removeLibraryPath(Katie::QString) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + ::Katie::QCoreApplication::removeLibraryPath(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; + + Sbk_Katie_QCoreApplicationFunc_removeLibraryPath_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QCoreApplication.removeLibraryPath"); + return {}; +} + +static PyObject* Sbk_Katie_QCoreApplicationFunc_removePostedEvents(PyObject* self, PyObject* args) +{ + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "removePostedEvents", 1, 2, &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: static QCoreApplication::removePostedEvents(Katie::QObject*) + // 1: static QCoreApplication::removePostedEvents(Katie::QObject*,int) + if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppPointerConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX]), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // removePostedEvents(Katie::QObject*) + } else if (numArgs == 2 + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 1; // removePostedEvents(Katie::QObject*,int) + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCoreApplicationFunc_removePostedEvents_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // removePostedEvents(Katie::QObject * receiver) + { + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QObject* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // removePostedEvents(Katie::QObject*) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + ::Katie::QCoreApplication::removePostedEvents(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 1: // removePostedEvents(Katie::QObject * receiver, int eventType) + { + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QObject* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // removePostedEvents(Katie::QObject*,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + ::Katie::QCoreApplication::removePostedEvents(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; + + Sbk_Katie_QCoreApplicationFunc_removePostedEvents_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QCoreApplication.removePostedEvents"); + return {}; +} + +static PyObject* Sbk_Katie_QCoreApplicationFunc_sendPostedEvents(PyObject* self, PyObject* args) +{ + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs == 1) + goto Sbk_Katie_QCoreApplicationFunc_sendPostedEvents_TypeError; + + if (!PyArg_UnpackTuple(args, "sendPostedEvents", 0, 2, &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: static QCoreApplication::sendPostedEvents() + // 1: static QCoreApplication::sendPostedEvents(Katie::QObject*,int) + if (numArgs == 0) { + overloadId = 0; // sendPostedEvents() + } else if (numArgs == 2 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppPointerConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX]), (pyArgs[0]))) + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 1; // sendPostedEvents(Katie::QObject*,int) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCoreApplicationFunc_sendPostedEvents_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // sendPostedEvents() + { + + if (!PyErr_Occurred()) { + // sendPostedEvents() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + ::Katie::QCoreApplication::sendPostedEvents(); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 1: // sendPostedEvents(Katie::QObject * receiver, int event_type) + { + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QObject* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // sendPostedEvents(Katie::QObject*,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + ::Katie::QCoreApplication::sendPostedEvents(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; + + Sbk_Katie_QCoreApplicationFunc_sendPostedEvents_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QCoreApplication.sendPostedEvents"); + return {}; +} + +static PyObject* Sbk_Katie_QCoreApplicationFunc_setApplicationName(PyObject* self, PyObject* pyArg) +{ + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: static QCoreApplication::setApplicationName(Katie::QString) + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArg)))) { + overloadId = 0; // setApplicationName(Katie::QString) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCoreApplicationFunc_setApplicationName_TypeError; + + // Call function/method + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // setApplicationName(Katie::QString) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + ::Katie::QCoreApplication::setApplicationName(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; + + Sbk_Katie_QCoreApplicationFunc_setApplicationName_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QCoreApplication.setApplicationName"); + return {}; +} + +static PyObject* Sbk_Katie_QCoreApplicationFunc_setApplicationVersion(PyObject* self, PyObject* pyArg) +{ + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: static QCoreApplication::setApplicationVersion(Katie::QString) + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArg)))) { + overloadId = 0; // setApplicationVersion(Katie::QString) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCoreApplicationFunc_setApplicationVersion_TypeError; + + // Call function/method + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // setApplicationVersion(Katie::QString) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + ::Katie::QCoreApplication::setApplicationVersion(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; + + Sbk_Katie_QCoreApplicationFunc_setApplicationVersion_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QCoreApplication.setApplicationVersion"); + return {}; +} + +static PyObject* Sbk_Katie_QCoreApplicationFunc_setAttribute(PyObject* self, PyObject* args, PyObject* kwds) +{ + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QCoreApplication.setAttribute(): too many arguments"); + return {}; + } else if (numArgs < 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QCoreApplication.setAttribute(): not enough arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OO:setAttribute", &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: static QCoreApplication::setAttribute(Katie::Qt::ApplicationAttribute,bool) + if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_APPLICATIONATTRIBUTE_IDX])->converter, (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // setAttribute(Katie::Qt::ApplicationAttribute,bool) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // setAttribute(Katie::Qt::ApplicationAttribute,bool) + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCoreApplicationFunc_setAttribute_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "on"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QCoreApplication.setAttribute(): got multiple values for keyword argument 'on'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QCoreApplicationFunc_setAttribute_TypeError; + } + } + ::Katie::Qt::ApplicationAttribute cppArg0{Katie::Qt::AA_ImmediateWidgetCreation}; + pythonToCpp[0](pyArgs[0], &cppArg0); + bool cppArg1 = true; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // setAttribute(Katie::Qt::ApplicationAttribute,bool) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + ::Katie::QCoreApplication::setAttribute(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; + + Sbk_Katie_QCoreApplicationFunc_setAttribute_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QCoreApplication.setAttribute"); + return {}; +} + +static PyObject* Sbk_Katie_QCoreApplicationFunc_setOrganizationDomain(PyObject* self, PyObject* pyArg) +{ + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: static QCoreApplication::setOrganizationDomain(Katie::QString) + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArg)))) { + overloadId = 0; // setOrganizationDomain(Katie::QString) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCoreApplicationFunc_setOrganizationDomain_TypeError; + + // Call function/method + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // setOrganizationDomain(Katie::QString) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + ::Katie::QCoreApplication::setOrganizationDomain(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; + + Sbk_Katie_QCoreApplicationFunc_setOrganizationDomain_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QCoreApplication.setOrganizationDomain"); + return {}; +} + +static PyObject* Sbk_Katie_QCoreApplicationFunc_setOrganizationName(PyObject* self, PyObject* pyArg) +{ + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: static QCoreApplication::setOrganizationName(Katie::QString) + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArg)))) { + overloadId = 0; // setOrganizationName(Katie::QString) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCoreApplicationFunc_setOrganizationName_TypeError; + + // Call function/method + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // setOrganizationName(Katie::QString) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + ::Katie::QCoreApplication::setOrganizationName(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; + + Sbk_Katie_QCoreApplicationFunc_setOrganizationName_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QCoreApplication.setOrganizationName"); + return {}; +} + +static PyObject* Sbk_Katie_QCoreApplicationFunc_startingUp(PyObject* self) +{ + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // startingUp() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + bool cppResult = ::Katie::QCoreApplication::startingUp(); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QCoreApplicationFunc_testAttribute(PyObject* self, PyObject* pyArg) +{ + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: static QCoreApplication::testAttribute(Katie::Qt::ApplicationAttribute) + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_APPLICATIONATTRIBUTE_IDX])->converter, (pyArg)))) { + overloadId = 0; // testAttribute(Katie::Qt::ApplicationAttribute) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCoreApplicationFunc_testAttribute_TypeError; + + // Call function/method + { + ::Katie::Qt::ApplicationAttribute cppArg0{Katie::Qt::AA_ImmediateWidgetCreation}; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // testAttribute(Katie::Qt::ApplicationAttribute) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + bool cppResult = ::Katie::QCoreApplication::testAttribute(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QCoreApplicationFunc_testAttribute_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QCoreApplication.testAttribute"); + return {}; +} + +static PyObject* Sbk_Katie_QCoreApplicationFunc_tr(PyObject* self, PyObject* args) +{ + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0, 0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "tr", 3, 3, &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2]))) + return {}; + + + // Overloaded function decisor + // 0: static QObject::tr(const char*,const char*,int) + if (numArgs == 3 + && Shiboken::String::check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0]))) + && Shiboken::String::check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1]))) + && (pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) { + overloadId = 0; // tr(const char*,const char*,int) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCoreApplicationFunc_tr_TypeError; + + // Call function/method + { + const char* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + const char* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + int cppArg2; + pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // tr(const char*,const char*,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(::Katie::QCoreApplication::tr(cppArg0, cppArg1, cppArg2)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QCoreApplicationFunc_tr_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QCoreApplication.tr"); + return {}; +} + +static PyObject* Sbk_Katie_QCoreApplicationFunc_trUtf8(PyObject* self, PyObject* args) +{ + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0, 0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "trUtf8", 3, 3, &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2]))) + return {}; + + + // Overloaded function decisor + // 0: static QObject::trUtf8(const char*,const char*,int) + if (numArgs == 3 + && Shiboken::String::check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0]))) + && Shiboken::String::check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1]))) + && (pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) { + overloadId = 0; // trUtf8(const char*,const char*,int) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCoreApplicationFunc_trUtf8_TypeError; + + // Call function/method + { + const char* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + const char* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + int cppArg2; + pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // trUtf8(const char*,const char*,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(::Katie::QCoreApplication::trUtf8(cppArg0, cppArg1, cppArg2)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QCoreApplicationFunc_trUtf8_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QCoreApplication.trUtf8"); + return {}; +} + +static PyObject* Sbk_Katie_QCoreApplicationFunc_translate(PyObject* self, PyObject* args, PyObject* kwds) +{ + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 3) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QCoreApplication.translate(): too many arguments"); + return {}; + } else if (numArgs < 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QCoreApplication.translate(): not enough arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OOO:translate", &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2]))) + return {}; + + + // Overloaded function decisor + // 0: static QCoreApplication::translate(const char*,const char*,const char*) + if (numArgs >= 2 + && Shiboken::String::check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0]))) + && Shiboken::String::check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 0; // translate(const char*,const char*,const char*) + } else if (Shiboken::String::check(pyArgs[2]) && (pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) { + overloadId = 0; // translate(const char*,const char*,const char*) + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCoreApplicationFunc_translate_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "disambiguation"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QCoreApplication.translate(): got multiple values for keyword argument 'disambiguation'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!Shiboken::String::check(pyArgs[2]) && (pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) + goto Sbk_Katie_QCoreApplicationFunc_translate_TypeError; + } + } + const char* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + const char* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + const char* cppArg2 = Q_NULLPTR; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // translate(const char*,const char*,const char*) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(::Katie::QCoreApplication::translate(cppArg0, cppArg1, cppArg2)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QCoreApplicationFunc_translate_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QCoreApplication.translate"); + return {}; +} + +static PyObject* Sbk_Katie_QCoreApplicationFunc_unixSignal(PyObject* self, PyObject* pyArg) +{ + QCoreApplicationWrapper* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = static_cast(reinterpret_cast< ::Katie::QCoreApplication *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QCOREAPPLICATION_IDX], reinterpret_cast(self)))); + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QCoreApplication::unixSignal(int) + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // unixSignal(int) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCoreApplicationFunc_unixSignal_TypeError; + + // Call function/method + { + int cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // unixSignal(int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + static_cast<::QCoreApplicationWrapper*>(cppSelf)->QCoreApplicationWrapper::unixSignal_protected(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; + + Sbk_Katie_QCoreApplicationFunc_unixSignal_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QCoreApplication.unixSignal"); + return {}; +} + +static PyObject* Sbk_Katie_QCoreApplicationFunc_watchUnixSignal(PyObject* self, PyObject* args) +{ + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "watchUnixSignal", 2, 2, &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: static QCoreApplication::watchUnixSignal(int,bool) + if (numArgs == 2 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0]))) + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // watchUnixSignal(int,bool) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QCoreApplicationFunc_watchUnixSignal_TypeError; + + // Call function/method + { + int cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + bool cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // watchUnixSignal(int,bool) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + ::Katie::QCoreApplication::watchUnixSignal(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; + + Sbk_Katie_QCoreApplicationFunc_watchUnixSignal_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QCoreApplication.watchUnixSignal"); + return {}; +} + +static PyMethodDef Sbk_Katie_QCoreApplication_methods[] = { + {"aboutToQuit", reinterpret_cast(Sbk_Katie_QCoreApplicationFunc_aboutToQuit), METH_NOARGS}, + {"addLibraryPath", reinterpret_cast(Sbk_Katie_QCoreApplicationFunc_addLibraryPath), METH_O|METH_STATIC}, + {"applicationDirPath", reinterpret_cast(Sbk_Katie_QCoreApplicationFunc_applicationDirPath), METH_NOARGS|METH_STATIC}, + {"applicationFilePath", reinterpret_cast(Sbk_Katie_QCoreApplicationFunc_applicationFilePath), METH_NOARGS|METH_STATIC}, + {"applicationName", reinterpret_cast(Sbk_Katie_QCoreApplicationFunc_applicationName), METH_NOARGS|METH_STATIC}, + {"applicationPid", reinterpret_cast(Sbk_Katie_QCoreApplicationFunc_applicationPid), METH_NOARGS|METH_STATIC}, + {"applicationVersion", reinterpret_cast(Sbk_Katie_QCoreApplicationFunc_applicationVersion), METH_NOARGS|METH_STATIC}, + {"closingDown", reinterpret_cast(Sbk_Katie_QCoreApplicationFunc_closingDown), METH_NOARGS|METH_STATIC}, + {"exec", reinterpret_cast(Sbk_Katie_QCoreApplicationFunc_exec), METH_NOARGS|METH_STATIC}, + {"exit", reinterpret_cast(Sbk_Katie_QCoreApplicationFunc_exit), METH_VARARGS|METH_KEYWORDS|METH_STATIC}, + {"filterEvent", reinterpret_cast(Sbk_Katie_QCoreApplicationFunc_filterEvent), METH_VARARGS}, + {"flush", reinterpret_cast(Sbk_Katie_QCoreApplicationFunc_flush), METH_NOARGS|METH_STATIC}, + {"hasPendingEvents", reinterpret_cast(Sbk_Katie_QCoreApplicationFunc_hasPendingEvents), METH_NOARGS|METH_STATIC}, + {"instance", reinterpret_cast(Sbk_Katie_QCoreApplicationFunc_instance), METH_NOARGS|METH_STATIC}, + {"organizationDomain", reinterpret_cast(Sbk_Katie_QCoreApplicationFunc_organizationDomain), METH_NOARGS|METH_STATIC}, + {"organizationName", reinterpret_cast(Sbk_Katie_QCoreApplicationFunc_organizationName), METH_NOARGS|METH_STATIC}, + {"processEvents", reinterpret_cast(Sbk_Katie_QCoreApplicationFunc_processEvents), METH_NOARGS|METH_STATIC}, + {"quit", reinterpret_cast(Sbk_Katie_QCoreApplicationFunc_quit), METH_NOARGS|METH_STATIC}, + {"removeLibraryPath", reinterpret_cast(Sbk_Katie_QCoreApplicationFunc_removeLibraryPath), METH_O|METH_STATIC}, + {"removePostedEvents", reinterpret_cast(Sbk_Katie_QCoreApplicationFunc_removePostedEvents), METH_VARARGS|METH_STATIC}, + {"sendPostedEvents", reinterpret_cast(Sbk_Katie_QCoreApplicationFunc_sendPostedEvents), METH_VARARGS|METH_STATIC}, + {"setApplicationName", reinterpret_cast(Sbk_Katie_QCoreApplicationFunc_setApplicationName), METH_O|METH_STATIC}, + {"setApplicationVersion", reinterpret_cast(Sbk_Katie_QCoreApplicationFunc_setApplicationVersion), METH_O|METH_STATIC}, + {"setAttribute", reinterpret_cast(Sbk_Katie_QCoreApplicationFunc_setAttribute), METH_VARARGS|METH_KEYWORDS|METH_STATIC}, + {"setOrganizationDomain", reinterpret_cast(Sbk_Katie_QCoreApplicationFunc_setOrganizationDomain), METH_O|METH_STATIC}, + {"setOrganizationName", reinterpret_cast(Sbk_Katie_QCoreApplicationFunc_setOrganizationName), METH_O|METH_STATIC}, + {"startingUp", reinterpret_cast(Sbk_Katie_QCoreApplicationFunc_startingUp), METH_NOARGS|METH_STATIC}, + {"testAttribute", reinterpret_cast(Sbk_Katie_QCoreApplicationFunc_testAttribute), METH_O|METH_STATIC}, + {"tr", reinterpret_cast(Sbk_Katie_QCoreApplicationFunc_tr), METH_VARARGS|METH_STATIC}, + {"trUtf8", reinterpret_cast(Sbk_Katie_QCoreApplicationFunc_trUtf8), METH_VARARGS|METH_STATIC}, + {"translate", reinterpret_cast(Sbk_Katie_QCoreApplicationFunc_translate), METH_VARARGS|METH_KEYWORDS|METH_STATIC}, + {"unixSignal", reinterpret_cast(Sbk_Katie_QCoreApplicationFunc_unixSignal), METH_O}, + {"watchUnixSignal", reinterpret_cast(Sbk_Katie_QCoreApplicationFunc_watchUnixSignal), METH_VARARGS|METH_STATIC}, + + {nullptr, nullptr} // Sentinel +}; + +} // extern "C" + +static int Sbk_Katie_QCoreApplication_traverse(PyObject* self, visitproc visit, void* arg) +{ + return reinterpret_cast(SbkObject_TypeF())->tp_traverse(self, visit, arg); +} +static int Sbk_Katie_QCoreApplication_clear(PyObject* self) +{ + return reinterpret_cast(SbkObject_TypeF())->tp_clear(self); +} +// Class Definition ----------------------------------------------- +extern "C" { +static SbkObjectType *_Sbk_Katie_QCoreApplication_Type = nullptr; +static SbkObjectType *Sbk_Katie_QCoreApplication_TypeF(void) +{ + return _Sbk_Katie_QCoreApplication_Type; +} + +static PyType_Slot Sbk_Katie_QCoreApplication_slots[] = { + {Py_tp_base, nullptr}, // inserted by introduceWrapperType + {Py_tp_dealloc, reinterpret_cast(&SbkDeallocQAppWrapper)}, + {Py_tp_repr, nullptr}, + {Py_tp_hash, nullptr}, + {Py_tp_call, nullptr}, + {Py_tp_str, nullptr}, + {Py_tp_getattro, nullptr}, + {Py_tp_setattro, nullptr}, + {Py_tp_traverse, reinterpret_cast(Sbk_Katie_QCoreApplication_traverse)}, + {Py_tp_clear, reinterpret_cast(Sbk_Katie_QCoreApplication_clear)}, + {Py_tp_richcompare, nullptr}, + {Py_tp_iter, nullptr}, + {Py_tp_iternext, nullptr}, + {Py_tp_methods, reinterpret_cast(Sbk_Katie_QCoreApplication_methods)}, + {Py_tp_getset, nullptr}, + {Py_tp_init, reinterpret_cast(Sbk_Katie_QCoreApplication_Init)}, + {Py_tp_new, reinterpret_cast(SbkQAppTpNew)}, + {0, nullptr} +}; +static PyType_Spec Sbk_Katie_QCoreApplication_spec = { + "KtCore.Katie.QCoreApplication", + sizeof(SbkObject), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, + Sbk_Katie_QCoreApplication_slots +}; + +} //extern "C" + +static void* Sbk_Katie_QCoreApplication_typeDiscovery(void* cptr, SbkObjectType* instanceType) +{ + if (instanceType == reinterpret_cast(Shiboken::SbkType< ::Katie::QObject >())) + return dynamic_cast< ::Katie::QCoreApplication*>(reinterpret_cast< ::Katie::QObject*>(cptr)); + return {}; +} + + +// Type conversion functions. + +// Python to C++ pointer conversion - returns the C++ object of the Python wrapper (keeps object identity). +static void QCoreApplication_PythonToCpp_QCoreApplication_PTR(PyObject* pyIn, void* cppOut) { + Shiboken::Conversions::pythonToCppPointer(Sbk_Katie_QCoreApplication_TypeF(), pyIn, cppOut); +} +static PythonToCppFunc is_QCoreApplication_PythonToCpp_QCoreApplication_PTR_Convertible(PyObject* pyIn) { + if (pyIn == Py_None) + return Shiboken::Conversions::nonePythonToCppNullPtr; + if (PyObject_TypeCheck(pyIn, reinterpret_cast(Sbk_Katie_QCoreApplication_TypeF()))) + return QCoreApplication_PythonToCpp_QCoreApplication_PTR; + return {}; +} + +// C++ to Python pointer conversion - tries to find the Python wrapper for the C++ object (keeps object identity). +static PyObject* QCoreApplication_PTR_CppToPython_QCoreApplication(const void* cppIn) { + auto pyOut = reinterpret_cast(Shiboken::BindingManager::instance().retrieveWrapper(cppIn)); + if (pyOut) { + Py_INCREF(pyOut); + return pyOut; + } + bool changedTypeName = false; + auto tCppIn = reinterpret_cast(cppIn); + const char *typeName = typeid(*tCppIn).name(); + auto sbkType = Shiboken::ObjectType::typeForTypeName(typeName); + if (sbkType && Shiboken::ObjectType::hasSpecialCastFunction(sbkType)) { + typeName = typeNameOf(tCppIn); + changedTypeName = true; + } + PyObject *result = Shiboken::Object::newObject(Sbk_Katie_QCoreApplication_TypeF(), const_cast(cppIn), false, /* exactType */ changedTypeName, typeName); + if (changedTypeName) + delete [] typeName; + return result; +} + +// The signatures string for the functions. +// Multiple signatures have their index "n:" in front. +static const char *Katie_QCoreApplication_SignatureStrings[] = { + "KtCore.Katie.QCoreApplication(argc:KtCore.int,argv:KtCore.char)", + "KtCore.Katie.QCoreApplication.aboutToQuit()", + "KtCore.Katie.QCoreApplication.addLibraryPath(arg__1:KtCore.Katie.QString)", + "KtCore.Katie.QCoreApplication.applicationDirPath()->KtCore.Katie.QString", + "KtCore.Katie.QCoreApplication.applicationFilePath()->KtCore.Katie.QString", + "KtCore.Katie.QCoreApplication.applicationName()->KtCore.Katie.QString", + "KtCore.Katie.QCoreApplication.applicationPid()->long long", + "KtCore.Katie.QCoreApplication.applicationVersion()->KtCore.Katie.QString", + "KtCore.Katie.QCoreApplication.closingDown()->bool", + "KtCore.Katie.QCoreApplication.exec()->int", + "KtCore.Katie.QCoreApplication.exit(retcode:int=0)", + "KtCore.Katie.QCoreApplication.filterEvent(message:void,result:KtCore.long)->bool", + "KtCore.Katie.QCoreApplication.flush()", + "KtCore.Katie.QCoreApplication.hasPendingEvents()->bool", + "KtCore.Katie.QCoreApplication.instance()->KtCore.Katie.QCoreApplication", + "KtCore.Katie.QCoreApplication.organizationDomain()->KtCore.Katie.QString", + "KtCore.Katie.QCoreApplication.organizationName()->KtCore.Katie.QString", + "KtCore.Katie.QCoreApplication.processEvents()", + "KtCore.Katie.QCoreApplication.quit()", + "KtCore.Katie.QCoreApplication.removeLibraryPath(arg__1:KtCore.Katie.QString)", + "1:KtCore.Katie.QCoreApplication.removePostedEvents(receiver:KtCore.Katie.QObject)", + "0:KtCore.Katie.QCoreApplication.removePostedEvents(receiver:KtCore.Katie.QObject,eventType:int)", + "1:KtCore.Katie.QCoreApplication.sendPostedEvents()", + "0:KtCore.Katie.QCoreApplication.sendPostedEvents(receiver:KtCore.Katie.QObject,event_type:int)", + "KtCore.Katie.QCoreApplication.setApplicationName(application:KtCore.Katie.QString)", + "KtCore.Katie.QCoreApplication.setApplicationVersion(version:KtCore.Katie.QString)", + "KtCore.Katie.QCoreApplication.setAttribute(attribute:KtCore.Katie.Qt.ApplicationAttribute,on:bool=true)", + "KtCore.Katie.QCoreApplication.setOrganizationDomain(orgDomain:KtCore.Katie.QString)", + "KtCore.Katie.QCoreApplication.setOrganizationName(orgName:KtCore.Katie.QString)", + "KtCore.Katie.QCoreApplication.startingUp()->bool", + "KtCore.Katie.QCoreApplication.testAttribute(attribute:KtCore.Katie.Qt.ApplicationAttribute)->bool", + "KtCore.Katie.QCoreApplication.tr(s:str,c:str,n:int)->KtCore.Katie.QString", + "KtCore.Katie.QCoreApplication.trUtf8(s:str,c:str,n:int)->KtCore.Katie.QString", + "KtCore.Katie.QCoreApplication.translate(context:str,sourceText:str,disambiguation:str=Q_NULLPTR)->KtCore.Katie.QString", + "KtCore.Katie.QCoreApplication.unixSignal(arg__1:int)", + "KtCore.Katie.QCoreApplication.watchUnixSignal(signal:int,watch:bool)", + nullptr}; // Sentinel + +void init_Katie_QCoreApplication(PyObject* module) +{ + _Sbk_Katie_QCoreApplication_Type = Shiboken::ObjectType::introduceWrapperType( + module, + "QCoreApplication", + "Katie::QCoreApplication*", + &Sbk_Katie_QCoreApplication_spec, + Katie_QCoreApplication_SignatureStrings, + &Shiboken::callCppDestructor< ::Katie::QCoreApplication >, + reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX]), + 0, + 0 ); + + SbkKtCoreTypes[SBK_KATIE_QCOREAPPLICATION_IDX] + = reinterpret_cast(Sbk_Katie_QCoreApplication_TypeF()); + + // Register Converter + SbkConverter* converter = Shiboken::Conversions::createConverter(Sbk_Katie_QCoreApplication_TypeF(), + QCoreApplication_PythonToCpp_QCoreApplication_PTR, + is_QCoreApplication_PythonToCpp_QCoreApplication_PTR_Convertible, + QCoreApplication_PTR_CppToPython_QCoreApplication); + + Shiboken::Conversions::registerConverterName(converter, "Katie::QCoreApplication"); + Shiboken::Conversions::registerConverterName(converter, "Katie::QCoreApplication*"); + Shiboken::Conversions::registerConverterName(converter, "Katie::QCoreApplication&"); + Shiboken::Conversions::registerConverterName(converter, "QCoreApplication"); + Shiboken::Conversions::registerConverterName(converter, "QCoreApplication*"); + Shiboken::Conversions::registerConverterName(converter, "QCoreApplication&"); + Shiboken::Conversions::registerConverterName(converter, typeid(::Katie::QCoreApplication).name()); + Shiboken::Conversions::registerConverterName(converter, typeid(::QCoreApplicationWrapper).name()); + + + Shiboken::ObjectType::setTypeDiscoveryFunctionV2(Sbk_Katie_QCoreApplication_TypeF(), &Sbk_Katie_QCoreApplication_typeDiscovery); + + +} diff --git a/bindings/KtCore/katie_qcoreapplication_wrapper.h b/bindings/KtCore/katie_qcoreapplication_wrapper.h new file mode 100644 index 000000000..5cdd7d7d8 --- /dev/null +++ b/bindings/KtCore/katie_qcoreapplication_wrapper.h @@ -0,0 +1,85 @@ +/**************************************************************************** +** +** Copyright (C) 2015 The Qt Company Ltd. +** Contact: http://www.qt.io/licensing/ +** +** This file is part of the FOO module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of The Qt Company Ltd nor the names of its +** contributors may be used to endorse or promote products derived +** from this software without specific prior written permission. +** +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef SBK_QCOREAPPLICATIONWRAPPER_H +#define SBK_QCOREAPPLICATIONWRAPPER_H + +#include + +class QCoreApplicationWrapper : public Katie::QCoreApplication +{ +public: + QCoreApplicationWrapper(int & argc, char ** argv); + inline void aboutToQuit_protected() { Katie::QCoreApplication::aboutToQuit(); } + inline void connectNotify_protected(const char * signal) { Katie::QCoreApplication::connectNotify(signal); } + void connectNotify(const char * signal) override; + inline void destroyed_protected(Katie::QObject * arg__1 = Q_NULLPTR) { Katie::QCoreApplication::destroyed(arg__1); } + inline void disconnectNotify_protected(const char * signal) { Katie::QCoreApplication::disconnectNotify(signal); } + void disconnectNotify(const char * signal) override; + inline int receivers_protected(const char * signal) const { return Katie::QCoreApplication::receivers(signal); } + inline Katie::QObject * sender_protected() const { return Katie::QCoreApplication::sender(); } + inline int senderSignalIndex_protected() const { return Katie::QCoreApplication::senderSignalIndex(); } + inline void unixSignal_protected(int arg__1) { Katie::QCoreApplication::unixSignal(arg__1); } + ~QCoreApplicationWrapper(); +}; + +# ifndef SBK_QOBJECTWRAPPER_H +# define SBK_QOBJECTWRAPPER_H + +// Inherited base class: +class QObjectWrapper : public Katie::QObject +{ +public: + QObjectWrapper(Katie::QObject * parent = Q_NULLPTR); + inline void connectNotify_protected(const char * signal) { Katie::QObject::connectNotify(signal); } + void connectNotify(const char * signal) override; + inline void destroyed_protected(Katie::QObject * arg__1 = Q_NULLPTR) { Katie::QObject::destroyed(arg__1); } + inline void disconnectNotify_protected(const char * signal) { Katie::QObject::disconnectNotify(signal); } + void disconnectNotify(const char * signal) override; + inline int receivers_protected(const char * signal) const { return Katie::QObject::receivers(signal); } + inline Katie::QObject * sender_protected() const { return Katie::QObject::sender(); } + inline int senderSignalIndex_protected() const { return Katie::QObject::senderSignalIndex(); } + ~QObjectWrapper(); +}; + +# endif // SBK_QOBJECTWRAPPER_H + +#endif // SBK_QCOREAPPLICATIONWRAPPER_H + diff --git a/bindings/KtCore/katie_qlatin1char_wrapper.cpp b/bindings/KtCore/katie_qlatin1char_wrapper.cpp new file mode 100644 index 000000000..d612a6d47 --- /dev/null +++ b/bindings/KtCore/katie_qlatin1char_wrapper.cpp @@ -0,0 +1,339 @@ +/**************************************************************************** +** +** Copyright (C) 2015 The Qt Company Ltd. +** Contact: http://www.qt.io/licensing/ +** +** This file is part of the FOO module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of The Qt Company Ltd nor the names of its +** contributors may be used to endorse or promote products derived +** from this software without specific prior written permission. +** +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + +// default includes +#include +#include + +// module include +#include "ktcore_python.h" + +// main header +#include "katie_qlatin1char_wrapper.h" + +// inner classes + +// Extra includes + + +#include +#include +using namespace Katie; + + + +template +static const char *typeNameOf(const T &t) +{ + const char *typeName = typeid(t).name(); + auto size = std::strlen(typeName); +#if defined(Q_CC_MSVC) // MSVC: "class QPaintDevice * __ptr64" + if (auto lastStar = strchr(typeName, '*')) { + // MSVC: "class QPaintDevice * __ptr64" + while (*--lastStar == ' ') { + } + size = lastStar - typeName + 1; + } +#else // g++, Clang: "QPaintDevice *" -> "P12QPaintDevice" + if (size > 2 && typeName[0] == 'P' && std::isdigit(typeName[1])) { + ++typeName; + --size; + } +#endif + char *result = new char[size + 1]; + result[size] = '\0'; + memcpy(result, typeName, size); + return result; +} + + +// Target --------------------------------------------------------- + +extern "C" { +static int +Sbk_Katie_QLatin1Char_Init(PyObject* self, PyObject* args, PyObject* kwds) +{ + SbkObject* sbkSelf = reinterpret_cast(self); + if (Shiboken::Object::isUserType(self) && !Shiboken::ObjectType::canCallConstructor(self->ob_type, Shiboken::SbkType< ::Katie::QLatin1Char >())) + return -1; + + ::Katie::QLatin1Char* cptr{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "QLatin1Char", 1, 1, &(pyArgs[0]))) + return -1; + + + // Overloaded function decisor + // 0: QLatin1Char::QLatin1Char(char) + if (numArgs == 1 + && SbkChar_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 0; // QLatin1Char(char) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QLatin1Char_Init_TypeError; + + // Call function/method + { + char cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // QLatin1Char(char) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cptr = new ::Katie::QLatin1Char(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred() || !Shiboken::Object::setCppPointer(sbkSelf, Shiboken::SbkType< ::Katie::QLatin1Char >(), cptr)) { + delete cptr; + return -1; + } + if (!cptr) goto Sbk_Katie_QLatin1Char_Init_TypeError; + + Shiboken::Object::setValidCpp(sbkSelf, true); + if (Shiboken::BindingManager::instance().hasWrapper(cptr)) { + Shiboken::BindingManager::instance().releaseWrapper(Shiboken::BindingManager::instance().retrieveWrapper(cptr)); + } + Shiboken::BindingManager::instance().registerWrapper(sbkSelf, cptr); + + + return 1; + + Sbk_Katie_QLatin1Char_Init_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QLatin1Char"); + return -1; +} + +static PyObject* Sbk_Katie_QLatin1CharFunc_toLatin1(PyObject* self) +{ + ::Katie::QLatin1Char* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QLatin1Char *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QLATIN1CHAR_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // toLatin1()const + char cppResult = const_cast(cppSelf)->toLatin1(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QLatin1CharFunc_unicode(PyObject* self) +{ + ::Katie::QLatin1Char* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QLatin1Char *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QLATIN1CHAR_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // unicode()const + ushort cppResult = const_cast(cppSelf)->unicode(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyMethodDef Sbk_Katie_QLatin1Char_methods[] = { + {"toLatin1", reinterpret_cast(Sbk_Katie_QLatin1CharFunc_toLatin1), METH_NOARGS}, + {"unicode", reinterpret_cast(Sbk_Katie_QLatin1CharFunc_unicode), METH_NOARGS}, + + {nullptr, nullptr} // Sentinel +}; + +} // extern "C" + +static int Sbk_Katie_QLatin1Char_traverse(PyObject* self, visitproc visit, void* arg) +{ + return reinterpret_cast(SbkObject_TypeF())->tp_traverse(self, visit, arg); +} +static int Sbk_Katie_QLatin1Char_clear(PyObject* self) +{ + return reinterpret_cast(SbkObject_TypeF())->tp_clear(self); +} +// Class Definition ----------------------------------------------- +extern "C" { +static SbkObjectType *_Sbk_Katie_QLatin1Char_Type = nullptr; +static SbkObjectType *Sbk_Katie_QLatin1Char_TypeF(void) +{ + return _Sbk_Katie_QLatin1Char_Type; +} + +static PyType_Slot Sbk_Katie_QLatin1Char_slots[] = { + {Py_tp_base, nullptr}, // inserted by introduceWrapperType + {Py_tp_dealloc, reinterpret_cast(&SbkDeallocWrapper)}, + {Py_tp_repr, nullptr}, + {Py_tp_hash, nullptr}, + {Py_tp_call, nullptr}, + {Py_tp_str, nullptr}, + {Py_tp_getattro, nullptr}, + {Py_tp_setattro, nullptr}, + {Py_tp_traverse, reinterpret_cast(Sbk_Katie_QLatin1Char_traverse)}, + {Py_tp_clear, reinterpret_cast(Sbk_Katie_QLatin1Char_clear)}, + {Py_tp_richcompare, nullptr}, + {Py_tp_iter, nullptr}, + {Py_tp_iternext, nullptr}, + {Py_tp_methods, reinterpret_cast(Sbk_Katie_QLatin1Char_methods)}, + {Py_tp_getset, nullptr}, + {Py_tp_init, reinterpret_cast(Sbk_Katie_QLatin1Char_Init)}, + {Py_tp_new, reinterpret_cast(SbkObjectTpNew)}, + {0, nullptr} +}; +static PyType_Spec Sbk_Katie_QLatin1Char_spec = { + "KtCore.Katie.QLatin1Char", + sizeof(SbkObject), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_GC, + Sbk_Katie_QLatin1Char_slots +}; + +} //extern "C" + + +// Type conversion functions. + +// Python to C++ pointer conversion - returns the C++ object of the Python wrapper (keeps object identity). +static void QLatin1Char_PythonToCpp_QLatin1Char_PTR(PyObject* pyIn, void* cppOut) { + Shiboken::Conversions::pythonToCppPointer(Sbk_Katie_QLatin1Char_TypeF(), pyIn, cppOut); +} +static PythonToCppFunc is_QLatin1Char_PythonToCpp_QLatin1Char_PTR_Convertible(PyObject* pyIn) { + if (pyIn == Py_None) + return Shiboken::Conversions::nonePythonToCppNullPtr; + if (PyObject_TypeCheck(pyIn, reinterpret_cast(Sbk_Katie_QLatin1Char_TypeF()))) + return QLatin1Char_PythonToCpp_QLatin1Char_PTR; + return {}; +} + +// C++ to Python pointer conversion - tries to find the Python wrapper for the C++ object (keeps object identity). +static PyObject* QLatin1Char_PTR_CppToPython_QLatin1Char(const void* cppIn) { + auto pyOut = reinterpret_cast(Shiboken::BindingManager::instance().retrieveWrapper(cppIn)); + if (pyOut) { + Py_INCREF(pyOut); + return pyOut; + } + bool changedTypeName = false; + auto tCppIn = reinterpret_cast(cppIn); + const char *typeName = typeid(*tCppIn).name(); + auto sbkType = Shiboken::ObjectType::typeForTypeName(typeName); + if (sbkType && Shiboken::ObjectType::hasSpecialCastFunction(sbkType)) { + typeName = typeNameOf(tCppIn); + changedTypeName = true; + } + PyObject *result = Shiboken::Object::newObject(Sbk_Katie_QLatin1Char_TypeF(), const_cast(cppIn), false, /* exactType */ changedTypeName, typeName); + if (changedTypeName) + delete [] typeName; + return result; +} + +// The signatures string for the functions. +// Multiple signatures have their index "n:" in front. +static const char *Katie_QLatin1Char_SignatureStrings[] = { + "KtCore.Katie.QLatin1Char(c:char)", + "KtCore.Katie.QLatin1Char.toLatin1()->char", + "KtCore.Katie.QLatin1Char.unicode()->ushort", + nullptr}; // Sentinel + +void init_Katie_QLatin1Char(PyObject* module) +{ + _Sbk_Katie_QLatin1Char_Type = Shiboken::ObjectType::introduceWrapperType( + module, + "QLatin1Char", + "Katie::QLatin1Char*", + &Sbk_Katie_QLatin1Char_spec, + Katie_QLatin1Char_SignatureStrings, + &Shiboken::callCppDestructor< ::Katie::QLatin1Char >, + 0, + 0, + 0 ); + + SbkKtCoreTypes[SBK_KATIE_QLATIN1CHAR_IDX] + = reinterpret_cast(Sbk_Katie_QLatin1Char_TypeF()); + + // Register Converter + SbkConverter* converter = Shiboken::Conversions::createConverter(Sbk_Katie_QLatin1Char_TypeF(), + QLatin1Char_PythonToCpp_QLatin1Char_PTR, + is_QLatin1Char_PythonToCpp_QLatin1Char_PTR_Convertible, + QLatin1Char_PTR_CppToPython_QLatin1Char); + + Shiboken::Conversions::registerConverterName(converter, "Katie::QLatin1Char"); + Shiboken::Conversions::registerConverterName(converter, "Katie::QLatin1Char*"); + Shiboken::Conversions::registerConverterName(converter, "Katie::QLatin1Char&"); + Shiboken::Conversions::registerConverterName(converter, "QLatin1Char"); + Shiboken::Conversions::registerConverterName(converter, "QLatin1Char*"); + Shiboken::Conversions::registerConverterName(converter, "QLatin1Char&"); + Shiboken::Conversions::registerConverterName(converter, typeid(::Katie::QLatin1Char).name()); + + + +} diff --git a/bindings/KtCore/katie_qlatin1char_wrapper.h b/bindings/KtCore/katie_qlatin1char_wrapper.h new file mode 100644 index 000000000..d412e0e47 --- /dev/null +++ b/bindings/KtCore/katie_qlatin1char_wrapper.h @@ -0,0 +1,47 @@ +/**************************************************************************** +** +** Copyright (C) 2015 The Qt Company Ltd. +** Contact: http://www.qt.io/licensing/ +** +** This file is part of the FOO module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of The Qt Company Ltd nor the names of its +** contributors may be used to endorse or promote products derived +** from this software without specific prior written permission. +** +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef SBK_KATIE_QLATIN1CHAR_H +#define SBK_KATIE_QLATIN1CHAR_H + +#include + +#endif // SBK_KATIE_QLATIN1CHAR_H + diff --git a/bindings/KtCore/katie_qlatin1string_wrapper.cpp b/bindings/KtCore/katie_qlatin1string_wrapper.cpp new file mode 100644 index 000000000..4a61becc8 --- /dev/null +++ b/bindings/KtCore/katie_qlatin1string_wrapper.cpp @@ -0,0 +1,458 @@ +/**************************************************************************** +** +** Copyright (C) 2015 The Qt Company Ltd. +** Contact: http://www.qt.io/licensing/ +** +** This file is part of the FOO module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of The Qt Company Ltd nor the names of its +** contributors may be used to endorse or promote products derived +** from this software without specific prior written permission. +** +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + +// default includes +#include +#include + +// module include +#include "ktcore_python.h" + +// main header +#include "katie_qlatin1string_wrapper.h" + +// inner classes + +// Extra includes +#include + + +#include +#include +using namespace Katie; + + + +template +static const char *typeNameOf(const T &t) +{ + const char *typeName = typeid(t).name(); + auto size = std::strlen(typeName); +#if defined(Q_CC_MSVC) // MSVC: "class QPaintDevice * __ptr64" + if (auto lastStar = strchr(typeName, '*')) { + // MSVC: "class QPaintDevice * __ptr64" + while (*--lastStar == ' ') { + } + size = lastStar - typeName + 1; + } +#else // g++, Clang: "QPaintDevice *" -> "P12QPaintDevice" + if (size > 2 && typeName[0] == 'P' && std::isdigit(typeName[1])) { + ++typeName; + --size; + } +#endif + char *result = new char[size + 1]; + result[size] = '\0'; + memcpy(result, typeName, size); + return result; +} + + +// Target --------------------------------------------------------- + +extern "C" { +static int +Sbk_Katie_QLatin1String_Init(PyObject* self, PyObject* args, PyObject* kwds) +{ + SbkObject* sbkSelf = reinterpret_cast(self); + if (Shiboken::Object::isUserType(self) && !Shiboken::ObjectType::canCallConstructor(self->ob_type, Shiboken::SbkType< ::Katie::QLatin1String >())) + return -1; + + ::Katie::QLatin1String* cptr{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "QLatin1String", 1, 1, &(pyArgs[0]))) + return -1; + + + // Overloaded function decisor + // 0: QLatin1String::QLatin1String(const char*) + if (numArgs == 1 + && Shiboken::String::check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 0; // QLatin1String(const char*) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QLatin1String_Init_TypeError; + + // Call function/method + { + const char* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // QLatin1String(const char*) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cptr = new ::Katie::QLatin1String(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred() || !Shiboken::Object::setCppPointer(sbkSelf, Shiboken::SbkType< ::Katie::QLatin1String >(), cptr)) { + delete cptr; + return -1; + } + if (!cptr) goto Sbk_Katie_QLatin1String_Init_TypeError; + + Shiboken::Object::setValidCpp(sbkSelf, true); + if (Shiboken::BindingManager::instance().hasWrapper(cptr)) { + Shiboken::BindingManager::instance().releaseWrapper(Shiboken::BindingManager::instance().retrieveWrapper(cptr)); + } + Shiboken::BindingManager::instance().registerWrapper(sbkSelf, cptr); + + + return 1; + + Sbk_Katie_QLatin1String_Init_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QLatin1String"); + return -1; +} + +static PyObject* Sbk_Katie_QLatin1StringFunc_latin1(PyObject* self) +{ + ::Katie::QLatin1String* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QLatin1String *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QLATIN1STRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // latin1()const + const char * cppResult = const_cast(cppSelf)->latin1(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyMethodDef Sbk_Katie_QLatin1String_methods[] = { + {"latin1", reinterpret_cast(Sbk_Katie_QLatin1StringFunc_latin1), METH_NOARGS}, + + {nullptr, nullptr} // Sentinel +}; + +// Rich comparison +static PyObject* Sbk_Katie_QLatin1String_richcompare(PyObject* self, PyObject* pyArg, int op) +{ + if (!Shiboken::Object::isValid(self)) + return {}; + ::Katie::QLatin1String& cppSelf = *reinterpret_cast< ::Katie::QLatin1String *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QLATIN1STRING_IDX], reinterpret_cast(self))); + SBK_UNUSED(cppSelf) + PyObject* pyResult{}; + PythonToCppFunc pythonToCpp; + SBK_UNUSED(pythonToCpp) + + switch (op) { + case Py_NE: + if (Shiboken::String::check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + // operator!=(const char * s) const + const char* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf !=(cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArg)))) { + // operator!=(const Katie::QString & s) const + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf !=(*cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else { + pyResult = Py_True; + Py_INCREF(pyResult); + } + + break; + case Py_LT: + if (Shiboken::String::check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + // operator<(const char * s) const + const char* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf <(cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArg)))) { + // operator<(const Katie::QString & s) const + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf <(*cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else { + goto Sbk_Katie_QLatin1String_RichComparison_TypeError; + } + + break; + case Py_LE: + if (Shiboken::String::check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + // operator<=(const char * s) const + const char* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf <=(cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArg)))) { + // operator<=(const Katie::QString & s) const + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf <=(*cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else { + goto Sbk_Katie_QLatin1String_RichComparison_TypeError; + } + + break; + case Py_EQ: + if (Shiboken::String::check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + // operator==(const char * s) const + const char* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf ==(cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArg)))) { + // operator==(const Katie::QString & s) const + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf ==(*cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else { + pyResult = Py_False; + Py_INCREF(pyResult); + } + + break; + case Py_GT: + if (Shiboken::String::check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + // operator>(const char * s) const + const char* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf >(cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArg)))) { + // operator>(const Katie::QString & s) const + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf >(*cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else { + goto Sbk_Katie_QLatin1String_RichComparison_TypeError; + } + + break; + case Py_GE: + if (Shiboken::String::check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + // operator>=(const char * s) const + const char* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf >=(cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArg)))) { + // operator>=(const Katie::QString & s) const + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf >=(*cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else { + goto Sbk_Katie_QLatin1String_RichComparison_TypeError; + } + + break; + default: + goto Sbk_Katie_QLatin1String_RichComparison_TypeError; + } + + if (pyResult && !PyErr_Occurred()) + return pyResult; + Sbk_Katie_QLatin1String_RichComparison_TypeError: + PyErr_SetString(PyExc_NotImplementedError, "operator not implemented."); + return {}; + +} + +} // extern "C" + +static int Sbk_Katie_QLatin1String_traverse(PyObject* self, visitproc visit, void* arg) +{ + return reinterpret_cast(SbkObject_TypeF())->tp_traverse(self, visit, arg); +} +static int Sbk_Katie_QLatin1String_clear(PyObject* self) +{ + return reinterpret_cast(SbkObject_TypeF())->tp_clear(self); +} +// Class Definition ----------------------------------------------- +extern "C" { +static SbkObjectType *_Sbk_Katie_QLatin1String_Type = nullptr; +static SbkObjectType *Sbk_Katie_QLatin1String_TypeF(void) +{ + return _Sbk_Katie_QLatin1String_Type; +} + +static PyType_Slot Sbk_Katie_QLatin1String_slots[] = { + {Py_tp_base, nullptr}, // inserted by introduceWrapperType + {Py_tp_dealloc, reinterpret_cast(&SbkDeallocWrapper)}, + {Py_tp_repr, nullptr}, + {Py_tp_hash, nullptr}, + {Py_tp_call, nullptr}, + {Py_tp_str, nullptr}, + {Py_tp_getattro, nullptr}, + {Py_tp_setattro, nullptr}, + {Py_tp_traverse, reinterpret_cast(Sbk_Katie_QLatin1String_traverse)}, + {Py_tp_clear, reinterpret_cast(Sbk_Katie_QLatin1String_clear)}, + {Py_tp_richcompare, reinterpret_cast(Sbk_Katie_QLatin1String_richcompare)}, + {Py_tp_iter, nullptr}, + {Py_tp_iternext, nullptr}, + {Py_tp_methods, reinterpret_cast(Sbk_Katie_QLatin1String_methods)}, + {Py_tp_getset, nullptr}, + {Py_tp_init, reinterpret_cast(Sbk_Katie_QLatin1String_Init)}, + {Py_tp_new, reinterpret_cast(SbkObjectTpNew)}, + {0, nullptr} +}; +static PyType_Spec Sbk_Katie_QLatin1String_spec = { + "KtCore.Katie.QLatin1String", + sizeof(SbkObject), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_GC, + Sbk_Katie_QLatin1String_slots +}; + +} //extern "C" + + +// Type conversion functions. + +// Python to C++ pointer conversion - returns the C++ object of the Python wrapper (keeps object identity). +static void QLatin1String_PythonToCpp_QLatin1String_PTR(PyObject* pyIn, void* cppOut) { + Shiboken::Conversions::pythonToCppPointer(Sbk_Katie_QLatin1String_TypeF(), pyIn, cppOut); +} +static PythonToCppFunc is_QLatin1String_PythonToCpp_QLatin1String_PTR_Convertible(PyObject* pyIn) { + if (pyIn == Py_None) + return Shiboken::Conversions::nonePythonToCppNullPtr; + if (PyObject_TypeCheck(pyIn, reinterpret_cast(Sbk_Katie_QLatin1String_TypeF()))) + return QLatin1String_PythonToCpp_QLatin1String_PTR; + return {}; +} + +// C++ to Python pointer conversion - tries to find the Python wrapper for the C++ object (keeps object identity). +static PyObject* QLatin1String_PTR_CppToPython_QLatin1String(const void* cppIn) { + auto pyOut = reinterpret_cast(Shiboken::BindingManager::instance().retrieveWrapper(cppIn)); + if (pyOut) { + Py_INCREF(pyOut); + return pyOut; + } + bool changedTypeName = false; + auto tCppIn = reinterpret_cast(cppIn); + const char *typeName = typeid(*tCppIn).name(); + auto sbkType = Shiboken::ObjectType::typeForTypeName(typeName); + if (sbkType && Shiboken::ObjectType::hasSpecialCastFunction(sbkType)) { + typeName = typeNameOf(tCppIn); + changedTypeName = true; + } + PyObject *result = Shiboken::Object::newObject(Sbk_Katie_QLatin1String_TypeF(), const_cast(cppIn), false, /* exactType */ changedTypeName, typeName); + if (changedTypeName) + delete [] typeName; + return result; +} + +// The signatures string for the functions. +// Multiple signatures have their index "n:" in front. +static const char *Katie_QLatin1String_SignatureStrings[] = { + "KtCore.Katie.QLatin1String(s:str)", + "KtCore.Katie.QLatin1String.latin1()->str", + nullptr}; // Sentinel + +void init_Katie_QLatin1String(PyObject* module) +{ + _Sbk_Katie_QLatin1String_Type = Shiboken::ObjectType::introduceWrapperType( + module, + "QLatin1String", + "Katie::QLatin1String*", + &Sbk_Katie_QLatin1String_spec, + Katie_QLatin1String_SignatureStrings, + &Shiboken::callCppDestructor< ::Katie::QLatin1String >, + 0, + 0, + 0 ); + + SbkKtCoreTypes[SBK_KATIE_QLATIN1STRING_IDX] + = reinterpret_cast(Sbk_Katie_QLatin1String_TypeF()); + + // Register Converter + SbkConverter* converter = Shiboken::Conversions::createConverter(Sbk_Katie_QLatin1String_TypeF(), + QLatin1String_PythonToCpp_QLatin1String_PTR, + is_QLatin1String_PythonToCpp_QLatin1String_PTR_Convertible, + QLatin1String_PTR_CppToPython_QLatin1String); + + Shiboken::Conversions::registerConverterName(converter, "Katie::QLatin1String"); + Shiboken::Conversions::registerConverterName(converter, "Katie::QLatin1String*"); + Shiboken::Conversions::registerConverterName(converter, "Katie::QLatin1String&"); + Shiboken::Conversions::registerConverterName(converter, "QLatin1String"); + Shiboken::Conversions::registerConverterName(converter, "QLatin1String*"); + Shiboken::Conversions::registerConverterName(converter, "QLatin1String&"); + Shiboken::Conversions::registerConverterName(converter, typeid(::Katie::QLatin1String).name()); + + + +} diff --git a/bindings/KtCore/katie_qlatin1string_wrapper.h b/bindings/KtCore/katie_qlatin1string_wrapper.h new file mode 100644 index 000000000..a9f515463 --- /dev/null +++ b/bindings/KtCore/katie_qlatin1string_wrapper.h @@ -0,0 +1,47 @@ +/**************************************************************************** +** +** Copyright (C) 2015 The Qt Company Ltd. +** Contact: http://www.qt.io/licensing/ +** +** This file is part of the FOO module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of The Qt Company Ltd nor the names of its +** contributors may be used to endorse or promote products derived +** from this software without specific prior written permission. +** +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef SBK_KATIE_QLATIN1STRING_H +#define SBK_KATIE_QLATIN1STRING_H + +#include + +#endif // SBK_KATIE_QLATIN1STRING_H + diff --git a/bindings/KtCore/katie_qobject_wrapper.cpp b/bindings/KtCore/katie_qobject_wrapper.cpp new file mode 100644 index 000000000..82f389b24 --- /dev/null +++ b/bindings/KtCore/katie_qobject_wrapper.cpp @@ -0,0 +1,1699 @@ +/**************************************************************************** +** +** Copyright (C) 2015 The Qt Company Ltd. +** Contact: http://www.qt.io/licensing/ +** +** This file is part of the FOO module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of The Qt Company Ltd nor the names of its +** contributors may be used to endorse or promote products derived +** from this software without specific prior written permission. +** +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + +// default includes +#include +#include + +// module include +#include "ktcore_python.h" + +// main header +#include "katie_qobject_wrapper.h" + +// inner classes + +// Extra includes +#include +#include + + +#include +#include +using namespace Katie; + + + +template +static const char *typeNameOf(const T &t) +{ + const char *typeName = typeid(t).name(); + auto size = std::strlen(typeName); +#if defined(Q_CC_MSVC) // MSVC: "class QPaintDevice * __ptr64" + if (auto lastStar = strchr(typeName, '*')) { + // MSVC: "class QPaintDevice * __ptr64" + while (*--lastStar == ' ') { + } + size = lastStar - typeName + 1; + } +#else // g++, Clang: "QPaintDevice *" -> "P12QPaintDevice" + if (size > 2 && typeName[0] == 'P' && std::isdigit(typeName[1])) { + ++typeName; + --size; + } +#endif + char *result = new char[size + 1]; + result[size] = '\0'; + memcpy(result, typeName, size); + return result; +} + +// Native --------------------------------------------------------- + +QObjectWrapper::QObjectWrapper(Katie::QObject * parent) : Katie::QObject(parent) +{ + // ... middle +} + +void QObjectWrapper::connectNotify(const char * signal) +{ + Shiboken::GilState gil; + if (PyErr_Occurred()) + return; + Shiboken::AutoDecRef pyOverride(Shiboken::BindingManager::instance().getOverride(this, "connectNotify")); + if (pyOverride.isNull()) { + gil.release(); + this->::Katie::QObject::connectNotify(signal); + return; + } + + Shiboken::AutoDecRef pyArgs(Py_BuildValue("(N)", + Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), signal) + )); + + Shiboken::AutoDecRef pyResult(PyObject_Call(pyOverride, pyArgs, nullptr)); + // An error happened in python code! + if (pyResult.isNull()) { + PyErr_Print(); + return; + } +} + +void QObjectWrapper::disconnectNotify(const char * signal) +{ + Shiboken::GilState gil; + if (PyErr_Occurred()) + return; + Shiboken::AutoDecRef pyOverride(Shiboken::BindingManager::instance().getOverride(this, "disconnectNotify")); + if (pyOverride.isNull()) { + gil.release(); + this->::Katie::QObject::disconnectNotify(signal); + return; + } + + Shiboken::AutoDecRef pyArgs(Py_BuildValue("(N)", + Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), signal) + )); + + Shiboken::AutoDecRef pyResult(PyObject_Call(pyOverride, pyArgs, nullptr)); + // An error happened in python code! + if (pyResult.isNull()) { + PyErr_Print(); + return; + } +} + +QObjectWrapper::~QObjectWrapper() +{ + SbkObject* wrapper = Shiboken::BindingManager::instance().retrieveWrapper(this); + Shiboken::Object::destroy(wrapper, this); +} + +// Target --------------------------------------------------------- + +extern "C" { +static int +Sbk_Katie_QObject_Init(PyObject* self, PyObject* args, PyObject* kwds) +{ + SbkObject* sbkSelf = reinterpret_cast(self); + if (Shiboken::Object::isUserType(self) && !Shiboken::ObjectType::canCallConstructor(self->ob_type, Shiboken::SbkType< ::Katie::QObject >())) + return -1; + + ::QObjectWrapper* cptr{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QObject(): too many arguments"); + return -1; + } + + if (!PyArg_ParseTuple(args, "|O:QObject", &(pyArgs[0]))) + return -1; + + + // Overloaded function decisor + // 0: QObject::QObject(Katie::QObject*) + if (numArgs == 0) { + overloadId = 0; // QObject(Katie::QObject*) + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppPointerConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX]), (pyArgs[0])))) { + overloadId = 0; // QObject(Katie::QObject*) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QObject_Init_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "parent"); + if (value && pyArgs[0]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QObject(): got multiple values for keyword argument 'parent'."); + return -1; + } else if (value) { + pyArgs[0] = value; + if (!(pythonToCpp[0] = Shiboken::Conversions::isPythonToCppPointerConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX]), (pyArgs[0])))) + goto Sbk_Katie_QObject_Init_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return -1; + ::Katie::QObject* cppArg0 = Q_NULLPTR; + if (pythonToCpp[0]) pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // QObject(Katie::QObject*) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cptr = new ::QObjectWrapper(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + Shiboken::Object::setParent(pyArgs[0], self); + } + } + + if (PyErr_Occurred() || !Shiboken::Object::setCppPointer(sbkSelf, Shiboken::SbkType< ::Katie::QObject >(), cptr)) { + delete cptr; + return -1; + } + if (!cptr) goto Sbk_Katie_QObject_Init_TypeError; + + Shiboken::Object::setValidCpp(sbkSelf, true); + Shiboken::Object::setHasCppWrapper(sbkSelf, true); + if (Shiboken::BindingManager::instance().hasWrapper(cptr)) { + Shiboken::BindingManager::instance().releaseWrapper(Shiboken::BindingManager::instance().retrieveWrapper(cptr)); + } + Shiboken::BindingManager::instance().registerWrapper(sbkSelf, cptr); + + + return 1; + + Sbk_Katie_QObject_Init_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QObject"); + return -1; +} + +static PyObject* Sbk_Katie_QObjectFunc_blockSignals(PyObject* self, PyObject* pyArg) +{ + QObjectWrapper* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = static_cast(reinterpret_cast< ::Katie::QObject *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX], reinterpret_cast(self)))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QObject::blockSignals(bool) + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // blockSignals(bool) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QObjectFunc_blockSignals_TypeError; + + // Call function/method + { + bool cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // blockSignals(bool) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + bool cppResult = cppSelf->blockSignals(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QObjectFunc_blockSignals_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QObject.blockSignals"); + return {}; +} + +static PyObject* Sbk_Katie_QObjectFunc_connect(PyObject* self, PyObject* args, PyObject* kwds) +{ + QObjectWrapper* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (self) { + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = static_cast(reinterpret_cast< ::Katie::QObject *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX], reinterpret_cast(self)))); + } + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr, nullptr, nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0, 0, 0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 5) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QObject.connect(): too many arguments"); + return {}; + } else if (numArgs < 3) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QObject.connect(): not enough arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OOOOO:connect", &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2]), &(pyArgs[3]), &(pyArgs[4]))) + return {}; + + + // Overloaded function decisor + // 0: static QObject::connect(const Katie::QObject*,const char*,const Katie::QObject*,const char*,Katie::Qt::ConnectionType) + // 1: QObject::connect(const Katie::QObject*,const char*,const char*,Katie::Qt::ConnectionType)const + if (numArgs >= 2 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppPointerConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX]), (pyArgs[0]))) + && Shiboken::String::check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + if (Shiboken::String::check(pyArgs[2]) && (pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) { + if (numArgs == 3) { + overloadId = 1; // connect(const Katie::QObject*,const char*,const char*,Katie::Qt::ConnectionType)const + } else if ((pythonToCpp[3] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CONNECTIONTYPE_IDX])->converter, (pyArgs[3])))) { + overloadId = 1; // connect(const Katie::QObject*,const char*,const char*,Katie::Qt::ConnectionType)const + } + } else if (numArgs >= 4 + && (pythonToCpp[2] = Shiboken::Conversions::isPythonToCppPointerConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX]), (pyArgs[2]))) + && Shiboken::String::check(pyArgs[3]) && (pythonToCpp[3] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[3])))) { + if (numArgs == 4) { + overloadId = 0; // connect(const Katie::QObject*,const char*,const Katie::QObject*,const char*,Katie::Qt::ConnectionType) + } else if ((pythonToCpp[4] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CONNECTIONTYPE_IDX])->converter, (pyArgs[4])))) { + overloadId = 0; // connect(const Katie::QObject*,const char*,const Katie::QObject*,const char*,Katie::Qt::ConnectionType) + } + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QObjectFunc_connect_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // connect(const Katie::QObject * sender, const char * signal, const Katie::QObject * receiver, const char * member, Katie::Qt::ConnectionType type) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "type"); + if (value && pyArgs[4]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QObject.connect(): got multiple values for keyword argument 'type'."); + return {}; + } else if (value) { + pyArgs[4] = value; + if (!(pythonToCpp[4] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CONNECTIONTYPE_IDX])->converter, (pyArgs[4])))) + goto Sbk_Katie_QObjectFunc_connect_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QObject* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + const char* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + if (!Shiboken::Object::isValid(pyArgs[2])) + return {}; + ::Katie::QObject* cppArg2; + pythonToCpp[2](pyArgs[2], &cppArg2); + const char* cppArg3; + pythonToCpp[3](pyArgs[3], &cppArg3); + ::Katie::Qt::ConnectionType cppArg4 = Katie::Qt::AutoConnection; + if (pythonToCpp[4]) pythonToCpp[4](pyArgs[4], &cppArg4); + + if (!PyErr_Occurred()) { + // connect(const Katie::QObject*,const char*,const Katie::QObject*,const char*,Katie::Qt::ConnectionType) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + bool cppResult = ::Katie::QObject::connect(cppArg0, cppArg1, cppArg2, cppArg3, cppArg4); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 1: // connect(const Katie::QObject * sender, const char * signal, const char * member, Katie::Qt::ConnectionType type) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "type"); + if (value && pyArgs[3]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QObject.connect(): got multiple values for keyword argument 'type'."); + return {}; + } else if (value) { + pyArgs[3] = value; + if (!(pythonToCpp[3] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CONNECTIONTYPE_IDX])->converter, (pyArgs[3])))) + goto Sbk_Katie_QObjectFunc_connect_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QObject* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + const char* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + const char* cppArg2; + pythonToCpp[2](pyArgs[2], &cppArg2); + ::Katie::Qt::ConnectionType cppArg3 = Katie::Qt::AutoConnection; + if (pythonToCpp[3]) pythonToCpp[3](pyArgs[3], &cppArg3); + + if (!PyErr_Occurred()) { + // connect(const Katie::QObject*,const char*,const char*,Katie::Qt::ConnectionType)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + bool cppResult = const_cast(cppSelf)->connect(cppArg0, cppArg1, cppArg2, cppArg3); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QObjectFunc_connect_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QObject.connect"); + return {}; +} + +static PyObject* Sbk_Katie_QObjectFunc_connectNotify(PyObject* self, PyObject* pyArg) +{ + QObjectWrapper* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = static_cast(reinterpret_cast< ::Katie::QObject *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX], reinterpret_cast(self)))); + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QObject::connectNotify(const char*) + if (Shiboken::String::check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // connectNotify(const char*) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QObjectFunc_connectNotify_TypeError; + + // Call function/method + { + const char* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // connectNotify(const char*) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + static_cast<::QObjectWrapper*>(cppSelf)->QObjectWrapper::connectNotify_protected(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; + + Sbk_Katie_QObjectFunc_connectNotify_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QObject.connectNotify"); + return {}; +} + +static PyObject* Sbk_Katie_QObjectFunc_deleteLater(PyObject* self) +{ + QObjectWrapper* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = static_cast(reinterpret_cast< ::Katie::QObject *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX], reinterpret_cast(self)))); + + // Call function/method + { + + if (!PyErr_Occurred()) { + // deleteLater() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cppSelf->deleteLater(); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; +} + +static PyObject* Sbk_Katie_QObjectFunc_destroyed(PyObject* self, PyObject* args, PyObject* kwds) +{ + QObjectWrapper* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = static_cast(reinterpret_cast< ::Katie::QObject *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX], reinterpret_cast(self)))); + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QObject.destroyed(): too many arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|O:destroyed", &(pyArgs[0]))) + return {}; + + + // Overloaded function decisor + // 0: QObject::destroyed(Katie::QObject*) + if (numArgs == 0) { + overloadId = 0; // destroyed(Katie::QObject*) + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppPointerConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX]), (pyArgs[0])))) { + overloadId = 0; // destroyed(Katie::QObject*) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QObjectFunc_destroyed_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "arg__1"); + if (value && pyArgs[0]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QObject.destroyed(): got multiple values for keyword argument 'arg__1'."); + return {}; + } else if (value) { + pyArgs[0] = value; + if (!(pythonToCpp[0] = Shiboken::Conversions::isPythonToCppPointerConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX]), (pyArgs[0])))) + goto Sbk_Katie_QObjectFunc_destroyed_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QObject* cppArg0 = Q_NULLPTR; + if (pythonToCpp[0]) pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // destroyed(Katie::QObject*) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + static_cast<::QObjectWrapper*>(cppSelf)->QObjectWrapper::destroyed_protected(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; + + Sbk_Katie_QObjectFunc_destroyed_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QObject.destroyed"); + return {}; +} + +static PyObject* Sbk_Katie_QObjectFunc_disconnect(PyObject* self, PyObject* args, PyObject* kwds) +{ + QObjectWrapper* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (self) { + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = static_cast(reinterpret_cast< ::Katie::QObject *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX], reinterpret_cast(self)))); + } + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr, nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0, 0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 4) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QObject.disconnect(): too many arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OOOO:disconnect", &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2]), &(pyArgs[3]))) + return {}; + + + // Overloaded function decisor + // 0: QObject::disconnect(const Katie::QObject*,const char*) + // 1: static QObject::disconnect(const Katie::QObject*,const char*,const Katie::QObject*,const char*) + // 2: QObject::disconnect(const char*,const Katie::QObject*,const char*) + if (numArgs == 0) { + overloadId = 2; // disconnect(const char*,const Katie::QObject*,const char*) + } else if (Shiboken::String::check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 2; // disconnect(const char*,const Katie::QObject*,const char*) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppPointerConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX]), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 2; // disconnect(const char*,const Katie::QObject*,const char*) + } else if (Shiboken::String::check(pyArgs[2]) && (pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) { + overloadId = 2; // disconnect(const char*,const Katie::QObject*,const char*) + } + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppPointerConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX]), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // disconnect(const Katie::QObject*,const char*) + } else if (Shiboken::String::check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 0; // disconnect(const Katie::QObject*,const char*) + } else if (numArgs == 4 + && (pythonToCpp[2] = Shiboken::Conversions::isPythonToCppPointerConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX]), (pyArgs[2]))) + && Shiboken::String::check(pyArgs[3]) && (pythonToCpp[3] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[3])))) { + overloadId = 1; // disconnect(const Katie::QObject*,const char*,const Katie::QObject*,const char*) + } + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QObjectFunc_disconnect_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // disconnect(const Katie::QObject * receiver, const char * member) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "member"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QObject.disconnect(): got multiple values for keyword argument 'member'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!Shiboken::String::check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QObjectFunc_disconnect_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QObject* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + const char* cppArg1 = Q_NULLPTR; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // disconnect(const Katie::QObject*,const char*) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + bool cppResult = cppSelf->disconnect(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 1: // disconnect(const Katie::QObject * sender, const char * signal, const Katie::QObject * receiver, const char * member) + { + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QObject* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + const char* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + if (!Shiboken::Object::isValid(pyArgs[2])) + return {}; + ::Katie::QObject* cppArg2; + pythonToCpp[2](pyArgs[2], &cppArg2); + const char* cppArg3; + pythonToCpp[3](pyArgs[3], &cppArg3); + + if (!PyErr_Occurred()) { + // disconnect(const Katie::QObject*,const char*,const Katie::QObject*,const char*) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + bool cppResult = ::Katie::QObject::disconnect(cppArg0, cppArg1, cppArg2, cppArg3); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 2: // disconnect(const char * signal, const Katie::QObject * receiver, const char * member) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "signal"); + if (value && pyArgs[0]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QObject.disconnect(): got multiple values for keyword argument 'signal'."); + return {}; + } else if (value) { + pyArgs[0] = value; + if (!Shiboken::String::check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) + goto Sbk_Katie_QObjectFunc_disconnect_TypeError; + } + value = PyDict_GetItemString(kwds, "receiver"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QObject.disconnect(): got multiple values for keyword argument 'receiver'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppPointerConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX]), (pyArgs[1])))) + goto Sbk_Katie_QObjectFunc_disconnect_TypeError; + } + value = PyDict_GetItemString(kwds, "member"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QObject.disconnect(): got multiple values for keyword argument 'member'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!Shiboken::String::check(pyArgs[2]) && (pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) + goto Sbk_Katie_QObjectFunc_disconnect_TypeError; + } + } + const char* cppArg0 = Q_NULLPTR; + if (pythonToCpp[0]) pythonToCpp[0](pyArgs[0], &cppArg0); + if (!Shiboken::Object::isValid(pyArgs[1])) + return {}; + ::Katie::QObject* cppArg1 = Q_NULLPTR; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + const char* cppArg2 = Q_NULLPTR; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // disconnect(const char*,const Katie::QObject*,const char*) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + bool cppResult = cppSelf->disconnect(cppArg0, cppArg1, cppArg2); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QObjectFunc_disconnect_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QObject.disconnect"); + return {}; +} + +static PyObject* Sbk_Katie_QObjectFunc_disconnectNotify(PyObject* self, PyObject* pyArg) +{ + QObjectWrapper* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = static_cast(reinterpret_cast< ::Katie::QObject *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX], reinterpret_cast(self)))); + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QObject::disconnectNotify(const char*) + if (Shiboken::String::check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // disconnectNotify(const char*) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QObjectFunc_disconnectNotify_TypeError; + + // Call function/method + { + const char* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // disconnectNotify(const char*) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + static_cast<::QObjectWrapper*>(cppSelf)->QObjectWrapper::disconnectNotify_protected(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; + + Sbk_Katie_QObjectFunc_disconnectNotify_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QObject.disconnectNotify"); + return {}; +} + +static PyObject* Sbk_Katie_QObjectFunc_dumpObjectInfo(PyObject* self) +{ + QObjectWrapper* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = static_cast(reinterpret_cast< ::Katie::QObject *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX], reinterpret_cast(self)))); + + // Call function/method + { + + if (!PyErr_Occurred()) { + // dumpObjectInfo() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cppSelf->dumpObjectInfo(); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; +} + +static PyObject* Sbk_Katie_QObjectFunc_dumpObjectTree(PyObject* self) +{ + QObjectWrapper* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = static_cast(reinterpret_cast< ::Katie::QObject *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX], reinterpret_cast(self)))); + + // Call function/method + { + + if (!PyErr_Occurred()) { + // dumpObjectTree() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cppSelf->dumpObjectTree(); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; +} + +static PyObject* Sbk_Katie_QObjectFunc_inherits(PyObject* self, PyObject* pyArg) +{ + QObjectWrapper* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = static_cast(reinterpret_cast< ::Katie::QObject *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX], reinterpret_cast(self)))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QObject::inherits(const char*)const + if (Shiboken::String::check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // inherits(const char*)const + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QObjectFunc_inherits_TypeError; + + // Call function/method + { + const char* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // inherits(const char*)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + bool cppResult = const_cast(cppSelf)->inherits(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QObjectFunc_inherits_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QObject.inherits"); + return {}; +} + +static PyObject* Sbk_Katie_QObjectFunc_installEventFilter(PyObject* self, PyObject* pyArg) +{ + QObjectWrapper* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = static_cast(reinterpret_cast< ::Katie::QObject *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX], reinterpret_cast(self)))); + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QObject::installEventFilter(Katie::QObject*) + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppPointerConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX]), (pyArg)))) { + overloadId = 0; // installEventFilter(Katie::QObject*) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QObjectFunc_installEventFilter_TypeError; + + // Call function/method + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QObject* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // installEventFilter(Katie::QObject*) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cppSelf->installEventFilter(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; + + Sbk_Katie_QObjectFunc_installEventFilter_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QObject.installEventFilter"); + return {}; +} + +static PyObject* Sbk_Katie_QObjectFunc_isWidgetType(PyObject* self) +{ + QObjectWrapper* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = static_cast(reinterpret_cast< ::Katie::QObject *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX], reinterpret_cast(self)))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // isWidgetType()const + bool cppResult = const_cast(cppSelf)->isWidgetType(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QObjectFunc_killTimer(PyObject* self, PyObject* pyArg) +{ + QObjectWrapper* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = static_cast(reinterpret_cast< ::Katie::QObject *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX], reinterpret_cast(self)))); + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QObject::killTimer(int) + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // killTimer(int) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QObjectFunc_killTimer_TypeError; + + // Call function/method + { + int cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // killTimer(int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cppSelf->killTimer(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; + + Sbk_Katie_QObjectFunc_killTimer_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QObject.killTimer"); + return {}; +} + +static PyObject* Sbk_Katie_QObjectFunc_objectName(PyObject* self) +{ + QObjectWrapper* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = static_cast(reinterpret_cast< ::Katie::QObject *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX], reinterpret_cast(self)))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // objectName()const + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->objectName()); + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QObjectFunc_parent(PyObject* self) +{ + QObjectWrapper* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = static_cast(reinterpret_cast< ::Katie::QObject *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX], reinterpret_cast(self)))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // parent()const + Katie::QObject * cppResult = const_cast(cppSelf)->parent(); + pyResult = Shiboken::Conversions::pointerToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX]), cppResult); + Shiboken::Object::setParent(self, pyResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QObjectFunc_receivers(PyObject* self, PyObject* pyArg) +{ + QObjectWrapper* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = static_cast(reinterpret_cast< ::Katie::QObject *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX], reinterpret_cast(self)))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QObject::receivers(const char*)const + if (Shiboken::String::check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // receivers(const char*)const + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QObjectFunc_receivers_TypeError; + + // Call function/method + { + const char* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // receivers(const char*)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + int cppResult = static_cast<::QObjectWrapper*>(cppSelf)->QObjectWrapper::receivers_protected(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QObjectFunc_receivers_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QObject.receivers"); + return {}; +} + +static PyObject* Sbk_Katie_QObjectFunc_removeEventFilter(PyObject* self, PyObject* pyArg) +{ + QObjectWrapper* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = static_cast(reinterpret_cast< ::Katie::QObject *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX], reinterpret_cast(self)))); + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QObject::removeEventFilter(Katie::QObject*) + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppPointerConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX]), (pyArg)))) { + overloadId = 0; // removeEventFilter(Katie::QObject*) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QObjectFunc_removeEventFilter_TypeError; + + // Call function/method + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QObject* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // removeEventFilter(Katie::QObject*) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cppSelf->removeEventFilter(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; + + Sbk_Katie_QObjectFunc_removeEventFilter_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QObject.removeEventFilter"); + return {}; +} + +static PyObject* Sbk_Katie_QObjectFunc_sender(PyObject* self) +{ + QObjectWrapper* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = static_cast(reinterpret_cast< ::Katie::QObject *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX], reinterpret_cast(self)))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // sender()const + Katie::QObject * cppResult = static_cast<::QObjectWrapper*>(cppSelf)->QObjectWrapper::sender_protected(); + pyResult = Shiboken::Conversions::pointerToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX]), cppResult); + Shiboken::Object::setParent(self, pyResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QObjectFunc_senderSignalIndex(PyObject* self) +{ + QObjectWrapper* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = static_cast(reinterpret_cast< ::Katie::QObject *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX], reinterpret_cast(self)))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // senderSignalIndex()const + int cppResult = static_cast<::QObjectWrapper*>(cppSelf)->QObjectWrapper::senderSignalIndex_protected(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QObjectFunc_setObjectName(PyObject* self, PyObject* pyArg) +{ + QObjectWrapper* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = static_cast(reinterpret_cast< ::Katie::QObject *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX], reinterpret_cast(self)))); + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QObject::setObjectName(Katie::QString) + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArg)))) { + overloadId = 0; // setObjectName(Katie::QString) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QObjectFunc_setObjectName_TypeError; + + // Call function/method + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // setObjectName(Katie::QString) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cppSelf->setObjectName(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; + + Sbk_Katie_QObjectFunc_setObjectName_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QObject.setObjectName"); + return {}; +} + +static PyObject* Sbk_Katie_QObjectFunc_setParent(PyObject* self, PyObject* pyArg) +{ + QObjectWrapper* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = static_cast(reinterpret_cast< ::Katie::QObject *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX], reinterpret_cast(self)))); + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QObject::setParent(Katie::QObject*) + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppPointerConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX]), (pyArg)))) { + overloadId = 0; // setParent(Katie::QObject*) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QObjectFunc_setParent_TypeError; + + // Call function/method + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QObject* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // setParent(Katie::QObject*) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cppSelf->setParent(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; + + Sbk_Katie_QObjectFunc_setParent_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QObject.setParent"); + return {}; +} + +static PyObject* Sbk_Katie_QObjectFunc_signalsBlocked(PyObject* self) +{ + QObjectWrapper* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = static_cast(reinterpret_cast< ::Katie::QObject *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX], reinterpret_cast(self)))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // signalsBlocked()const + bool cppResult = const_cast(cppSelf)->signalsBlocked(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QObjectFunc_startTimer(PyObject* self, PyObject* pyArg) +{ + QObjectWrapper* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = static_cast(reinterpret_cast< ::Katie::QObject *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX], reinterpret_cast(self)))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QObject::startTimer(int) + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // startTimer(int) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QObjectFunc_startTimer_TypeError; + + // Call function/method + { + int cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // startTimer(int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + int cppResult = cppSelf->startTimer(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QObjectFunc_startTimer_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QObject.startTimer"); + return {}; +} + +static PyObject* Sbk_Katie_QObjectFunc_tr(PyObject* self, PyObject* args) +{ + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0, 0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "tr", 3, 3, &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2]))) + return {}; + + + // Overloaded function decisor + // 0: static QObject::tr(const char*,const char*,int) + if (numArgs == 3 + && Shiboken::String::check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0]))) + && Shiboken::String::check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1]))) + && (pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) { + overloadId = 0; // tr(const char*,const char*,int) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QObjectFunc_tr_TypeError; + + // Call function/method + { + const char* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + const char* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + int cppArg2; + pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // tr(const char*,const char*,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(::Katie::QObject::tr(cppArg0, cppArg1, cppArg2)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QObjectFunc_tr_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QObject.tr"); + return {}; +} + +static PyObject* Sbk_Katie_QObjectFunc_trUtf8(PyObject* self, PyObject* args) +{ + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0, 0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "trUtf8", 3, 3, &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2]))) + return {}; + + + // Overloaded function decisor + // 0: static QObject::trUtf8(const char*,const char*,int) + if (numArgs == 3 + && Shiboken::String::check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0]))) + && Shiboken::String::check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1]))) + && (pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) { + overloadId = 0; // trUtf8(const char*,const char*,int) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QObjectFunc_trUtf8_TypeError; + + // Call function/method + { + const char* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + const char* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + int cppArg2; + pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // trUtf8(const char*,const char*,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(::Katie::QObject::trUtf8(cppArg0, cppArg1, cppArg2)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QObjectFunc_trUtf8_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QObject.trUtf8"); + return {}; +} + +static PyMethodDef Sbk_Katie_QObjectMethod_connect = { + "connect", reinterpret_cast(Sbk_Katie_QObjectFunc_connect), METH_VARARGS|METH_KEYWORDS|METH_STATIC +}; + +static PyMethodDef Sbk_Katie_QObjectMethod_disconnect = { + "disconnect", reinterpret_cast(Sbk_Katie_QObjectFunc_disconnect), METH_VARARGS|METH_KEYWORDS|METH_STATIC +}; + +static PyMethodDef Sbk_Katie_QObject_methods[] = { + {"blockSignals", reinterpret_cast(Sbk_Katie_QObjectFunc_blockSignals), METH_O}, + Sbk_Katie_QObjectMethod_connect, + {"connectNotify", reinterpret_cast(Sbk_Katie_QObjectFunc_connectNotify), METH_O}, + {"deleteLater", reinterpret_cast(Sbk_Katie_QObjectFunc_deleteLater), METH_NOARGS}, + {"destroyed", reinterpret_cast(Sbk_Katie_QObjectFunc_destroyed), METH_VARARGS|METH_KEYWORDS}, + Sbk_Katie_QObjectMethod_disconnect, + {"disconnectNotify", reinterpret_cast(Sbk_Katie_QObjectFunc_disconnectNotify), METH_O}, + {"dumpObjectInfo", reinterpret_cast(Sbk_Katie_QObjectFunc_dumpObjectInfo), METH_NOARGS}, + {"dumpObjectTree", reinterpret_cast(Sbk_Katie_QObjectFunc_dumpObjectTree), METH_NOARGS}, + {"inherits", reinterpret_cast(Sbk_Katie_QObjectFunc_inherits), METH_O}, + {"installEventFilter", reinterpret_cast(Sbk_Katie_QObjectFunc_installEventFilter), METH_O}, + {"isWidgetType", reinterpret_cast(Sbk_Katie_QObjectFunc_isWidgetType), METH_NOARGS}, + {"killTimer", reinterpret_cast(Sbk_Katie_QObjectFunc_killTimer), METH_O}, + {"objectName", reinterpret_cast(Sbk_Katie_QObjectFunc_objectName), METH_NOARGS}, + {"parent", reinterpret_cast(Sbk_Katie_QObjectFunc_parent), METH_NOARGS}, + {"receivers", reinterpret_cast(Sbk_Katie_QObjectFunc_receivers), METH_O}, + {"removeEventFilter", reinterpret_cast(Sbk_Katie_QObjectFunc_removeEventFilter), METH_O}, + {"sender", reinterpret_cast(Sbk_Katie_QObjectFunc_sender), METH_NOARGS}, + {"senderSignalIndex", reinterpret_cast(Sbk_Katie_QObjectFunc_senderSignalIndex), METH_NOARGS}, + {"setObjectName", reinterpret_cast(Sbk_Katie_QObjectFunc_setObjectName), METH_O}, + {"setParent", reinterpret_cast(Sbk_Katie_QObjectFunc_setParent), METH_O}, + {"signalsBlocked", reinterpret_cast(Sbk_Katie_QObjectFunc_signalsBlocked), METH_NOARGS}, + {"startTimer", reinterpret_cast(Sbk_Katie_QObjectFunc_startTimer), METH_O}, + {"tr", reinterpret_cast(Sbk_Katie_QObjectFunc_tr), METH_VARARGS|METH_STATIC}, + {"trUtf8", reinterpret_cast(Sbk_Katie_QObjectFunc_trUtf8), METH_VARARGS|METH_STATIC}, + + {nullptr, nullptr} // Sentinel +}; + +static PyObject* Sbk_Katie_QObject_getattro(PyObject* self, PyObject* name) +{ + if (self) { + // Search the method in the instance dict + if (reinterpret_cast(self)->ob_dict) { + PyObject* meth = PyDict_GetItem(reinterpret_cast(self)->ob_dict, name); + if (meth) { + Py_INCREF(meth); + return meth; + } + } + // Search the method in the type dict + if (Shiboken::Object::isUserType(self)) { + Shiboken::AutoDecRef tmp(_Pep_PrivateMangle(self, name)); + PyObject *meth = PyDict_GetItem(Py_TYPE(self)->tp_dict, tmp); + if (meth) + return PyFunction_Check(meth) ? SBK_PyMethod_New(meth, self) : PyObject_GenericGetAttr(self, name); + } + static PyMethodDef non_static_Sbk_Katie_QObjectMethod_connect = { + Sbk_Katie_QObjectMethod_connect.ml_name, + Sbk_Katie_QObjectMethod_connect.ml_meth, + Sbk_Katie_QObjectMethod_connect.ml_flags & (~METH_STATIC), + Sbk_Katie_QObjectMethod_connect.ml_doc, + }; + if (Shiboken::String::compare(name, "connect") == 0) + return PyCFunction_NewEx(&non_static_Sbk_Katie_QObjectMethod_connect, self, 0); + static PyMethodDef non_static_Sbk_Katie_QObjectMethod_disconnect = { + Sbk_Katie_QObjectMethod_disconnect.ml_name, + Sbk_Katie_QObjectMethod_disconnect.ml_meth, + Sbk_Katie_QObjectMethod_disconnect.ml_flags & (~METH_STATIC), + Sbk_Katie_QObjectMethod_disconnect.ml_doc, + }; + if (Shiboken::String::compare(name, "disconnect") == 0) + return PyCFunction_NewEx(&non_static_Sbk_Katie_QObjectMethod_disconnect, self, 0); + } + return PyObject_GenericGetAttr(self, name); +} + +} // extern "C" + +static int Sbk_Katie_QObject_traverse(PyObject* self, visitproc visit, void* arg) +{ + return reinterpret_cast(SbkObject_TypeF())->tp_traverse(self, visit, arg); +} +static int Sbk_Katie_QObject_clear(PyObject* self) +{ + return reinterpret_cast(SbkObject_TypeF())->tp_clear(self); +} +// Class Definition ----------------------------------------------- +extern "C" { +static SbkObjectType *_Sbk_Katie_QObject_Type = nullptr; +static SbkObjectType *Sbk_Katie_QObject_TypeF(void) +{ + return _Sbk_Katie_QObject_Type; +} + +static PyType_Slot Sbk_Katie_QObject_slots[] = { + {Py_tp_base, nullptr}, // inserted by introduceWrapperType + {Py_tp_dealloc, reinterpret_cast(&SbkDeallocWrapper)}, + {Py_tp_repr, nullptr}, + {Py_tp_hash, nullptr}, + {Py_tp_call, nullptr}, + {Py_tp_str, nullptr}, + {Py_tp_getattro, reinterpret_cast(Sbk_Katie_QObject_getattro)}, + {Py_tp_setattro, nullptr}, + {Py_tp_traverse, reinterpret_cast(Sbk_Katie_QObject_traverse)}, + {Py_tp_clear, reinterpret_cast(Sbk_Katie_QObject_clear)}, + {Py_tp_richcompare, nullptr}, + {Py_tp_iter, nullptr}, + {Py_tp_iternext, nullptr}, + {Py_tp_methods, reinterpret_cast(Sbk_Katie_QObject_methods)}, + {Py_tp_getset, nullptr}, + {Py_tp_init, reinterpret_cast(Sbk_Katie_QObject_Init)}, + {Py_tp_new, reinterpret_cast(SbkObjectTpNew)}, + {0, nullptr} +}; +static PyType_Spec Sbk_Katie_QObject_spec = { + "KtCore.Katie.QObject", + sizeof(SbkObject), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_GC, + Sbk_Katie_QObject_slots +}; + +} //extern "C" + + +// Type conversion functions. + +// Python to C++ pointer conversion - returns the C++ object of the Python wrapper (keeps object identity). +static void QObject_PythonToCpp_QObject_PTR(PyObject* pyIn, void* cppOut) { + Shiboken::Conversions::pythonToCppPointer(Sbk_Katie_QObject_TypeF(), pyIn, cppOut); +} +static PythonToCppFunc is_QObject_PythonToCpp_QObject_PTR_Convertible(PyObject* pyIn) { + if (pyIn == Py_None) + return Shiboken::Conversions::nonePythonToCppNullPtr; + if (PyObject_TypeCheck(pyIn, reinterpret_cast(Sbk_Katie_QObject_TypeF()))) + return QObject_PythonToCpp_QObject_PTR; + return {}; +} + +// C++ to Python pointer conversion - tries to find the Python wrapper for the C++ object (keeps object identity). +static PyObject* QObject_PTR_CppToPython_QObject(const void* cppIn) { + auto pyOut = reinterpret_cast(Shiboken::BindingManager::instance().retrieveWrapper(cppIn)); + if (pyOut) { + Py_INCREF(pyOut); + return pyOut; + } + bool changedTypeName = false; + auto tCppIn = reinterpret_cast(cppIn); + const char *typeName = typeid(*tCppIn).name(); + auto sbkType = Shiboken::ObjectType::typeForTypeName(typeName); + if (sbkType && Shiboken::ObjectType::hasSpecialCastFunction(sbkType)) { + typeName = typeNameOf(tCppIn); + changedTypeName = true; + } + PyObject *result = Shiboken::Object::newObject(Sbk_Katie_QObject_TypeF(), const_cast(cppIn), false, /* exactType */ changedTypeName, typeName); + if (changedTypeName) + delete [] typeName; + return result; +} + +// The signatures string for the functions. +// Multiple signatures have their index "n:" in front. +static const char *Katie_QObject_SignatureStrings[] = { + "KtCore.Katie.QObject(parent:KtCore.Katie.QObject=Q_NULLPTR)", + "KtCore.Katie.QObject.blockSignals(b:bool)->bool", + "1:KtCore.Katie.QObject.connect(sender:KtCore.Katie.QObject,signal:str,receiver:KtCore.Katie.QObject,member:str,type:KtCore.Katie.Qt.ConnectionType=Qt.AutoConnection)->bool", + "0:KtCore.Katie.QObject.connect(sender:KtCore.Katie.QObject,signal:str,member:str,type:KtCore.Katie.Qt.ConnectionType=Qt.AutoConnection)->bool", + "KtCore.Katie.QObject.connectNotify(signal:str)", + "KtCore.Katie.QObject.deleteLater()", + "KtCore.Katie.QObject.destroyed(arg__1:KtCore.Katie.QObject=Q_NULLPTR)", + "2:KtCore.Katie.QObject.disconnect(receiver:KtCore.Katie.QObject,member:str=Q_NULLPTR)->bool", + "1:KtCore.Katie.QObject.disconnect(sender:KtCore.Katie.QObject,signal:str,receiver:KtCore.Katie.QObject,member:str)->bool", + "0:KtCore.Katie.QObject.disconnect(signal:str=Q_NULLPTR,receiver:KtCore.Katie.QObject=Q_NULLPTR,member:str=Q_NULLPTR)->bool", + "KtCore.Katie.QObject.disconnectNotify(signal:str)", + "KtCore.Katie.QObject.dumpObjectInfo()", + "KtCore.Katie.QObject.dumpObjectTree()", + "KtCore.Katie.QObject.inherits(classname:str)->bool", + "KtCore.Katie.QObject.installEventFilter(arg__1:KtCore.Katie.QObject)", + "KtCore.Katie.QObject.isWidgetType()->bool", + "KtCore.Katie.QObject.killTimer(id:int)", + "KtCore.Katie.QObject.objectName()->KtCore.Katie.QString", + "KtCore.Katie.QObject.parent()->KtCore.Katie.QObject", + "KtCore.Katie.QObject.receivers(signal:str)->int", + "KtCore.Katie.QObject.removeEventFilter(arg__1:KtCore.Katie.QObject)", + "KtCore.Katie.QObject.sender()->KtCore.Katie.QObject", + "KtCore.Katie.QObject.senderSignalIndex()->int", + "KtCore.Katie.QObject.setObjectName(name:KtCore.Katie.QString)", + "KtCore.Katie.QObject.setParent(arg__1:KtCore.Katie.QObject)", + "KtCore.Katie.QObject.signalsBlocked()->bool", + "KtCore.Katie.QObject.startTimer(interval:int)->int", + "KtCore.Katie.QObject.tr(s:str,c:str,n:int)->KtCore.Katie.QString", + "KtCore.Katie.QObject.trUtf8(s:str,c:str,n:int)->KtCore.Katie.QString", + nullptr}; // Sentinel + +void init_Katie_QObject(PyObject* module) +{ + _Sbk_Katie_QObject_Type = Shiboken::ObjectType::introduceWrapperType( + module, + "QObject", + "Katie::QObject*", + &Sbk_Katie_QObject_spec, + Katie_QObject_SignatureStrings, + &Shiboken::callCppDestructor< ::Katie::QObject >, + 0, + 0, + 0 ); + + SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX] + = reinterpret_cast(Sbk_Katie_QObject_TypeF()); + + // Register Converter + SbkConverter* converter = Shiboken::Conversions::createConverter(Sbk_Katie_QObject_TypeF(), + QObject_PythonToCpp_QObject_PTR, + is_QObject_PythonToCpp_QObject_PTR_Convertible, + QObject_PTR_CppToPython_QObject); + + Shiboken::Conversions::registerConverterName(converter, "Katie::QObject"); + Shiboken::Conversions::registerConverterName(converter, "Katie::QObject*"); + Shiboken::Conversions::registerConverterName(converter, "Katie::QObject&"); + Shiboken::Conversions::registerConverterName(converter, "QObject"); + Shiboken::Conversions::registerConverterName(converter, "QObject*"); + Shiboken::Conversions::registerConverterName(converter, "QObject&"); + Shiboken::Conversions::registerConverterName(converter, typeid(::Katie::QObject).name()); + Shiboken::Conversions::registerConverterName(converter, typeid(::QObjectWrapper).name()); + + + +} diff --git a/bindings/KtCore/katie_qobject_wrapper.h b/bindings/KtCore/katie_qobject_wrapper.h new file mode 100644 index 000000000..5d0bbcb68 --- /dev/null +++ b/bindings/KtCore/katie_qobject_wrapper.h @@ -0,0 +1,62 @@ +/**************************************************************************** +** +** Copyright (C) 2015 The Qt Company Ltd. +** Contact: http://www.qt.io/licensing/ +** +** This file is part of the FOO module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of The Qt Company Ltd nor the names of its +** contributors may be used to endorse or promote products derived +** from this software without specific prior written permission. +** +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef SBK_QOBJECTWRAPPER_H +#define SBK_QOBJECTWRAPPER_H + +#include + +class QObjectWrapper : public Katie::QObject +{ +public: + QObjectWrapper(Katie::QObject * parent = Q_NULLPTR); + inline void connectNotify_protected(const char * signal) { Katie::QObject::connectNotify(signal); } + void connectNotify(const char * signal) override; + inline void destroyed_protected(Katie::QObject * arg__1 = Q_NULLPTR) { Katie::QObject::destroyed(arg__1); } + inline void disconnectNotify_protected(const char * signal) { Katie::QObject::disconnectNotify(signal); } + void disconnectNotify(const char * signal) override; + inline int receivers_protected(const char * signal) const { return Katie::QObject::receivers(signal); } + inline Katie::QObject * sender_protected() const { return Katie::QObject::sender(); } + inline int senderSignalIndex_protected() const { return Katie::QObject::senderSignalIndex(); } + ~QObjectWrapper(); +}; + +#endif // SBK_QOBJECTWRAPPER_H + diff --git a/bindings/KtCore/katie_qstring_wrapper.cpp b/bindings/KtCore/katie_qstring_wrapper.cpp new file mode 100644 index 000000000..262f9f246 --- /dev/null +++ b/bindings/KtCore/katie_qstring_wrapper.cpp @@ -0,0 +1,9067 @@ +/**************************************************************************** +** +** Copyright (C) 2015 The Qt Company Ltd. +** Contact: http://www.qt.io/licensing/ +** +** This file is part of the FOO module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of The Qt Company Ltd nor the names of its +** contributors may be used to endorse or promote products derived +** from this software without specific prior written permission. +** +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + +// default includes +#include +#include + +// module include +#include "ktcore_python.h" + +// main header +#include "katie_qstring_wrapper.h" + +// inner classes + +// Extra includes +#include +#include +#include + + +#include +#include +using namespace Katie; + + + +template +static const char *typeNameOf(const T &t) +{ + const char *typeName = typeid(t).name(); + auto size = std::strlen(typeName); +#if defined(Q_CC_MSVC) // MSVC: "class QPaintDevice * __ptr64" + if (auto lastStar = strchr(typeName, '*')) { + // MSVC: "class QPaintDevice * __ptr64" + while (*--lastStar == ' ') { + } + size = lastStar - typeName + 1; + } +#else // g++, Clang: "QPaintDevice *" -> "P12QPaintDevice" + if (size > 2 && typeName[0] == 'P' && std::isdigit(typeName[1])) { + ++typeName; + --size; + } +#endif + char *result = new char[size + 1]; + result[size] = '\0'; + memcpy(result, typeName, size); + return result; +} + + +// Target --------------------------------------------------------- + +extern "C" { +static int +Sbk_Katie_QString_Init(PyObject* self, PyObject* args, PyObject* kwds) +{ + SbkObject* sbkSelf = reinterpret_cast(self); + if (Shiboken::Object::isUserType(self) && !Shiboken::ObjectType::canCallConstructor(self->ob_type, Shiboken::SbkType< ::Katie::QString >())) + return -1; + + ::Katie::QString* cptr{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString(): too many arguments"); + return -1; + } + + if (!PyArg_ParseTuple(args, "|OO:QString", &(pyArgs[0]), &(pyArgs[1]))) + return -1; + + + // Overloaded function decisor + // 0: QString::QString() + // 1: QString::QString(Katie::QByteArray) + // 2: QString::QString(const Katie::QChar*,int) + // 3: QString::QString(Katie::QChar) + // 4: QString::QString(Katie::QLatin1String) + // 5: QString::QString(Katie::QString) + // 6: QString::QString(const char*) + // 7: QString::QString(int,Katie::QChar) + // 8: QString::QString(int,Katie::Qt::Initialization) + if (numArgs == 0) { + overloadId = 0; // QString() + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 2 + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_INITIALIZATION_IDX])->converter, (pyArgs[1])))) { + overloadId = 8; // QString(int,Katie::Qt::Initialization) + } else if (numArgs == 2 + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppValueConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[1])))) { + overloadId = 7; // QString(int,Katie::QChar) + } + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 6; // QString(const char*) + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArgs[0])))) { + overloadId = 5; // QString(Katie::QString) + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QLATIN1STRING_IDX]), (pyArgs[0])))) { + overloadId = 4; // QString(Katie::QLatin1String) + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppPointerConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 2; // QString(const Katie::QChar*,int) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 2; // QString(const Katie::QChar*,int) + } + } else if (numArgs == 1 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArgs[0])))) { + overloadId = 1; // QString(Katie::QByteArray) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QString_Init_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // QString() + { + + if (!PyErr_Occurred()) { + // QString() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cptr = new ::Katie::QString(); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 1: // QString(const Katie::QByteArray & a) + { + if (!Shiboken::Object::isValid(pyArgs[0])) + return -1; + ::Katie::QByteArray* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // QString(Katie::QByteArray) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cptr = new ::Katie::QString(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 2: // QString(const Katie::QChar * unicode, int size) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "size"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString(): got multiple values for keyword argument 'size'."); + return -1; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QString_Init_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return -1; + ::Katie::QChar* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = -1; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // QString(const Katie::QChar*,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cptr = new ::Katie::QString(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 3: // QString(const Katie::QChar c) + { + if (!Shiboken::Object::isValid(pyArgs[0])) + return -1; + ::Katie::QChar* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // QString(Katie::QChar) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cptr = new ::Katie::QString(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 4: // QString(const Katie::QLatin1String & latin1) + { + if (!Shiboken::Object::isValid(pyArgs[0])) + return -1; + ::Katie::QLatin1String* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // QString(Katie::QLatin1String) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cptr = new ::Katie::QString(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 5: // QString(const Katie::QString & arg__1) + { + if (!Shiboken::Object::isValid(pyArgs[0])) + return -1; + ::Katie::QString* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // QString(Katie::QString) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cptr = new ::Katie::QString(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 6: // QString(const char * ch) + { + const char* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // QString(const char*) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cptr = new ::Katie::QString(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 7: // QString(const int size, const Katie::QChar c) + { + int cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + if (!Shiboken::Object::isValid(pyArgs[1])) + return -1; + ::Katie::QChar* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // QString(int,Katie::QChar) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cptr = new ::Katie::QString(cppArg0, *cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 8: // QString(int size, Katie::Qt::Initialization arg__2) + { + int cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + ::Katie::Qt::Initialization cppArg1{Katie::Qt::Uninitialized}; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // QString(int,Katie::Qt::Initialization) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cptr = new ::Katie::QString(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + } + + if (PyErr_Occurred() || !Shiboken::Object::setCppPointer(sbkSelf, Shiboken::SbkType< ::Katie::QString >(), cptr)) { + delete cptr; + return -1; + } + if (!cptr) goto Sbk_Katie_QString_Init_TypeError; + + Shiboken::Object::setValidCpp(sbkSelf, true); + if (Shiboken::BindingManager::instance().hasWrapper(cptr)) { + Shiboken::BindingManager::instance().releaseWrapper(Shiboken::BindingManager::instance().retrieveWrapper(cptr)); + } + Shiboken::BindingManager::instance().registerWrapper(sbkSelf, cptr); + + + return 1; + + Sbk_Katie_QString_Init_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString"); + return -1; +} + +static PyObject* Sbk_Katie_QStringFunc_append(PyObject* self, PyObject* pyArg) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QString::append(Katie::QChar) + // 1: QString::append(Katie::QByteArray) + // 2: QString::append(Katie::QLatin1String) + // 3: QString::append(Katie::QString) + // 4: QString::append(const char*) + if (Shiboken::String::check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 4; // append(const char*) + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArg)))) { + overloadId = 3; // append(Katie::QString) + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QLATIN1STRING_IDX]), (pyArg)))) { + overloadId = 2; // append(Katie::QLatin1String) + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArg)))) { + overloadId = 1; // append(Katie::QByteArray) + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppValueConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArg)))) { + overloadId = 0; // append(Katie::QChar) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_append_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // append(Katie::QChar c) + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QChar* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // append(Katie::QChar) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->append(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + case 1: // append(const Katie::QByteArray & s) + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QByteArray* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // append(Katie::QByteArray) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->append(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + case 2: // append(const Katie::QLatin1String & s) + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QLatin1String* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // append(Katie::QLatin1String) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->append(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + case 3: // append(const Katie::QString & s) + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // append(Katie::QString) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->append(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + case 4: // append(const char * s) + { + const char* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // append(const char*) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->append(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_append_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QString.append"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_arg(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 9) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.arg(): too many arguments"); + return {}; + } else if (numArgs < 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.arg(): not enough arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OOOOOOOOO:arg", &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2]), &(pyArgs[3]), &(pyArgs[4]), &(pyArgs[5]), &(pyArgs[6]), &(pyArgs[7]), &(pyArgs[8]))) + return {}; + + + // Overloaded function decisor + // 0: QString::arg(Katie::QChar,int,Katie::QChar)const + // 1: QString::arg(char,int,Katie::QChar)const + // 2: QString::arg(Katie::QString,int,Katie::QChar)const + // 3: QString::arg(Katie::QString,Katie::QString)const + // 4: QString::arg(Katie::QString,Katie::QString,Katie::QString)const + // 5: QString::arg(Katie::QString,Katie::QString,Katie::QString,Katie::QString)const + // 6: QString::arg(Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString)const + // 7: QString::arg(Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString)const + // 8: QString::arg(Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString)const + // 9: QString::arg(Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString)const + // 10: QString::arg(Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString)const + // 11: QString::arg(double,int,char,int,Katie::QChar)const + // 12: QString::arg(int,int,int,Katie::QChar)const + // 13: QString::arg(long,int,int,Katie::QChar)const + // 14: QString::arg(long long,int,int,Katie::QChar)const + // 15: QString::arg(short,int,int,Katie::QChar)const + // 16: QString::arg(uint,int,int,Katie::QChar)const + // 17: QString::arg(ulong,int,int,Katie::QChar)const + // 18: QString::arg(unsigned long long,int,int,Katie::QChar)const + // 19: QString::arg(ushort,int,int,Katie::QChar)const + if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 19; // arg(ushort,int,int,Katie::QChar)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 19; // arg(ushort,int,int,Katie::QChar)const + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) { + if (numArgs == 3) { + overloadId = 19; // arg(ushort,int,int,Katie::QChar)const + } else if ((pythonToCpp[3] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[3])))) { + overloadId = 19; // arg(ushort,int,int,Katie::QChar)const + } + } + } + } else if (PyLong_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 18; // arg(unsigned long long,int,int,Katie::QChar)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 18; // arg(unsigned long long,int,int,Katie::QChar)const + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) { + if (numArgs == 3) { + overloadId = 18; // arg(unsigned long long,int,int,Katie::QChar)const + } else if ((pythonToCpp[3] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[3])))) { + overloadId = 18; // arg(unsigned long long,int,int,Katie::QChar)const + } + } + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 17; // arg(ulong,int,int,Katie::QChar)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 17; // arg(ulong,int,int,Katie::QChar)const + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) { + if (numArgs == 3) { + overloadId = 17; // arg(ulong,int,int,Katie::QChar)const + } else if ((pythonToCpp[3] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[3])))) { + overloadId = 17; // arg(ulong,int,int,Katie::QChar)const + } + } + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 16; // arg(uint,int,int,Katie::QChar)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 16; // arg(uint,int,int,Katie::QChar)const + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) { + if (numArgs == 3) { + overloadId = 16; // arg(uint,int,int,Katie::QChar)const + } else if ((pythonToCpp[3] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[3])))) { + overloadId = 16; // arg(uint,int,int,Katie::QChar)const + } + } + } + } else if (PyLong_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 14; // arg(long long,int,int,Katie::QChar)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 14; // arg(long long,int,int,Katie::QChar)const + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) { + if (numArgs == 3) { + overloadId = 14; // arg(long long,int,int,Katie::QChar)const + } else if ((pythonToCpp[3] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[3])))) { + overloadId = 14; // arg(long long,int,int,Katie::QChar)const + } + } + } + } else if (PyFloat_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 11; // arg(double,int,char,int,Katie::QChar)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 11; // arg(double,int,char,int,Katie::QChar)const + } else if (SbkChar_Check(pyArgs[2]) && (pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) { + if (numArgs == 3) { + overloadId = 11; // arg(double,int,char,int,Katie::QChar)const + } else if ((pythonToCpp[3] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[3])))) { + if (numArgs == 4) { + overloadId = 11; // arg(double,int,char,int,Katie::QChar)const + } else if ((pythonToCpp[4] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[4])))) { + overloadId = 11; // arg(double,int,char,int,Katie::QChar)const + } + } + } + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 15; // arg(short,int,int,Katie::QChar)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 15; // arg(short,int,int,Katie::QChar)const + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) { + if (numArgs == 3) { + overloadId = 15; // arg(short,int,int,Katie::QChar)const + } else if ((pythonToCpp[3] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[3])))) { + overloadId = 15; // arg(short,int,int,Katie::QChar)const + } + } + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 13; // arg(long,int,int,Katie::QChar)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 13; // arg(long,int,int,Katie::QChar)const + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) { + if (numArgs == 3) { + overloadId = 13; // arg(long,int,int,Katie::QChar)const + } else if ((pythonToCpp[3] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[3])))) { + overloadId = 13; // arg(long,int,int,Katie::QChar)const + } + } + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 12; // arg(int,int,int,Katie::QChar)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 12; // arg(int,int,int,Katie::QChar)const + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) { + if (numArgs == 3) { + overloadId = 12; // arg(int,int,int,Katie::QChar)const + } else if ((pythonToCpp[3] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[3])))) { + overloadId = 12; // arg(int,int,int,Katie::QChar)const + } + } + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 2; // arg(Katie::QString,int,Katie::QChar)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 3; // arg(Katie::QString,Katie::QString)const + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArgs[2])))) { + if (numArgs == 3) { + overloadId = 4; // arg(Katie::QString,Katie::QString,Katie::QString)const + } else if ((pythonToCpp[3] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArgs[3])))) { + if (numArgs == 4) { + overloadId = 5; // arg(Katie::QString,Katie::QString,Katie::QString,Katie::QString)const + } else if ((pythonToCpp[4] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArgs[4])))) { + if (numArgs == 5) { + overloadId = 6; // arg(Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString)const + } else if ((pythonToCpp[5] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArgs[5])))) { + if (numArgs == 6) { + overloadId = 7; // arg(Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString)const + } else if ((pythonToCpp[6] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArgs[6])))) { + if (numArgs == 7) { + overloadId = 8; // arg(Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString)const + } else if ((pythonToCpp[7] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArgs[7])))) { + if (numArgs == 8) { + overloadId = 9; // arg(Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString)const + } else if (numArgs == 9 + && (pythonToCpp[8] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArgs[8])))) { + overloadId = 10; // arg(Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString)const + } + } + } + } + } + } + } + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 2; // arg(Katie::QString,int,Katie::QChar)const + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[2])))) { + overloadId = 2; // arg(Katie::QString,int,Katie::QChar)const + } + } + } else if (SbkChar_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 1; // arg(char,int,Katie::QChar)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 1; // arg(char,int,Katie::QChar)const + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[2])))) { + overloadId = 1; // arg(char,int,Katie::QChar)const + } + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppValueConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // arg(Katie::QChar,int,Katie::QChar)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 0; // arg(Katie::QChar,int,Katie::QChar)const + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[2])))) { + overloadId = 0; // arg(Katie::QChar,int,Katie::QChar)const + } + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_arg_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // arg(Katie::QChar a, int fieldWidth, const Katie::QChar & fillChar) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "fieldWidth"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.arg(): got multiple values for keyword argument 'fieldWidth'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_arg_TypeError; + } + value = PyDict_GetItemString(kwds, "fillChar"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.arg(): got multiple values for keyword argument 'fillChar'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[2])))) + goto Sbk_Katie_QStringFunc_arg_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QChar* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 0; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + if (!Shiboken::Object::isValid(pyArgs[2])) + return {}; + ::Katie::QChar* cppArg2 = QLatin1Char(' '); + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // arg(Katie::QChar,int,Katie::QChar)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->arg(*cppArg0, cppArg1, *cppArg2)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + break; + } + case 1: // arg(char a, int fieldWidth, const Katie::QChar & fillChar) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "fieldWidth"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.arg(): got multiple values for keyword argument 'fieldWidth'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_arg_TypeError; + } + value = PyDict_GetItemString(kwds, "fillChar"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.arg(): got multiple values for keyword argument 'fillChar'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[2])))) + goto Sbk_Katie_QStringFunc_arg_TypeError; + } + } + char cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 0; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + if (!Shiboken::Object::isValid(pyArgs[2])) + return {}; + ::Katie::QChar* cppArg2 = QLatin1Char(' '); + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // arg(char,int,Katie::QChar)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->arg(cppArg0, cppArg1, *cppArg2)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + break; + } + case 2: // arg(const Katie::QString & a, int fieldWidth, const Katie::QChar & fillChar) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "fieldWidth"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.arg(): got multiple values for keyword argument 'fieldWidth'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_arg_TypeError; + } + value = PyDict_GetItemString(kwds, "fillChar"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.arg(): got multiple values for keyword argument 'fillChar'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[2])))) + goto Sbk_Katie_QStringFunc_arg_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 0; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + if (!Shiboken::Object::isValid(pyArgs[2])) + return {}; + ::Katie::QChar* cppArg2 = QLatin1Char(' '); + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // arg(Katie::QString,int,Katie::QChar)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->arg(*cppArg0, cppArg1, *cppArg2)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + break; + } + case 3: // arg(const Katie::QString & a1, const Katie::QString & a2) const + { + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + if (!Shiboken::Object::isValid(pyArgs[1])) + return {}; + ::Katie::QString* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // arg(Katie::QString,Katie::QString)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->arg(*cppArg0, *cppArg1)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + break; + } + case 4: // arg(const Katie::QString & a1, const Katie::QString & a2, const Katie::QString & a3) const + { + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + if (!Shiboken::Object::isValid(pyArgs[1])) + return {}; + ::Katie::QString* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + if (!Shiboken::Object::isValid(pyArgs[2])) + return {}; + ::Katie::QString* cppArg2; + pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // arg(Katie::QString,Katie::QString,Katie::QString)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->arg(*cppArg0, *cppArg1, *cppArg2)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + break; + } + case 5: // arg(const Katie::QString & a1, const Katie::QString & a2, const Katie::QString & a3, const Katie::QString & a4) const + { + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + if (!Shiboken::Object::isValid(pyArgs[1])) + return {}; + ::Katie::QString* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + if (!Shiboken::Object::isValid(pyArgs[2])) + return {}; + ::Katie::QString* cppArg2; + pythonToCpp[2](pyArgs[2], &cppArg2); + if (!Shiboken::Object::isValid(pyArgs[3])) + return {}; + ::Katie::QString* cppArg3; + pythonToCpp[3](pyArgs[3], &cppArg3); + + if (!PyErr_Occurred()) { + // arg(Katie::QString,Katie::QString,Katie::QString,Katie::QString)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->arg(*cppArg0, *cppArg1, *cppArg2, *cppArg3)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + break; + } + case 6: // arg(const Katie::QString & a1, const Katie::QString & a2, const Katie::QString & a3, const Katie::QString & a4, const Katie::QString & a5) const + { + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + if (!Shiboken::Object::isValid(pyArgs[1])) + return {}; + ::Katie::QString* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + if (!Shiboken::Object::isValid(pyArgs[2])) + return {}; + ::Katie::QString* cppArg2; + pythonToCpp[2](pyArgs[2], &cppArg2); + if (!Shiboken::Object::isValid(pyArgs[3])) + return {}; + ::Katie::QString* cppArg3; + pythonToCpp[3](pyArgs[3], &cppArg3); + if (!Shiboken::Object::isValid(pyArgs[4])) + return {}; + ::Katie::QString* cppArg4; + pythonToCpp[4](pyArgs[4], &cppArg4); + + if (!PyErr_Occurred()) { + // arg(Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->arg(*cppArg0, *cppArg1, *cppArg2, *cppArg3, *cppArg4)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + break; + } + case 7: // arg(const Katie::QString & a1, const Katie::QString & a2, const Katie::QString & a3, const Katie::QString & a4, const Katie::QString & a5, const Katie::QString & a6) const + { + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + if (!Shiboken::Object::isValid(pyArgs[1])) + return {}; + ::Katie::QString* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + if (!Shiboken::Object::isValid(pyArgs[2])) + return {}; + ::Katie::QString* cppArg2; + pythonToCpp[2](pyArgs[2], &cppArg2); + if (!Shiboken::Object::isValid(pyArgs[3])) + return {}; + ::Katie::QString* cppArg3; + pythonToCpp[3](pyArgs[3], &cppArg3); + if (!Shiboken::Object::isValid(pyArgs[4])) + return {}; + ::Katie::QString* cppArg4; + pythonToCpp[4](pyArgs[4], &cppArg4); + if (!Shiboken::Object::isValid(pyArgs[5])) + return {}; + ::Katie::QString* cppArg5; + pythonToCpp[5](pyArgs[5], &cppArg5); + + if (!PyErr_Occurred()) { + // arg(Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->arg(*cppArg0, *cppArg1, *cppArg2, *cppArg3, *cppArg4, *cppArg5)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + break; + } + case 8: // arg(const Katie::QString & a1, const Katie::QString & a2, const Katie::QString & a3, const Katie::QString & a4, const Katie::QString & a5, const Katie::QString & a6, const Katie::QString & a7) const + { + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + if (!Shiboken::Object::isValid(pyArgs[1])) + return {}; + ::Katie::QString* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + if (!Shiboken::Object::isValid(pyArgs[2])) + return {}; + ::Katie::QString* cppArg2; + pythonToCpp[2](pyArgs[2], &cppArg2); + if (!Shiboken::Object::isValid(pyArgs[3])) + return {}; + ::Katie::QString* cppArg3; + pythonToCpp[3](pyArgs[3], &cppArg3); + if (!Shiboken::Object::isValid(pyArgs[4])) + return {}; + ::Katie::QString* cppArg4; + pythonToCpp[4](pyArgs[4], &cppArg4); + if (!Shiboken::Object::isValid(pyArgs[5])) + return {}; + ::Katie::QString* cppArg5; + pythonToCpp[5](pyArgs[5], &cppArg5); + if (!Shiboken::Object::isValid(pyArgs[6])) + return {}; + ::Katie::QString* cppArg6; + pythonToCpp[6](pyArgs[6], &cppArg6); + + if (!PyErr_Occurred()) { + // arg(Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->arg(*cppArg0, *cppArg1, *cppArg2, *cppArg3, *cppArg4, *cppArg5, *cppArg6)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + break; + } + case 9: // arg(const Katie::QString & a1, const Katie::QString & a2, const Katie::QString & a3, const Katie::QString & a4, const Katie::QString & a5, const Katie::QString & a6, const Katie::QString & a7, const Katie::QString & a8) const + { + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + if (!Shiboken::Object::isValid(pyArgs[1])) + return {}; + ::Katie::QString* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + if (!Shiboken::Object::isValid(pyArgs[2])) + return {}; + ::Katie::QString* cppArg2; + pythonToCpp[2](pyArgs[2], &cppArg2); + if (!Shiboken::Object::isValid(pyArgs[3])) + return {}; + ::Katie::QString* cppArg3; + pythonToCpp[3](pyArgs[3], &cppArg3); + if (!Shiboken::Object::isValid(pyArgs[4])) + return {}; + ::Katie::QString* cppArg4; + pythonToCpp[4](pyArgs[4], &cppArg4); + if (!Shiboken::Object::isValid(pyArgs[5])) + return {}; + ::Katie::QString* cppArg5; + pythonToCpp[5](pyArgs[5], &cppArg5); + if (!Shiboken::Object::isValid(pyArgs[6])) + return {}; + ::Katie::QString* cppArg6; + pythonToCpp[6](pyArgs[6], &cppArg6); + if (!Shiboken::Object::isValid(pyArgs[7])) + return {}; + ::Katie::QString* cppArg7; + pythonToCpp[7](pyArgs[7], &cppArg7); + + if (!PyErr_Occurred()) { + // arg(Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->arg(*cppArg0, *cppArg1, *cppArg2, *cppArg3, *cppArg4, *cppArg5, *cppArg6, *cppArg7)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + break; + } + case 10: // arg(const Katie::QString & a1, const Katie::QString & a2, const Katie::QString & a3, const Katie::QString & a4, const Katie::QString & a5, const Katie::QString & a6, const Katie::QString & a7, const Katie::QString & a8, const Katie::QString & a9) const + { + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + if (!Shiboken::Object::isValid(pyArgs[1])) + return {}; + ::Katie::QString* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + if (!Shiboken::Object::isValid(pyArgs[2])) + return {}; + ::Katie::QString* cppArg2; + pythonToCpp[2](pyArgs[2], &cppArg2); + if (!Shiboken::Object::isValid(pyArgs[3])) + return {}; + ::Katie::QString* cppArg3; + pythonToCpp[3](pyArgs[3], &cppArg3); + if (!Shiboken::Object::isValid(pyArgs[4])) + return {}; + ::Katie::QString* cppArg4; + pythonToCpp[4](pyArgs[4], &cppArg4); + if (!Shiboken::Object::isValid(pyArgs[5])) + return {}; + ::Katie::QString* cppArg5; + pythonToCpp[5](pyArgs[5], &cppArg5); + if (!Shiboken::Object::isValid(pyArgs[6])) + return {}; + ::Katie::QString* cppArg6; + pythonToCpp[6](pyArgs[6], &cppArg6); + if (!Shiboken::Object::isValid(pyArgs[7])) + return {}; + ::Katie::QString* cppArg7; + pythonToCpp[7](pyArgs[7], &cppArg7); + if (!Shiboken::Object::isValid(pyArgs[8])) + return {}; + ::Katie::QString* cppArg8; + pythonToCpp[8](pyArgs[8], &cppArg8); + + if (!PyErr_Occurred()) { + // arg(Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString,Katie::QString)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->arg(*cppArg0, *cppArg1, *cppArg2, *cppArg3, *cppArg4, *cppArg5, *cppArg6, *cppArg7, *cppArg8)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + break; + } + case 11: // arg(double a, int fieldWidth, char fmt, int prec, const Katie::QChar & fillChar) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "fieldWidth"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.arg(): got multiple values for keyword argument 'fieldWidth'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_arg_TypeError; + } + value = PyDict_GetItemString(kwds, "fmt"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.arg(): got multiple values for keyword argument 'fmt'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!SbkChar_Check(pyArgs[2]) && (pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) + goto Sbk_Katie_QStringFunc_arg_TypeError; + } + value = PyDict_GetItemString(kwds, "prec"); + if (value && pyArgs[3]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.arg(): got multiple values for keyword argument 'prec'."); + return {}; + } else if (value) { + pyArgs[3] = value; + if (!(pythonToCpp[3] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[3])))) + goto Sbk_Katie_QStringFunc_arg_TypeError; + } + value = PyDict_GetItemString(kwds, "fillChar"); + if (value && pyArgs[4]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.arg(): got multiple values for keyword argument 'fillChar'."); + return {}; + } else if (value) { + pyArgs[4] = value; + if (!(pythonToCpp[4] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[4])))) + goto Sbk_Katie_QStringFunc_arg_TypeError; + } + } + double cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 0; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + char cppArg2 = 'g'; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + int cppArg3 = -1; + if (pythonToCpp[3]) pythonToCpp[3](pyArgs[3], &cppArg3); + if (!Shiboken::Object::isValid(pyArgs[4])) + return {}; + ::Katie::QChar* cppArg4 = QLatin1Char(' '); + if (pythonToCpp[4]) pythonToCpp[4](pyArgs[4], &cppArg4); + + if (!PyErr_Occurred()) { + // arg(double,int,char,int,Katie::QChar)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->arg(cppArg0, cppArg1, cppArg2, cppArg3, *cppArg4)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + break; + } + case 12: // arg(int a, int fieldWidth, int base, const Katie::QChar & fillChar) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "fieldWidth"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.arg(): got multiple values for keyword argument 'fieldWidth'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_arg_TypeError; + } + value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.arg(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) + goto Sbk_Katie_QStringFunc_arg_TypeError; + } + value = PyDict_GetItemString(kwds, "fillChar"); + if (value && pyArgs[3]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.arg(): got multiple values for keyword argument 'fillChar'."); + return {}; + } else if (value) { + pyArgs[3] = value; + if (!(pythonToCpp[3] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[3])))) + goto Sbk_Katie_QStringFunc_arg_TypeError; + } + } + int cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 0; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + int cppArg2 = 10; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + if (!Shiboken::Object::isValid(pyArgs[3])) + return {}; + ::Katie::QChar* cppArg3 = QLatin1Char(' '); + if (pythonToCpp[3]) pythonToCpp[3](pyArgs[3], &cppArg3); + + if (!PyErr_Occurred()) { + // arg(int,int,int,Katie::QChar)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->arg(cppArg0, cppArg1, cppArg2, *cppArg3)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + break; + } + case 13: // arg(long a, int fieldwidth, int base, const Katie::QChar & fillChar) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "fieldwidth"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.arg(): got multiple values for keyword argument 'fieldwidth'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_arg_TypeError; + } + value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.arg(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) + goto Sbk_Katie_QStringFunc_arg_TypeError; + } + value = PyDict_GetItemString(kwds, "fillChar"); + if (value && pyArgs[3]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.arg(): got multiple values for keyword argument 'fillChar'."); + return {}; + } else if (value) { + pyArgs[3] = value; + if (!(pythonToCpp[3] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[3])))) + goto Sbk_Katie_QStringFunc_arg_TypeError; + } + } + long cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 0; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + int cppArg2 = 10; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + if (!Shiboken::Object::isValid(pyArgs[3])) + return {}; + ::Katie::QChar* cppArg3 = QLatin1Char(' '); + if (pythonToCpp[3]) pythonToCpp[3](pyArgs[3], &cppArg3); + + if (!PyErr_Occurred()) { + // arg(long,int,int,Katie::QChar)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->arg(cppArg0, cppArg1, cppArg2, *cppArg3)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + break; + } + case 14: // arg(long long a, int fieldwidth, int base, const Katie::QChar & fillChar) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "fieldwidth"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.arg(): got multiple values for keyword argument 'fieldwidth'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_arg_TypeError; + } + value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.arg(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) + goto Sbk_Katie_QStringFunc_arg_TypeError; + } + value = PyDict_GetItemString(kwds, "fillChar"); + if (value && pyArgs[3]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.arg(): got multiple values for keyword argument 'fillChar'."); + return {}; + } else if (value) { + pyArgs[3] = value; + if (!(pythonToCpp[3] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[3])))) + goto Sbk_Katie_QStringFunc_arg_TypeError; + } + } + long long cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 0; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + int cppArg2 = 10; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + if (!Shiboken::Object::isValid(pyArgs[3])) + return {}; + ::Katie::QChar* cppArg3 = QLatin1Char(' '); + if (pythonToCpp[3]) pythonToCpp[3](pyArgs[3], &cppArg3); + + if (!PyErr_Occurred()) { + // arg(long long,int,int,Katie::QChar)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->arg(cppArg0, cppArg1, cppArg2, *cppArg3)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + break; + } + case 15: // arg(short a, int fieldWidth, int base, const Katie::QChar & fillChar) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "fieldWidth"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.arg(): got multiple values for keyword argument 'fieldWidth'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_arg_TypeError; + } + value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.arg(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) + goto Sbk_Katie_QStringFunc_arg_TypeError; + } + value = PyDict_GetItemString(kwds, "fillChar"); + if (value && pyArgs[3]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.arg(): got multiple values for keyword argument 'fillChar'."); + return {}; + } else if (value) { + pyArgs[3] = value; + if (!(pythonToCpp[3] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[3])))) + goto Sbk_Katie_QStringFunc_arg_TypeError; + } + } + short cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 0; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + int cppArg2 = 10; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + if (!Shiboken::Object::isValid(pyArgs[3])) + return {}; + ::Katie::QChar* cppArg3 = QLatin1Char(' '); + if (pythonToCpp[3]) pythonToCpp[3](pyArgs[3], &cppArg3); + + if (!PyErr_Occurred()) { + // arg(short,int,int,Katie::QChar)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->arg(cppArg0, cppArg1, cppArg2, *cppArg3)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + break; + } + case 16: // arg(uint a, int fieldWidth, int base, const Katie::QChar & fillChar) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "fieldWidth"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.arg(): got multiple values for keyword argument 'fieldWidth'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_arg_TypeError; + } + value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.arg(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) + goto Sbk_Katie_QStringFunc_arg_TypeError; + } + value = PyDict_GetItemString(kwds, "fillChar"); + if (value && pyArgs[3]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.arg(): got multiple values for keyword argument 'fillChar'."); + return {}; + } else if (value) { + pyArgs[3] = value; + if (!(pythonToCpp[3] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[3])))) + goto Sbk_Katie_QStringFunc_arg_TypeError; + } + } + uint cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 0; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + int cppArg2 = 10; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + if (!Shiboken::Object::isValid(pyArgs[3])) + return {}; + ::Katie::QChar* cppArg3 = QLatin1Char(' '); + if (pythonToCpp[3]) pythonToCpp[3](pyArgs[3], &cppArg3); + + if (!PyErr_Occurred()) { + // arg(uint,int,int,Katie::QChar)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->arg(cppArg0, cppArg1, cppArg2, *cppArg3)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + break; + } + case 17: // arg(ulong a, int fieldwidth, int base, const Katie::QChar & fillChar) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "fieldwidth"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.arg(): got multiple values for keyword argument 'fieldwidth'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_arg_TypeError; + } + value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.arg(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) + goto Sbk_Katie_QStringFunc_arg_TypeError; + } + value = PyDict_GetItemString(kwds, "fillChar"); + if (value && pyArgs[3]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.arg(): got multiple values for keyword argument 'fillChar'."); + return {}; + } else if (value) { + pyArgs[3] = value; + if (!(pythonToCpp[3] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[3])))) + goto Sbk_Katie_QStringFunc_arg_TypeError; + } + } + ::ulong cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 0; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + int cppArg2 = 10; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + if (!Shiboken::Object::isValid(pyArgs[3])) + return {}; + ::Katie::QChar* cppArg3 = QLatin1Char(' '); + if (pythonToCpp[3]) pythonToCpp[3](pyArgs[3], &cppArg3); + + if (!PyErr_Occurred()) { + // arg(ulong,int,int,Katie::QChar)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->arg(cppArg0, cppArg1, cppArg2, *cppArg3)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + break; + } + case 18: // arg(unsigned long long a, int fieldwidth, int base, const Katie::QChar & fillChar) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "fieldwidth"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.arg(): got multiple values for keyword argument 'fieldwidth'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_arg_TypeError; + } + value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.arg(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) + goto Sbk_Katie_QStringFunc_arg_TypeError; + } + value = PyDict_GetItemString(kwds, "fillChar"); + if (value && pyArgs[3]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.arg(): got multiple values for keyword argument 'fillChar'."); + return {}; + } else if (value) { + pyArgs[3] = value; + if (!(pythonToCpp[3] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[3])))) + goto Sbk_Katie_QStringFunc_arg_TypeError; + } + } + unsigned long long cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 0; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + int cppArg2 = 10; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + if (!Shiboken::Object::isValid(pyArgs[3])) + return {}; + ::Katie::QChar* cppArg3 = QLatin1Char(' '); + if (pythonToCpp[3]) pythonToCpp[3](pyArgs[3], &cppArg3); + + if (!PyErr_Occurred()) { + // arg(unsigned long long,int,int,Katie::QChar)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->arg(cppArg0, cppArg1, cppArg2, *cppArg3)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + break; + } + case 19: // arg(ushort a, int fieldWidth, int base, const Katie::QChar & fillChar) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "fieldWidth"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.arg(): got multiple values for keyword argument 'fieldWidth'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_arg_TypeError; + } + value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.arg(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) + goto Sbk_Katie_QStringFunc_arg_TypeError; + } + value = PyDict_GetItemString(kwds, "fillChar"); + if (value && pyArgs[3]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.arg(): got multiple values for keyword argument 'fillChar'."); + return {}; + } else if (value) { + pyArgs[3] = value; + if (!(pythonToCpp[3] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[3])))) + goto Sbk_Katie_QStringFunc_arg_TypeError; + } + } + ::ushort cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 0; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + int cppArg2 = 10; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + if (!Shiboken::Object::isValid(pyArgs[3])) + return {}; + ::Katie::QChar* cppArg3 = QLatin1Char(' '); + if (pythonToCpp[3]) pythonToCpp[3](pyArgs[3], &cppArg3); + + if (!PyErr_Occurred()) { + // arg(ushort,int,int,Katie::QChar)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->arg(cppArg0, cppArg1, cppArg2, *cppArg3)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_arg_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.arg"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_at(PyObject* self, PyObject* pyArg) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QString::at(int)const + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // at(int)const + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_at_TypeError; + + // Call function/method + { + int cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // at(int)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + const Katie::QChar* cppResult = new Katie::QChar(const_cast(cppSelf)->at(cppArg0)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_at_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QString.at"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_begin(PyObject* self) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // begin() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QChar * cppResult = cppSelf->begin(); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::pointerToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), cppResult); + Shiboken::Object::setParent(self, pyResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QStringFunc_capacity(PyObject* self) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // capacity()const + int cppResult = const_cast(cppSelf)->capacity(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QStringFunc_chop(PyObject* self, PyObject* pyArg) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QString::chop(int) + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // chop(int) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_chop_TypeError; + + // Call function/method + { + int cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // chop(int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cppSelf->chop(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; + + Sbk_Katie_QStringFunc_chop_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QString.chop"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_clear(PyObject* self) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + + // Call function/method + { + + if (!PyErr_Occurred()) { + // clear() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cppSelf->clear(); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; +} + +static PyObject* Sbk_Katie_QStringFunc_compare(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (self) { + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + } + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 3) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.compare(): too many arguments"); + return {}; + } else if (numArgs < 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.compare(): not enough arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OOO:compare", &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2]))) + return {}; + + + // Overloaded function decisor + // 0: QString::compare(Katie::QLatin1String,Katie::Qt::CaseSensitivity)const + // 1: static QString::compare(Katie::QLatin1String,Katie::QString,Katie::Qt::CaseSensitivity) + // 2: QString::compare(Katie::QString,Katie::Qt::CaseSensitivity)const + // 3: static QString::compare(Katie::QString,Katie::QLatin1String,Katie::Qt::CaseSensitivity) + // 4: static QString::compare(Katie::QString,Katie::QString,Katie::Qt::CaseSensitivity) + if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 2; // compare(Katie::QString,Katie::Qt::CaseSensitivity)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 4; // compare(Katie::QString,Katie::QString,Katie::Qt::CaseSensitivity) + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[2])))) { + overloadId = 4; // compare(Katie::QString,Katie::QString,Katie::Qt::CaseSensitivity) + } + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QLATIN1STRING_IDX]), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 3; // compare(Katie::QString,Katie::QLatin1String,Katie::Qt::CaseSensitivity) + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[2])))) { + overloadId = 3; // compare(Katie::QString,Katie::QLatin1String,Katie::Qt::CaseSensitivity) + } + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[1])))) { + overloadId = 2; // compare(Katie::QString,Katie::Qt::CaseSensitivity)const + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QLATIN1STRING_IDX]), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // compare(Katie::QLatin1String,Katie::Qt::CaseSensitivity)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 1; // compare(Katie::QLatin1String,Katie::QString,Katie::Qt::CaseSensitivity) + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[2])))) { + overloadId = 1; // compare(Katie::QLatin1String,Katie::QString,Katie::Qt::CaseSensitivity) + } + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[1])))) { + overloadId = 0; // compare(Katie::QLatin1String,Katie::Qt::CaseSensitivity)const + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_compare_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // compare(const Katie::QLatin1String & other, Katie::Qt::CaseSensitivity cs) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "cs"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.compare(): got multiple values for keyword argument 'cs'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_compare_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QLatin1String* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + ::Katie::Qt::CaseSensitivity cppArg1 = Katie::Qt::CaseSensitive; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // compare(Katie::QLatin1String,Katie::Qt::CaseSensitivity)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + int cppResult = const_cast(cppSelf)->compare(*cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 1: // compare(const Katie::QLatin1String & s1, const Katie::QString & s2, Katie::Qt::CaseSensitivity cs) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "cs"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.compare(): got multiple values for keyword argument 'cs'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[2])))) + goto Sbk_Katie_QStringFunc_compare_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QLatin1String* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + if (!Shiboken::Object::isValid(pyArgs[1])) + return {}; + ::Katie::QString* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + ::Katie::Qt::CaseSensitivity cppArg2 = Katie::Qt::CaseSensitive; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // compare(Katie::QLatin1String,Katie::QString,Katie::Qt::CaseSensitivity) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + int cppResult = ::Katie::QString::compare(*cppArg0, *cppArg1, cppArg2); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 2: // compare(const Katie::QString & s, Katie::Qt::CaseSensitivity cs) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "cs"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.compare(): got multiple values for keyword argument 'cs'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_compare_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + ::Katie::Qt::CaseSensitivity cppArg1 = Katie::Qt::CaseSensitive; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // compare(Katie::QString,Katie::Qt::CaseSensitivity)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + int cppResult = const_cast(cppSelf)->compare(*cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 3: // compare(const Katie::QString & s1, const Katie::QLatin1String & s2, Katie::Qt::CaseSensitivity cs) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "cs"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.compare(): got multiple values for keyword argument 'cs'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[2])))) + goto Sbk_Katie_QStringFunc_compare_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + if (!Shiboken::Object::isValid(pyArgs[1])) + return {}; + ::Katie::QLatin1String* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + ::Katie::Qt::CaseSensitivity cppArg2 = Katie::Qt::CaseSensitive; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // compare(Katie::QString,Katie::QLatin1String,Katie::Qt::CaseSensitivity) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + int cppResult = ::Katie::QString::compare(*cppArg0, *cppArg1, cppArg2); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 4: // compare(const Katie::QString & s1, const Katie::QString & s2, Katie::Qt::CaseSensitivity cs) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "cs"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.compare(): got multiple values for keyword argument 'cs'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[2])))) + goto Sbk_Katie_QStringFunc_compare_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + if (!Shiboken::Object::isValid(pyArgs[1])) + return {}; + ::Katie::QString* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + ::Katie::Qt::CaseSensitivity cppArg2 = Katie::Qt::CaseSensitive; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // compare(Katie::QString,Katie::QString,Katie::Qt::CaseSensitivity) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + int cppResult = ::Katie::QString::compare(*cppArg0, *cppArg1, cppArg2); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_compare_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.compare"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_constBegin(PyObject* self) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // constBegin()const + const Katie::QChar * cppResult = const_cast(cppSelf)->constBegin(); + pyResult = Shiboken::Conversions::pointerToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), cppResult); + Shiboken::Object::setParent(self, pyResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QStringFunc_constData(PyObject* self) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // constData()const + const Katie::QChar * cppResult = const_cast(cppSelf)->constData(); + pyResult = Shiboken::Conversions::pointerToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), cppResult); + Shiboken::Object::setParent(self, pyResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QStringFunc_constEnd(PyObject* self) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // constEnd()const + const Katie::QChar * cppResult = const_cast(cppSelf)->constEnd(); + pyResult = Shiboken::Conversions::pointerToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), cppResult); + Shiboken::Object::setParent(self, pyResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QStringFunc_contains(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.contains(): too many arguments"); + return {}; + } else if (numArgs < 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.contains(): not enough arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OO:contains", &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QString::contains(Katie::QChar,Katie::Qt::CaseSensitivity)const + // 1: QString::contains(Katie::QString,Katie::Qt::CaseSensitivity)const + if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 1; // contains(Katie::QString,Katie::Qt::CaseSensitivity)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[1])))) { + overloadId = 1; // contains(Katie::QString,Katie::Qt::CaseSensitivity)const + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppValueConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // contains(Katie::QChar,Katie::Qt::CaseSensitivity)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[1])))) { + overloadId = 0; // contains(Katie::QChar,Katie::Qt::CaseSensitivity)const + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_contains_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // contains(Katie::QChar c, Katie::Qt::CaseSensitivity cs) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "cs"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.contains(): got multiple values for keyword argument 'cs'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_contains_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QChar* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + ::Katie::Qt::CaseSensitivity cppArg1 = Katie::Qt::CaseSensitive; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // contains(Katie::QChar,Katie::Qt::CaseSensitivity)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + bool cppResult = const_cast(cppSelf)->contains(*cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 1: // contains(const Katie::QString & s, Katie::Qt::CaseSensitivity cs) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "cs"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.contains(): got multiple values for keyword argument 'cs'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_contains_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + ::Katie::Qt::CaseSensitivity cppArg1 = Katie::Qt::CaseSensitive; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // contains(Katie::QString,Katie::Qt::CaseSensitivity)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + bool cppResult = const_cast(cppSelf)->contains(*cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_contains_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.contains"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_count(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.count(): too many arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OO:count", &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QString::count()const + // 1: QString::count(Katie::QChar,Katie::Qt::CaseSensitivity)const + // 2: QString::count(Katie::QString,Katie::Qt::CaseSensitivity)const + if (numArgs == 0) { + overloadId = 0; // count()const + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 2; // count(Katie::QString,Katie::Qt::CaseSensitivity)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[1])))) { + overloadId = 2; // count(Katie::QString,Katie::Qt::CaseSensitivity)const + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppValueConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 1; // count(Katie::QChar,Katie::Qt::CaseSensitivity)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[1])))) { + overloadId = 1; // count(Katie::QChar,Katie::Qt::CaseSensitivity)const + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_count_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // count() const + { + + if (!PyErr_Occurred()) { + // count()const + int cppResult = const_cast(cppSelf)->count(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 1: // count(Katie::QChar c, Katie::Qt::CaseSensitivity cs) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "cs"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.count(): got multiple values for keyword argument 'cs'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_count_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QChar* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + ::Katie::Qt::CaseSensitivity cppArg1 = Katie::Qt::CaseSensitive; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // count(Katie::QChar,Katie::Qt::CaseSensitivity)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + int cppResult = const_cast(cppSelf)->count(*cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 2: // count(const Katie::QString & s, Katie::Qt::CaseSensitivity cs) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "cs"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.count(): got multiple values for keyword argument 'cs'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_count_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + ::Katie::Qt::CaseSensitivity cppArg1 = Katie::Qt::CaseSensitive; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // count(Katie::QString,Katie::Qt::CaseSensitivity)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + int cppResult = const_cast(cppSelf)->count(*cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_count_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.count"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_data(PyObject* self) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // data() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QChar * cppResult = cppSelf->data(); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::pointerToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), cppResult); + Shiboken::Object::setParent(self, pyResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QStringFunc_detach(PyObject* self) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + + // Call function/method + { + + if (!PyErr_Occurred()) { + // detach() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cppSelf->detach(); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; +} + +static PyObject* Sbk_Katie_QStringFunc_end(PyObject* self) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // end() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QChar * cppResult = cppSelf->end(); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::pointerToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), cppResult); + Shiboken::Object::setParent(self, pyResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QStringFunc_endsWith(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.endsWith(): too many arguments"); + return {}; + } else if (numArgs < 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.endsWith(): not enough arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OO:endsWith", &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QString::endsWith(Katie::QChar,Katie::Qt::CaseSensitivity)const + // 1: QString::endsWith(Katie::QLatin1String,Katie::Qt::CaseSensitivity)const + // 2: QString::endsWith(Katie::QString,Katie::Qt::CaseSensitivity)const + if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 2; // endsWith(Katie::QString,Katie::Qt::CaseSensitivity)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[1])))) { + overloadId = 2; // endsWith(Katie::QString,Katie::Qt::CaseSensitivity)const + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QLATIN1STRING_IDX]), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 1; // endsWith(Katie::QLatin1String,Katie::Qt::CaseSensitivity)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[1])))) { + overloadId = 1; // endsWith(Katie::QLatin1String,Katie::Qt::CaseSensitivity)const + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // endsWith(Katie::QChar,Katie::Qt::CaseSensitivity)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[1])))) { + overloadId = 0; // endsWith(Katie::QChar,Katie::Qt::CaseSensitivity)const + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_endsWith_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // endsWith(const Katie::QChar & c, Katie::Qt::CaseSensitivity cs) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "cs"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.endsWith(): got multiple values for keyword argument 'cs'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_endsWith_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QChar* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + ::Katie::Qt::CaseSensitivity cppArg1 = Katie::Qt::CaseSensitive; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // endsWith(Katie::QChar,Katie::Qt::CaseSensitivity)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + bool cppResult = const_cast(cppSelf)->endsWith(*cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 1: // endsWith(const Katie::QLatin1String & s, Katie::Qt::CaseSensitivity cs) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "cs"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.endsWith(): got multiple values for keyword argument 'cs'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_endsWith_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QLatin1String* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + ::Katie::Qt::CaseSensitivity cppArg1 = Katie::Qt::CaseSensitive; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // endsWith(Katie::QLatin1String,Katie::Qt::CaseSensitivity)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + bool cppResult = const_cast(cppSelf)->endsWith(*cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 2: // endsWith(const Katie::QString & s, Katie::Qt::CaseSensitivity cs) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "cs"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.endsWith(): got multiple values for keyword argument 'cs'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_endsWith_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + ::Katie::Qt::CaseSensitivity cppArg1 = Katie::Qt::CaseSensitive; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // endsWith(Katie::QString,Katie::Qt::CaseSensitivity)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + bool cppResult = const_cast(cppSelf)->endsWith(*cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_endsWith_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.endsWith"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_fill(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.fill(): too many arguments"); + return {}; + } else if (numArgs < 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.fill(): not enough arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OO:fill", &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QString::fill(Katie::QChar,int) + if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppValueConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // fill(Katie::QChar,int) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // fill(Katie::QChar,int) + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_fill_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "size"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.fill(): got multiple values for keyword argument 'size'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_fill_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QChar* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = -1; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // fill(Katie::QChar,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->fill(*cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_fill_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.fill"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_fromAscii(PyObject* self, PyObject* args, PyObject* kwds) +{ + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.fromAscii(): too many arguments"); + return {}; + } else if (numArgs < 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.fromAscii(): not enough arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OO:fromAscii", &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: static QString::fromAscii(const char*,int) + if (Shiboken::String::check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // fromAscii(const char*,int) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // fromAscii(const char*,int) + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_fromAscii_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "size"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.fromAscii(): got multiple values for keyword argument 'size'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_fromAscii_TypeError; + } + } + const char* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = -1; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // fromAscii(const char*,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(::Katie::QString::fromAscii(cppArg0, cppArg1)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_fromAscii_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.fromAscii"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_fromLatin1(PyObject* self, PyObject* args, PyObject* kwds) +{ + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.fromLatin1(): too many arguments"); + return {}; + } else if (numArgs < 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.fromLatin1(): not enough arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OO:fromLatin1", &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: static QString::fromLatin1(const char*,int) + if (Shiboken::String::check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // fromLatin1(const char*,int) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // fromLatin1(const char*,int) + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_fromLatin1_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "size"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.fromLatin1(): got multiple values for keyword argument 'size'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_fromLatin1_TypeError; + } + } + const char* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = -1; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // fromLatin1(const char*,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(::Katie::QString::fromLatin1(cppArg0, cppArg1)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_fromLatin1_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.fromLatin1"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_fromLocal8Bit(PyObject* self, PyObject* args, PyObject* kwds) +{ + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.fromLocal8Bit(): too many arguments"); + return {}; + } else if (numArgs < 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.fromLocal8Bit(): not enough arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OO:fromLocal8Bit", &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: static QString::fromLocal8Bit(const char*,int) + if (Shiboken::String::check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // fromLocal8Bit(const char*,int) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // fromLocal8Bit(const char*,int) + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_fromLocal8Bit_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "size"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.fromLocal8Bit(): got multiple values for keyword argument 'size'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_fromLocal8Bit_TypeError; + } + } + const char* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = -1; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // fromLocal8Bit(const char*,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(::Katie::QString::fromLocal8Bit(cppArg0, cppArg1)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_fromLocal8Bit_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.fromLocal8Bit"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_fromRawData(PyObject* self, PyObject* args) +{ + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "fromRawData", 2, 2, &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: static QString::fromRawData(const Katie::QChar*,int) + if (numArgs == 2 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppPointerConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[0]))) + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // fromRawData(const Katie::QChar*,int) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_fromRawData_TypeError; + + // Call function/method + { + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QChar* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // fromRawData(const Katie::QChar*,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(::Katie::QString::fromRawData(cppArg0, cppArg1)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_fromRawData_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.fromRawData"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_fromStdString(PyObject* self, PyObject* pyArg) +{ + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: static QString::fromStdString(std::string) + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // fromStdString(std::string) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_fromStdString_TypeError; + + // Call function/method + { + ::std::string cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // fromStdString(std::string) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(::Katie::QString::fromStdString(cppArg0)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_fromStdString_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QString.fromStdString"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_fromUcs4(PyObject* self, PyObject* args, PyObject* kwds) +{ + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.fromUcs4(): too many arguments"); + return {}; + } else if (numArgs < 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.fromUcs4(): not enough arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OO:fromUcs4", &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: static QString::fromUcs4(const uint*,int) + if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // fromUcs4(const uint*,int) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // fromUcs4(const uint*,int) + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_fromUcs4_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "size"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.fromUcs4(): got multiple values for keyword argument 'size'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_fromUcs4_TypeError; + } + } + uint* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = -1; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // fromUcs4(const uint*,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(::Katie::QString::fromUcs4(cppArg0, cppArg1)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_fromUcs4_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.fromUcs4"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_fromUtf16(PyObject* self, PyObject* args, PyObject* kwds) +{ + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.fromUtf16(): too many arguments"); + return {}; + } else if (numArgs < 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.fromUtf16(): not enough arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OO:fromUtf16", &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: static QString::fromUtf16(const ushort*,int) + if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // fromUtf16(const ushort*,int) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // fromUtf16(const ushort*,int) + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_fromUtf16_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "size"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.fromUtf16(): got multiple values for keyword argument 'size'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_fromUtf16_TypeError; + } + } + ::ushort* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = -1; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // fromUtf16(const ushort*,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(::Katie::QString::fromUtf16(cppArg0, cppArg1)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_fromUtf16_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.fromUtf16"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_fromUtf8(PyObject* self, PyObject* args, PyObject* kwds) +{ + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.fromUtf8(): too many arguments"); + return {}; + } else if (numArgs < 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.fromUtf8(): not enough arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OO:fromUtf8", &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: static QString::fromUtf8(const char*,int) + if (Shiboken::String::check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // fromUtf8(const char*,int) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // fromUtf8(const char*,int) + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_fromUtf8_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "size"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.fromUtf8(): got multiple values for keyword argument 'size'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_fromUtf8_TypeError; + } + } + const char* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = -1; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // fromUtf8(const char*,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(::Katie::QString::fromUtf8(cppArg0, cppArg1)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_fromUtf8_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.fromUtf8"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_indexOf(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 3) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.indexOf(): too many arguments"); + return {}; + } else if (numArgs < 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.indexOf(): not enough arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OOO:indexOf", &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2]))) + return {}; + + + // Overloaded function decisor + // 0: QString::indexOf(Katie::QChar,int,Katie::Qt::CaseSensitivity)const + // 1: QString::indexOf(Katie::QLatin1String,int,Katie::Qt::CaseSensitivity)const + // 2: QString::indexOf(Katie::QString,int,Katie::Qt::CaseSensitivity)const + if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 2; // indexOf(Katie::QString,int,Katie::Qt::CaseSensitivity)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 2; // indexOf(Katie::QString,int,Katie::Qt::CaseSensitivity)const + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[2])))) { + overloadId = 2; // indexOf(Katie::QString,int,Katie::Qt::CaseSensitivity)const + } + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QLATIN1STRING_IDX]), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 1; // indexOf(Katie::QLatin1String,int,Katie::Qt::CaseSensitivity)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 1; // indexOf(Katie::QLatin1String,int,Katie::Qt::CaseSensitivity)const + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[2])))) { + overloadId = 1; // indexOf(Katie::QLatin1String,int,Katie::Qt::CaseSensitivity)const + } + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppValueConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // indexOf(Katie::QChar,int,Katie::Qt::CaseSensitivity)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 0; // indexOf(Katie::QChar,int,Katie::Qt::CaseSensitivity)const + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[2])))) { + overloadId = 0; // indexOf(Katie::QChar,int,Katie::Qt::CaseSensitivity)const + } + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_indexOf_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // indexOf(Katie::QChar c, int from, Katie::Qt::CaseSensitivity cs) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "from"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.indexOf(): got multiple values for keyword argument 'from'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_indexOf_TypeError; + } + value = PyDict_GetItemString(kwds, "cs"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.indexOf(): got multiple values for keyword argument 'cs'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[2])))) + goto Sbk_Katie_QStringFunc_indexOf_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QChar* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 0; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + ::Katie::Qt::CaseSensitivity cppArg2 = Katie::Qt::CaseSensitive; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // indexOf(Katie::QChar,int,Katie::Qt::CaseSensitivity)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + int cppResult = const_cast(cppSelf)->indexOf(*cppArg0, cppArg1, cppArg2); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 1: // indexOf(const Katie::QLatin1String & s, int from, Katie::Qt::CaseSensitivity cs) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "from"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.indexOf(): got multiple values for keyword argument 'from'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_indexOf_TypeError; + } + value = PyDict_GetItemString(kwds, "cs"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.indexOf(): got multiple values for keyword argument 'cs'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[2])))) + goto Sbk_Katie_QStringFunc_indexOf_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QLatin1String* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 0; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + ::Katie::Qt::CaseSensitivity cppArg2 = Katie::Qt::CaseSensitive; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // indexOf(Katie::QLatin1String,int,Katie::Qt::CaseSensitivity)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + int cppResult = const_cast(cppSelf)->indexOf(*cppArg0, cppArg1, cppArg2); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 2: // indexOf(const Katie::QString & s, int from, Katie::Qt::CaseSensitivity cs) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "from"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.indexOf(): got multiple values for keyword argument 'from'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_indexOf_TypeError; + } + value = PyDict_GetItemString(kwds, "cs"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.indexOf(): got multiple values for keyword argument 'cs'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[2])))) + goto Sbk_Katie_QStringFunc_indexOf_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 0; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + ::Katie::Qt::CaseSensitivity cppArg2 = Katie::Qt::CaseSensitive; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // indexOf(Katie::QString,int,Katie::Qt::CaseSensitivity)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + int cppResult = const_cast(cppSelf)->indexOf(*cppArg0, cppArg1, cppArg2); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_indexOf_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.indexOf"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_insert(PyObject* self, PyObject* args) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0, 0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "insert", 2, 3, &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2]))) + return {}; + + + // Overloaded function decisor + // 0: QString::insert(int,Katie::QChar) + // 1: QString::insert(int,const Katie::QChar*,int) + // 2: QString::insert(int,Katie::QLatin1String) + // 3: QString::insert(int,Katie::QString) + if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 2 + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArgs[1])))) { + overloadId = 3; // insert(int,Katie::QString) + } else if (numArgs == 2 + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QLATIN1STRING_IDX]), (pyArgs[1])))) { + overloadId = 2; // insert(int,Katie::QLatin1String) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppValueConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 0; // insert(int,Katie::QChar) + } else if (numArgs == 3 + && (pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) { + overloadId = 1; // insert(int,const Katie::QChar*,int) + } + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_insert_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // insert(int i, Katie::QChar c) + { + int cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + if (!Shiboken::Object::isValid(pyArgs[1])) + return {}; + ::Katie::QChar* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // insert(int,Katie::QChar) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->insert(cppArg0, *cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + case 1: // insert(int i, const Katie::QChar * uc, int len) + { + int cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + if (!Shiboken::Object::isValid(pyArgs[1])) + return {}; + ::Katie::QChar* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + int cppArg2; + pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // insert(int,const Katie::QChar*,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->insert(cppArg0, cppArg1, cppArg2); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + case 2: // insert(int i, const Katie::QLatin1String & s) + { + int cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + if (!Shiboken::Object::isValid(pyArgs[1])) + return {}; + ::Katie::QLatin1String* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // insert(int,Katie::QLatin1String) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->insert(cppArg0, *cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + case 3: // insert(int i, const Katie::QString & s) + { + int cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + if (!Shiboken::Object::isValid(pyArgs[1])) + return {}; + ::Katie::QString* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // insert(int,Katie::QString) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->insert(cppArg0, *cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_insert_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.insert"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_isDetached(PyObject* self) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // isDetached()const + bool cppResult = const_cast(cppSelf)->isDetached(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QStringFunc_isEmpty(PyObject* self) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // isEmpty()const + bool cppResult = const_cast(cppSelf)->isEmpty(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QStringFunc_isNull(PyObject* self) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // isNull()const + bool cppResult = const_cast(cppSelf)->isNull(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QStringFunc_isRightToLeft(PyObject* self) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // isRightToLeft()const + bool cppResult = const_cast(cppSelf)->isRightToLeft(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QStringFunc_isSharedWith(PyObject* self, PyObject* pyArg) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QString::isSharedWith(Katie::QString)const + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArg)))) { + overloadId = 0; // isSharedWith(Katie::QString)const + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_isSharedWith_TypeError; + + // Call function/method + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // isSharedWith(Katie::QString)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + bool cppResult = const_cast(cppSelf)->isSharedWith(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_isSharedWith_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QString.isSharedWith"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_isSimpleText(PyObject* self) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // isSimpleText()const + bool cppResult = const_cast(cppSelf)->isSimpleText(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QStringFunc_lastIndexOf(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 3) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.lastIndexOf(): too many arguments"); + return {}; + } else if (numArgs < 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.lastIndexOf(): not enough arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OOO:lastIndexOf", &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2]))) + return {}; + + + // Overloaded function decisor + // 0: QString::lastIndexOf(Katie::QChar,int,Katie::Qt::CaseSensitivity)const + // 1: QString::lastIndexOf(Katie::QLatin1String,int,Katie::Qt::CaseSensitivity)const + // 2: QString::lastIndexOf(Katie::QString,int,Katie::Qt::CaseSensitivity)const + if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 2; // lastIndexOf(Katie::QString,int,Katie::Qt::CaseSensitivity)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 2; // lastIndexOf(Katie::QString,int,Katie::Qt::CaseSensitivity)const + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[2])))) { + overloadId = 2; // lastIndexOf(Katie::QString,int,Katie::Qt::CaseSensitivity)const + } + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QLATIN1STRING_IDX]), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 1; // lastIndexOf(Katie::QLatin1String,int,Katie::Qt::CaseSensitivity)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 1; // lastIndexOf(Katie::QLatin1String,int,Katie::Qt::CaseSensitivity)const + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[2])))) { + overloadId = 1; // lastIndexOf(Katie::QLatin1String,int,Katie::Qt::CaseSensitivity)const + } + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppValueConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // lastIndexOf(Katie::QChar,int,Katie::Qt::CaseSensitivity)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 0; // lastIndexOf(Katie::QChar,int,Katie::Qt::CaseSensitivity)const + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[2])))) { + overloadId = 0; // lastIndexOf(Katie::QChar,int,Katie::Qt::CaseSensitivity)const + } + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_lastIndexOf_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // lastIndexOf(Katie::QChar c, int from, Katie::Qt::CaseSensitivity cs) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "from"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.lastIndexOf(): got multiple values for keyword argument 'from'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_lastIndexOf_TypeError; + } + value = PyDict_GetItemString(kwds, "cs"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.lastIndexOf(): got multiple values for keyword argument 'cs'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[2])))) + goto Sbk_Katie_QStringFunc_lastIndexOf_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QChar* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = -1; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + ::Katie::Qt::CaseSensitivity cppArg2 = Katie::Qt::CaseSensitive; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // lastIndexOf(Katie::QChar,int,Katie::Qt::CaseSensitivity)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + int cppResult = const_cast(cppSelf)->lastIndexOf(*cppArg0, cppArg1, cppArg2); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 1: // lastIndexOf(const Katie::QLatin1String & s, int from, Katie::Qt::CaseSensitivity cs) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "from"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.lastIndexOf(): got multiple values for keyword argument 'from'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_lastIndexOf_TypeError; + } + value = PyDict_GetItemString(kwds, "cs"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.lastIndexOf(): got multiple values for keyword argument 'cs'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[2])))) + goto Sbk_Katie_QStringFunc_lastIndexOf_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QLatin1String* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = -1; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + ::Katie::Qt::CaseSensitivity cppArg2 = Katie::Qt::CaseSensitive; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // lastIndexOf(Katie::QLatin1String,int,Katie::Qt::CaseSensitivity)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + int cppResult = const_cast(cppSelf)->lastIndexOf(*cppArg0, cppArg1, cppArg2); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 2: // lastIndexOf(const Katie::QString & s, int from, Katie::Qt::CaseSensitivity cs) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "from"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.lastIndexOf(): got multiple values for keyword argument 'from'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_lastIndexOf_TypeError; + } + value = PyDict_GetItemString(kwds, "cs"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.lastIndexOf(): got multiple values for keyword argument 'cs'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[2])))) + goto Sbk_Katie_QStringFunc_lastIndexOf_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = -1; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + ::Katie::Qt::CaseSensitivity cppArg2 = Katie::Qt::CaseSensitive; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // lastIndexOf(Katie::QString,int,Katie::Qt::CaseSensitivity)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + int cppResult = const_cast(cppSelf)->lastIndexOf(*cppArg0, cppArg1, cppArg2); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_lastIndexOf_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.lastIndexOf"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_left(PyObject* self, PyObject* pyArg) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QString::left(int)const + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // left(int)const + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_left_TypeError; + + // Call function/method + { + int cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // left(int)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->left(cppArg0)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_left_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QString.left"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_leftJustified(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 3) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.leftJustified(): too many arguments"); + return {}; + } else if (numArgs < 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.leftJustified(): not enough arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OOO:leftJustified", &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2]))) + return {}; + + + // Overloaded function decisor + // 0: QString::leftJustified(int,Katie::QChar,bool)const + if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // leftJustified(int,Katie::QChar,bool)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppValueConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 0; // leftJustified(int,Katie::QChar,bool)const + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) { + overloadId = 0; // leftJustified(int,Katie::QChar,bool)const + } + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_leftJustified_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "fill"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.leftJustified(): got multiple values for keyword argument 'fill'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppValueConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_leftJustified_TypeError; + } + value = PyDict_GetItemString(kwds, "trunc"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.leftJustified(): got multiple values for keyword argument 'trunc'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) + goto Sbk_Katie_QStringFunc_leftJustified_TypeError; + } + } + int cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + if (!Shiboken::Object::isValid(pyArgs[1])) + return {}; + ::Katie::QChar* cppArg1 = QLatin1Char(' '); + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + bool cppArg2 = false; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // leftJustified(int,Katie::QChar,bool)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->leftJustified(cppArg0, *cppArg1, cppArg2)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_leftJustified_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.leftJustified"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_length(PyObject* self) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // length()const + int cppResult = const_cast(cppSelf)->length(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QStringFunc_localeAwareCompare(PyObject* self, PyObject* args) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (self) { + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + } + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "localeAwareCompare", 1, 2, &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QString::localeAwareCompare(Katie::QString)const + // 1: static QString::localeAwareCompare(Katie::QString,Katie::QString) + if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // localeAwareCompare(Katie::QString)const + } else if (numArgs == 2 + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArgs[1])))) { + overloadId = 1; // localeAwareCompare(Katie::QString,Katie::QString) + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_localeAwareCompare_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // localeAwareCompare(const Katie::QString & s) const + { + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // localeAwareCompare(Katie::QString)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + int cppResult = const_cast(cppSelf)->localeAwareCompare(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 1: // localeAwareCompare(const Katie::QString & s1, const Katie::QString & s2) + { + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + if (!Shiboken::Object::isValid(pyArgs[1])) + return {}; + ::Katie::QString* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // localeAwareCompare(Katie::QString,Katie::QString) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + int cppResult = ::Katie::QString::localeAwareCompare(*cppArg0, *cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_localeAwareCompare_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.localeAwareCompare"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_mid(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.mid(): too many arguments"); + return {}; + } else if (numArgs < 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.mid(): not enough arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OO:mid", &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QString::mid(int,int)const + if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // mid(int,int)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // mid(int,int)const + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_mid_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "n"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.mid(): got multiple values for keyword argument 'n'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_mid_TypeError; + } + } + int cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = -1; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // mid(int,int)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->mid(cppArg0, cppArg1)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_mid_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.mid"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_normalized(PyObject* self, PyObject* args) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "normalized", 1, 2, &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QString::normalized(Katie::QString::NormalizationForm)const + // 1: QString::normalized(Katie::QString::NormalizationForm,Katie::QChar::UnicodeVersion)const + if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QSTRING_NORMALIZATIONFORM_IDX])->converter, (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // normalized(Katie::QString::NormalizationForm)const + } else if (numArgs == 2 + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QCHAR_UNICODEVERSION_IDX])->converter, (pyArgs[1])))) { + overloadId = 1; // normalized(Katie::QString::NormalizationForm,Katie::QChar::UnicodeVersion)const + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_normalized_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // normalized(Katie::QString::NormalizationForm mode) const + { + ::Katie::QString::NormalizationForm cppArg0{Katie::QString::NormalizationForm_D}; + pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // normalized(Katie::QString::NormalizationForm)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->normalized(cppArg0)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + break; + } + case 1: // normalized(Katie::QString::NormalizationForm mode, Katie::QChar::UnicodeVersion version) const + { + ::Katie::QString::NormalizationForm cppArg0{Katie::QString::NormalizationForm_D}; + pythonToCpp[0](pyArgs[0], &cppArg0); + ::Katie::QChar::UnicodeVersion cppArg1{Katie::QChar::Unicode_Unassigned}; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // normalized(Katie::QString::NormalizationForm,Katie::QChar::UnicodeVersion)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->normalized(cppArg0, cppArg1)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_normalized_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.normalized"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_number(PyObject* self, PyObject* args, PyObject* kwds) +{ + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 3) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.number(): too many arguments"); + return {}; + } else if (numArgs < 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.number(): not enough arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OOO:number", &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2]))) + return {}; + + + // Overloaded function decisor + // 0: static QString::number(double,char,int) + // 1: static QString::number(int,int) + // 2: static QString::number(long,int) + // 3: static QString::number(long long,int) + // 4: static QString::number(uint,int) + // 5: static QString::number(ulong,int) + // 6: static QString::number(unsigned long long,int) + if (PyLong_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 6; // number(unsigned long long,int) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 6; // number(unsigned long long,int) + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 5; // number(ulong,int) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 5; // number(ulong,int) + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 4; // number(uint,int) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 4; // number(uint,int) + } + } else if (PyLong_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 3; // number(long long,int) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 3; // number(long long,int) + } + } else if (PyFloat_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // number(double,char,int) + } else if (SbkChar_Check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 0; // number(double,char,int) + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) { + overloadId = 0; // number(double,char,int) + } + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 2; // number(long,int) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 2; // number(long,int) + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 1; // number(int,int) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 1; // number(int,int) + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_number_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // number(double arg__1, char f, int prec) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "f"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.number(): got multiple values for keyword argument 'f'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!SbkChar_Check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_number_TypeError; + } + value = PyDict_GetItemString(kwds, "prec"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.number(): got multiple values for keyword argument 'prec'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) + goto Sbk_Katie_QStringFunc_number_TypeError; + } + } + double cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + char cppArg1 = 'g'; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + int cppArg2 = 6; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // number(double,char,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(::Katie::QString::number(cppArg0, cppArg1, cppArg2)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + break; + } + case 1: // number(int arg__1, int base) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.number(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_number_TypeError; + } + } + int cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // number(int,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(::Katie::QString::number(cppArg0, cppArg1)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + break; + } + case 2: // number(long arg__1, int base) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.number(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_number_TypeError; + } + } + long cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // number(long,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(::Katie::QString::number(cppArg0, cppArg1)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + break; + } + case 3: // number(long long arg__1, int base) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.number(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_number_TypeError; + } + } + long long cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // number(long long,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(::Katie::QString::number(cppArg0, cppArg1)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + break; + } + case 4: // number(uint arg__1, int base) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.number(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_number_TypeError; + } + } + uint cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // number(uint,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(::Katie::QString::number(cppArg0, cppArg1)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + break; + } + case 5: // number(ulong arg__1, int base) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.number(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_number_TypeError; + } + } + ::ulong cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // number(ulong,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(::Katie::QString::number(cppArg0, cppArg1)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + break; + } + case 6: // number(unsigned long long arg__1, int base) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.number(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_number_TypeError; + } + } + unsigned long long cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // number(unsigned long long,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(::Katie::QString::number(cppArg0, cppArg1)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_number_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.number"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_prepend(PyObject* self, PyObject* pyArg) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QString::prepend(Katie::QChar) + // 1: QString::prepend(Katie::QByteArray) + // 2: QString::prepend(Katie::QLatin1String) + // 3: QString::prepend(Katie::QString) + // 4: QString::prepend(const char*) + if (Shiboken::String::check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 4; // prepend(const char*) + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArg)))) { + overloadId = 3; // prepend(Katie::QString) + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QLATIN1STRING_IDX]), (pyArg)))) { + overloadId = 2; // prepend(Katie::QLatin1String) + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArg)))) { + overloadId = 1; // prepend(Katie::QByteArray) + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppValueConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArg)))) { + overloadId = 0; // prepend(Katie::QChar) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_prepend_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // prepend(Katie::QChar c) + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QChar* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // prepend(Katie::QChar) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->prepend(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + case 1: // prepend(const Katie::QByteArray & s) + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QByteArray* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // prepend(Katie::QByteArray) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->prepend(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + case 2: // prepend(const Katie::QLatin1String & s) + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QLatin1String* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // prepend(Katie::QLatin1String) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->prepend(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + case 3: // prepend(const Katie::QString & s) + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // prepend(Katie::QString) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->prepend(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + case 4: // prepend(const char * s) + { + const char* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // prepend(const char*) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->prepend(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_prepend_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QString.prepend"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_push_back(PyObject* self, PyObject* pyArg) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QString::push_back(Katie::QChar) + // 1: QString::push_back(Katie::QString) + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArg)))) { + overloadId = 1; // push_back(Katie::QString) + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppValueConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArg)))) { + overloadId = 0; // push_back(Katie::QChar) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_push_back_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // push_back(Katie::QChar c) + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QChar* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // push_back(Katie::QChar) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cppSelf->push_back(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 1: // push_back(const Katie::QString & s) + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // push_back(Katie::QString) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cppSelf->push_back(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; + + Sbk_Katie_QStringFunc_push_back_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QString.push_back"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_push_front(PyObject* self, PyObject* pyArg) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QString::push_front(Katie::QChar) + // 1: QString::push_front(Katie::QString) + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArg)))) { + overloadId = 1; // push_front(Katie::QString) + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppValueConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArg)))) { + overloadId = 0; // push_front(Katie::QChar) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_push_front_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // push_front(Katie::QChar c) + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QChar* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // push_front(Katie::QChar) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cppSelf->push_front(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 1: // push_front(const Katie::QString & s) + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // push_front(Katie::QString) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cppSelf->push_front(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; + + Sbk_Katie_QStringFunc_push_front_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QString.push_front"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_remove(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.remove(): too many arguments"); + return {}; + } else if (numArgs < 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.remove(): not enough arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OO:remove", &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QString::remove(Katie::QChar,Katie::Qt::CaseSensitivity) + // 1: QString::remove(Katie::QString,Katie::Qt::CaseSensitivity) + // 2: QString::remove(int,int) + if (numArgs == 2 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0]))) + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 2; // remove(int,int) + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 1; // remove(Katie::QString,Katie::Qt::CaseSensitivity) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[1])))) { + overloadId = 1; // remove(Katie::QString,Katie::Qt::CaseSensitivity) + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppValueConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // remove(Katie::QChar,Katie::Qt::CaseSensitivity) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[1])))) { + overloadId = 0; // remove(Katie::QChar,Katie::Qt::CaseSensitivity) + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_remove_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // remove(Katie::QChar c, Katie::Qt::CaseSensitivity cs) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "cs"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.remove(): got multiple values for keyword argument 'cs'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_remove_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QChar* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + ::Katie::Qt::CaseSensitivity cppArg1 = Katie::Qt::CaseSensitive; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // remove(Katie::QChar,Katie::Qt::CaseSensitivity) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->remove(*cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + case 1: // remove(const Katie::QString & s, Katie::Qt::CaseSensitivity cs) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "cs"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.remove(): got multiple values for keyword argument 'cs'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_remove_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + ::Katie::Qt::CaseSensitivity cppArg1 = Katie::Qt::CaseSensitive; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // remove(Katie::QString,Katie::Qt::CaseSensitivity) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->remove(*cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + case 2: // remove(int i, int len) + { + int cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // remove(int,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->remove(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_remove_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.remove"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_repeated(PyObject* self, PyObject* pyArg) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QString::repeated(int)const + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // repeated(int)const + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_repeated_TypeError; + + // Call function/method + { + int cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // repeated(int)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->repeated(cppArg0)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_repeated_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QString.repeated"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_replace(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr, nullptr, nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0, 0, 0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 5) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.replace(): too many arguments"); + return {}; + } else if (numArgs < 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.replace(): not enough arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OOOOO:replace", &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2]), &(pyArgs[3]), &(pyArgs[4]))) + return {}; + + + // Overloaded function decisor + // 0: QString::replace(Katie::QChar,Katie::QChar,Katie::Qt::CaseSensitivity) + // 1: QString::replace(Katie::QChar,Katie::QLatin1String,Katie::Qt::CaseSensitivity) + // 2: QString::replace(Katie::QChar,Katie::QString,Katie::Qt::CaseSensitivity) + // 3: QString::replace(const Katie::QChar*,int,const Katie::QChar*,int,Katie::Qt::CaseSensitivity) + // 4: QString::replace(Katie::QLatin1String,Katie::QLatin1String,Katie::Qt::CaseSensitivity) + // 5: QString::replace(Katie::QLatin1String,Katie::QString,Katie::Qt::CaseSensitivity) + // 6: QString::replace(Katie::QString,Katie::QLatin1String,Katie::Qt::CaseSensitivity) + // 7: QString::replace(Katie::QString,Katie::QString,Katie::Qt::CaseSensitivity) + // 8: QString::replace(int,int,Katie::QChar) + // 9: QString::replace(int,int,const Katie::QChar*,int) + // 10: QString::replace(int,int,Katie::QString) + if (numArgs >= 2 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0]))) + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + if (numArgs == 3 + && (pythonToCpp[2] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArgs[2])))) { + overloadId = 10; // replace(int,int,Katie::QString) + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppValueConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[2])))) { + if (numArgs == 3) { + overloadId = 8; // replace(int,int,Katie::QChar) + } else if (numArgs == 4 + && (pythonToCpp[3] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[3])))) { + overloadId = 9; // replace(int,int,const Katie::QChar*,int) + } + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArgs[0])))) { + if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 7; // replace(Katie::QString,Katie::QString,Katie::Qt::CaseSensitivity) + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[2])))) { + overloadId = 7; // replace(Katie::QString,Katie::QString,Katie::Qt::CaseSensitivity) + } + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QLATIN1STRING_IDX]), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 6; // replace(Katie::QString,Katie::QLatin1String,Katie::Qt::CaseSensitivity) + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[2])))) { + overloadId = 6; // replace(Katie::QString,Katie::QLatin1String,Katie::Qt::CaseSensitivity) + } + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QLATIN1STRING_IDX]), (pyArgs[0])))) { + if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 5; // replace(Katie::QLatin1String,Katie::QString,Katie::Qt::CaseSensitivity) + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[2])))) { + overloadId = 5; // replace(Katie::QLatin1String,Katie::QString,Katie::Qt::CaseSensitivity) + } + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QLATIN1STRING_IDX]), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 4; // replace(Katie::QLatin1String,Katie::QLatin1String,Katie::Qt::CaseSensitivity) + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[2])))) { + overloadId = 4; // replace(Katie::QLatin1String,Katie::QLatin1String,Katie::Qt::CaseSensitivity) + } + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppValueConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[0])))) { + if (numArgs >= 4 + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1]))) + && (pythonToCpp[2] = Shiboken::Conversions::isPythonToCppPointerConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[2]))) + && (pythonToCpp[3] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[3])))) { + if (numArgs == 4) { + overloadId = 3; // replace(const Katie::QChar*,int,const Katie::QChar*,int,Katie::Qt::CaseSensitivity) + } else if ((pythonToCpp[4] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[4])))) { + overloadId = 3; // replace(const Katie::QChar*,int,const Katie::QChar*,int,Katie::Qt::CaseSensitivity) + } + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 2; // replace(Katie::QChar,Katie::QString,Katie::Qt::CaseSensitivity) + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[2])))) { + overloadId = 2; // replace(Katie::QChar,Katie::QString,Katie::Qt::CaseSensitivity) + } + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QLATIN1STRING_IDX]), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 1; // replace(Katie::QChar,Katie::QLatin1String,Katie::Qt::CaseSensitivity) + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[2])))) { + overloadId = 1; // replace(Katie::QChar,Katie::QLatin1String,Katie::Qt::CaseSensitivity) + } + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppValueConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 0; // replace(Katie::QChar,Katie::QChar,Katie::Qt::CaseSensitivity) + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[2])))) { + overloadId = 0; // replace(Katie::QChar,Katie::QChar,Katie::Qt::CaseSensitivity) + } + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_replace_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // replace(Katie::QChar before, Katie::QChar after, Katie::Qt::CaseSensitivity cs) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "cs"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.replace(): got multiple values for keyword argument 'cs'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[2])))) + goto Sbk_Katie_QStringFunc_replace_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QChar* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + if (!Shiboken::Object::isValid(pyArgs[1])) + return {}; + ::Katie::QChar* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + ::Katie::Qt::CaseSensitivity cppArg2 = Katie::Qt::CaseSensitive; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // replace(Katie::QChar,Katie::QChar,Katie::Qt::CaseSensitivity) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->replace(*cppArg0, *cppArg1, cppArg2); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + case 1: // replace(Katie::QChar c, const Katie::QLatin1String & after, Katie::Qt::CaseSensitivity cs) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "cs"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.replace(): got multiple values for keyword argument 'cs'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[2])))) + goto Sbk_Katie_QStringFunc_replace_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QChar* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + if (!Shiboken::Object::isValid(pyArgs[1])) + return {}; + ::Katie::QLatin1String* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + ::Katie::Qt::CaseSensitivity cppArg2 = Katie::Qt::CaseSensitive; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // replace(Katie::QChar,Katie::QLatin1String,Katie::Qt::CaseSensitivity) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->replace(*cppArg0, *cppArg1, cppArg2); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + case 2: // replace(Katie::QChar c, const Katie::QString & after, Katie::Qt::CaseSensitivity cs) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "cs"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.replace(): got multiple values for keyword argument 'cs'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[2])))) + goto Sbk_Katie_QStringFunc_replace_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QChar* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + if (!Shiboken::Object::isValid(pyArgs[1])) + return {}; + ::Katie::QString* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + ::Katie::Qt::CaseSensitivity cppArg2 = Katie::Qt::CaseSensitive; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // replace(Katie::QChar,Katie::QString,Katie::Qt::CaseSensitivity) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->replace(*cppArg0, *cppArg1, cppArg2); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + case 3: // replace(const Katie::QChar * before, int blen, const Katie::QChar * after, int alen, Katie::Qt::CaseSensitivity cs) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "cs"); + if (value && pyArgs[4]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.replace(): got multiple values for keyword argument 'cs'."); + return {}; + } else if (value) { + pyArgs[4] = value; + if (!(pythonToCpp[4] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[4])))) + goto Sbk_Katie_QStringFunc_replace_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QChar* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + if (!Shiboken::Object::isValid(pyArgs[2])) + return {}; + ::Katie::QChar* cppArg2; + pythonToCpp[2](pyArgs[2], &cppArg2); + int cppArg3; + pythonToCpp[3](pyArgs[3], &cppArg3); + ::Katie::Qt::CaseSensitivity cppArg4 = Katie::Qt::CaseSensitive; + if (pythonToCpp[4]) pythonToCpp[4](pyArgs[4], &cppArg4); + + if (!PyErr_Occurred()) { + // replace(const Katie::QChar*,int,const Katie::QChar*,int,Katie::Qt::CaseSensitivity) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->replace(cppArg0, cppArg1, cppArg2, cppArg3, cppArg4); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + case 4: // replace(const Katie::QLatin1String & before, const Katie::QLatin1String & after, Katie::Qt::CaseSensitivity cs) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "cs"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.replace(): got multiple values for keyword argument 'cs'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[2])))) + goto Sbk_Katie_QStringFunc_replace_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QLatin1String* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + if (!Shiboken::Object::isValid(pyArgs[1])) + return {}; + ::Katie::QLatin1String* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + ::Katie::Qt::CaseSensitivity cppArg2 = Katie::Qt::CaseSensitive; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // replace(Katie::QLatin1String,Katie::QLatin1String,Katie::Qt::CaseSensitivity) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->replace(*cppArg0, *cppArg1, cppArg2); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + case 5: // replace(const Katie::QLatin1String & before, const Katie::QString & after, Katie::Qt::CaseSensitivity cs) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "cs"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.replace(): got multiple values for keyword argument 'cs'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[2])))) + goto Sbk_Katie_QStringFunc_replace_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QLatin1String* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + if (!Shiboken::Object::isValid(pyArgs[1])) + return {}; + ::Katie::QString* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + ::Katie::Qt::CaseSensitivity cppArg2 = Katie::Qt::CaseSensitive; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // replace(Katie::QLatin1String,Katie::QString,Katie::Qt::CaseSensitivity) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->replace(*cppArg0, *cppArg1, cppArg2); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + case 6: // replace(const Katie::QString & before, const Katie::QLatin1String & after, Katie::Qt::CaseSensitivity cs) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "cs"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.replace(): got multiple values for keyword argument 'cs'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[2])))) + goto Sbk_Katie_QStringFunc_replace_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + if (!Shiboken::Object::isValid(pyArgs[1])) + return {}; + ::Katie::QLatin1String* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + ::Katie::Qt::CaseSensitivity cppArg2 = Katie::Qt::CaseSensitive; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // replace(Katie::QString,Katie::QLatin1String,Katie::Qt::CaseSensitivity) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->replace(*cppArg0, *cppArg1, cppArg2); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + case 7: // replace(const Katie::QString & before, const Katie::QString & after, Katie::Qt::CaseSensitivity cs) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "cs"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.replace(): got multiple values for keyword argument 'cs'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[2])))) + goto Sbk_Katie_QStringFunc_replace_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + if (!Shiboken::Object::isValid(pyArgs[1])) + return {}; + ::Katie::QString* cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + ::Katie::Qt::CaseSensitivity cppArg2 = Katie::Qt::CaseSensitive; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // replace(Katie::QString,Katie::QString,Katie::Qt::CaseSensitivity) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->replace(*cppArg0, *cppArg1, cppArg2); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + case 8: // replace(int i, int len, Katie::QChar after) + { + int cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + if (!Shiboken::Object::isValid(pyArgs[2])) + return {}; + ::Katie::QChar* cppArg2; + pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // replace(int,int,Katie::QChar) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->replace(cppArg0, cppArg1, *cppArg2); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + case 9: // replace(int i, int len, const Katie::QChar * s, int slen) + { + int cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + if (!Shiboken::Object::isValid(pyArgs[2])) + return {}; + ::Katie::QChar* cppArg2; + pythonToCpp[2](pyArgs[2], &cppArg2); + int cppArg3; + pythonToCpp[3](pyArgs[3], &cppArg3); + + if (!PyErr_Occurred()) { + // replace(int,int,const Katie::QChar*,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->replace(cppArg0, cppArg1, cppArg2, cppArg3); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + case 10: // replace(int i, int len, const Katie::QString & after) + { + int cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + if (!Shiboken::Object::isValid(pyArgs[2])) + return {}; + ::Katie::QString* cppArg2; + pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // replace(int,int,Katie::QString) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->replace(cppArg0, cppArg1, *cppArg2); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_replace_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.replace"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_reserve(PyObject* self, PyObject* pyArg) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QString::reserve(int) + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // reserve(int) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_reserve_TypeError; + + // Call function/method + { + int cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // reserve(int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cppSelf->reserve(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; + + Sbk_Katie_QStringFunc_reserve_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QString.reserve"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_resize(PyObject* self, PyObject* pyArg) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QString::resize(int) + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // resize(int) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_resize_TypeError; + + // Call function/method + { + int cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // resize(int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cppSelf->resize(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; + + Sbk_Katie_QStringFunc_resize_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QString.resize"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_right(PyObject* self, PyObject* pyArg) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QString::right(int)const + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // right(int)const + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_right_TypeError; + + // Call function/method + { + int cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // right(int)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->right(cppArg0)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_right_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QString.right"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_rightJustified(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 3) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.rightJustified(): too many arguments"); + return {}; + } else if (numArgs < 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.rightJustified(): not enough arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OOO:rightJustified", &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2]))) + return {}; + + + // Overloaded function decisor + // 0: QString::rightJustified(int,Katie::QChar,bool)const + if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // rightJustified(int,Katie::QChar,bool)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppValueConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 0; // rightJustified(int,Katie::QChar,bool)const + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) { + overloadId = 0; // rightJustified(int,Katie::QChar,bool)const + } + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_rightJustified_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "fill"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.rightJustified(): got multiple values for keyword argument 'fill'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppValueConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_rightJustified_TypeError; + } + value = PyDict_GetItemString(kwds, "trunc"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.rightJustified(): got multiple values for keyword argument 'trunc'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) + goto Sbk_Katie_QStringFunc_rightJustified_TypeError; + } + } + int cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + if (!Shiboken::Object::isValid(pyArgs[1])) + return {}; + ::Katie::QChar* cppArg1 = QLatin1Char(' '); + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + bool cppArg2 = false; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // rightJustified(int,Katie::QChar,bool)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->rightJustified(cppArg0, *cppArg1, cppArg2)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_rightJustified_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.rightJustified"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_section(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr, nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0, 0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 4) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.section(): too many arguments"); + return {}; + } else if (numArgs < 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.section(): not enough arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OOOO:section", &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2]), &(pyArgs[3]))) + return {}; + + + // Overloaded function decisor + // 0: QString::section(Katie::QChar,int,int,Katie::QString::SectionFlags)const + // 1: QString::section(Katie::QString,int,int,Katie::QString::SectionFlags)const + if (numArgs >= 2 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArgs[0]))) + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 1; // section(Katie::QString,int,int,Katie::QString::SectionFlags)const + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) { + if (numArgs == 3) { + overloadId = 1; // section(Katie::QString,int,int,Katie::QString::SectionFlags)const + } else if ((pythonToCpp[3] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[3])))) { + overloadId = 1; // section(Katie::QString,int,int,Katie::QString::SectionFlags)const + } + } + } else if (numArgs >= 2 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppValueConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[0]))) + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 0; // section(Katie::QChar,int,int,Katie::QString::SectionFlags)const + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) { + if (numArgs == 3) { + overloadId = 0; // section(Katie::QChar,int,int,Katie::QString::SectionFlags)const + } else if ((pythonToCpp[3] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[3])))) { + overloadId = 0; // section(Katie::QChar,int,int,Katie::QString::SectionFlags)const + } + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_section_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // section(Katie::QChar sep, int start, int end, Katie::QString::SectionFlags flags) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "end"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.section(): got multiple values for keyword argument 'end'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) + goto Sbk_Katie_QStringFunc_section_TypeError; + } + value = PyDict_GetItemString(kwds, "flags"); + if (value && pyArgs[3]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.section(): got multiple values for keyword argument 'flags'."); + return {}; + } else if (value) { + pyArgs[3] = value; + if (!(pythonToCpp[3] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[3])))) + goto Sbk_Katie_QStringFunc_section_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QChar* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + int cppArg2 = -1; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + ::Katie::QString::SectionFlags cppArg3 = SectionDefault; + if (pythonToCpp[3]) pythonToCpp[3](pyArgs[3], &cppArg3); + + if (!PyErr_Occurred()) { + // section(Katie::QChar,int,int,Katie::QString::SectionFlags)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->section(*cppArg0, cppArg1, cppArg2, cppArg3)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + break; + } + case 1: // section(const Katie::QString & in_sep, int start, int end, Katie::QString::SectionFlags flags) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "end"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.section(): got multiple values for keyword argument 'end'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) + goto Sbk_Katie_QStringFunc_section_TypeError; + } + value = PyDict_GetItemString(kwds, "flags"); + if (value && pyArgs[3]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.section(): got multiple values for keyword argument 'flags'."); + return {}; + } else if (value) { + pyArgs[3] = value; + if (!(pythonToCpp[3] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[3])))) + goto Sbk_Katie_QStringFunc_section_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + int cppArg2 = -1; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + ::Katie::QString::SectionFlags cppArg3 = SectionDefault; + if (pythonToCpp[3]) pythonToCpp[3](pyArgs[3], &cppArg3); + + if (!PyErr_Occurred()) { + // section(Katie::QString,int,int,Katie::QString::SectionFlags)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->section(*cppArg0, cppArg1, cppArg2, cppArg3)); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_section_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.section"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_setNum(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 3) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.setNum(): too many arguments"); + return {}; + } else if (numArgs < 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.setNum(): not enough arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OOO:setNum", &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2]))) + return {}; + + + // Overloaded function decisor + // 0: QString::setNum(double,char,int) + // 1: QString::setNum(float,char,int) + // 2: QString::setNum(int,int) + // 3: QString::setNum(long,int) + // 4: QString::setNum(long long,int) + // 5: QString::setNum(short,int) + // 6: QString::setNum(uint,int) + // 7: QString::setNum(ulong,int) + // 8: QString::setNum(unsigned long long,int) + // 9: QString::setNum(ushort,int) + if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 9; // setNum(ushort,int) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 9; // setNum(ushort,int) + } + } else if (PyLong_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 8; // setNum(unsigned long long,int) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 8; // setNum(unsigned long long,int) + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 7; // setNum(ulong,int) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 7; // setNum(ulong,int) + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 6; // setNum(uint,int) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 6; // setNum(uint,int) + } + } else if (PyLong_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 4; // setNum(long long,int) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 4; // setNum(long long,int) + } + } else if (PyFloat_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 1; // setNum(float,char,int) + } else if (SbkChar_Check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 1; // setNum(float,char,int) + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) { + overloadId = 1; // setNum(float,char,int) + } + } + } else if (PyFloat_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // setNum(double,char,int) + } else if (SbkChar_Check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + if (numArgs == 2) { + overloadId = 0; // setNum(double,char,int) + } else if ((pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) { + overloadId = 0; // setNum(double,char,int) + } + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 5; // setNum(short,int) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 5; // setNum(short,int) + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 3; // setNum(long,int) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 3; // setNum(long,int) + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 2; // setNum(int,int) + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 2; // setNum(int,int) + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_setNum_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // setNum(double arg__1, char f, int prec) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "f"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.setNum(): got multiple values for keyword argument 'f'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!SbkChar_Check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_setNum_TypeError; + } + value = PyDict_GetItemString(kwds, "prec"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.setNum(): got multiple values for keyword argument 'prec'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) + goto Sbk_Katie_QStringFunc_setNum_TypeError; + } + } + double cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + char cppArg1 = 'g'; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + int cppArg2 = 6; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // setNum(double,char,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->setNum(cppArg0, cppArg1, cppArg2); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + case 1: // setNum(float arg__1, char f, int prec) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "f"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.setNum(): got multiple values for keyword argument 'f'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!SbkChar_Check(pyArgs[1]) && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_setNum_TypeError; + } + value = PyDict_GetItemString(kwds, "prec"); + if (value && pyArgs[2]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.setNum(): got multiple values for keyword argument 'prec'."); + return {}; + } else if (value) { + pyArgs[2] = value; + if (!(pythonToCpp[2] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[2])))) + goto Sbk_Katie_QStringFunc_setNum_TypeError; + } + } + float cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + char cppArg1 = 'g'; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + int cppArg2 = 6; + if (pythonToCpp[2]) pythonToCpp[2](pyArgs[2], &cppArg2); + + if (!PyErr_Occurred()) { + // setNum(float,char,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->setNum(cppArg0, cppArg1, cppArg2); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + case 2: // setNum(int arg__1, int base) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.setNum(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_setNum_TypeError; + } + } + int cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // setNum(int,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->setNum(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + case 3: // setNum(long arg__1, int base) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.setNum(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_setNum_TypeError; + } + } + long cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // setNum(long,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->setNum(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + case 4: // setNum(long long arg__1, int base) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.setNum(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_setNum_TypeError; + } + } + long long cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // setNum(long long,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->setNum(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + case 5: // setNum(short arg__1, int base) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.setNum(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_setNum_TypeError; + } + } + short cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // setNum(short,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->setNum(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + case 6: // setNum(uint arg__1, int base) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.setNum(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_setNum_TypeError; + } + } + uint cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // setNum(uint,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->setNum(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + case 7: // setNum(ulong arg__1, int base) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.setNum(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_setNum_TypeError; + } + } + ::ulong cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // setNum(ulong,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->setNum(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + case 8: // setNum(unsigned long long arg__1, int base) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.setNum(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_setNum_TypeError; + } + } + unsigned long long cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // setNum(unsigned long long,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->setNum(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + case 9: // setNum(ushort arg__1, int base) + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.setNum(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_setNum_TypeError; + } + } + ::ushort cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // setNum(ushort,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->setNum(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_setNum_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.setNum"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_setRawData(PyObject* self, PyObject* args) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "setRawData", 2, 2, &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QString::setRawData(const Katie::QChar*,int) + if (numArgs == 2 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppPointerConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[0]))) + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // setRawData(const Katie::QChar*,int) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_setRawData_TypeError; + + // Call function/method + { + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QChar* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // setRawData(const Katie::QChar*,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->setRawData(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_setRawData_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.setRawData"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_setUnicode(PyObject* self, PyObject* args) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "setUnicode", 2, 2, &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QString::setUnicode(const Katie::QChar*,int) + if (numArgs == 2 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppPointerConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[0]))) + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // setUnicode(const Katie::QChar*,int) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_setUnicode_TypeError; + + // Call function/method + { + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QChar* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // setUnicode(const Katie::QChar*,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->setUnicode(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_setUnicode_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.setUnicode"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_setUtf16(PyObject* self, PyObject* args) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + + + if (!PyArg_UnpackTuple(args, "setUtf16", 2, 2, &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QString::setUtf16(const ushort*,int) + if (numArgs == 2 + && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0]))) + && (pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // setUtf16(const ushort*,int) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_setUtf16_TypeError; + + // Call function/method + { + ::ushort* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1; + pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // setUtf16(const ushort*,int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->setUtf16(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_setUtf16_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.setUtf16"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_simplified(PyObject* self) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // simplified()const + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->simplified()); + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QStringFunc_size(PyObject* self) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // size()const + int cppResult = const_cast(cppSelf)->size(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QStringFunc_sprintf(PyObject* self, PyObject* pyArg) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QString::sprintf(const char*) + if (Shiboken::String::check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // sprintf(const char*) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_sprintf_TypeError; + + // Call function/method + { + const char* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // sprintf(const char*) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + Katie::QString & cppResult = cppSelf->sprintf(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::referenceToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_sprintf_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QString.sprintf"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_squeeze(PyObject* self) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + + // Call function/method + { + + if (!PyErr_Occurred()) { + // squeeze() + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cppSelf->squeeze(); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; +} + +static PyObject* Sbk_Katie_QStringFunc_startsWith(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.startsWith(): too many arguments"); + return {}; + } else if (numArgs < 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.startsWith(): not enough arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OO:startsWith", &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QString::startsWith(Katie::QChar,Katie::Qt::CaseSensitivity)const + // 1: QString::startsWith(Katie::QLatin1String,Katie::Qt::CaseSensitivity)const + // 2: QString::startsWith(Katie::QString,Katie::Qt::CaseSensitivity)const + if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 2; // startsWith(Katie::QString,Katie::Qt::CaseSensitivity)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[1])))) { + overloadId = 2; // startsWith(Katie::QString,Katie::Qt::CaseSensitivity)const + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QLATIN1STRING_IDX]), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 1; // startsWith(Katie::QLatin1String,Katie::Qt::CaseSensitivity)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[1])))) { + overloadId = 1; // startsWith(Katie::QLatin1String,Katie::Qt::CaseSensitivity)const + } + } else if ((pythonToCpp[0] = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // startsWith(Katie::QChar,Katie::Qt::CaseSensitivity)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[1])))) { + overloadId = 0; // startsWith(Katie::QChar,Katie::Qt::CaseSensitivity)const + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_startsWith_TypeError; + + // Call function/method + switch (overloadId) { + case 0: // startsWith(const Katie::QChar & c, Katie::Qt::CaseSensitivity cs) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "cs"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.startsWith(): got multiple values for keyword argument 'cs'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_startsWith_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QChar* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + ::Katie::Qt::CaseSensitivity cppArg1 = Katie::Qt::CaseSensitive; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // startsWith(Katie::QChar,Katie::Qt::CaseSensitivity)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + bool cppResult = const_cast(cppSelf)->startsWith(*cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 1: // startsWith(const Katie::QLatin1String & s, Katie::Qt::CaseSensitivity cs) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "cs"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.startsWith(): got multiple values for keyword argument 'cs'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_startsWith_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QLatin1String* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + ::Katie::Qt::CaseSensitivity cppArg1 = Katie::Qt::CaseSensitive; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // startsWith(Katie::QLatin1String,Katie::Qt::CaseSensitivity)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + bool cppResult = const_cast(cppSelf)->startsWith(*cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + case 2: // startsWith(const Katie::QString & s, Katie::Qt::CaseSensitivity cs) const + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "cs"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.startsWith(): got multiple values for keyword argument 'cs'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])->converter, (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_startsWith_TypeError; + } + } + if (!Shiboken::Object::isValid(pyArgs[0])) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp[0](pyArgs[0], &cppArg0); + ::Katie::Qt::CaseSensitivity cppArg1 = Katie::Qt::CaseSensitive; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // startsWith(Katie::QString,Katie::Qt::CaseSensitivity)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + bool cppResult = const_cast(cppSelf)->startsWith(*cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + break; + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_startsWith_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.startsWith"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_swap(PyObject* self, PyObject* pyArg) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QString::swap(Katie::QString&) + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArg)))) { + overloadId = 0; // swap(Katie::QString&) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_swap_TypeError; + + // Call function/method + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // swap(Katie::QString&) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cppSelf->swap(*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; + + Sbk_Katie_QStringFunc_swap_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QString.swap"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_toAscii(PyObject* self) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // toAscii()const + Katie::QByteArray* cppResult = new Katie::QByteArray(const_cast(cppSelf)->toAscii()); + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QStringFunc_toCaseFolded(PyObject* self) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // toCaseFolded()const + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->toCaseFolded()); + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QStringFunc_toDouble(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.toDouble(): too many arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|O:toDouble", &(pyArgs[0]))) + return {}; + + + // Overloaded function decisor + // 0: QString::toDouble(bool*)const + if (numArgs == 0) { + overloadId = 0; // toDouble(bool*)const + } else if (PyBool_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 0; // toDouble(bool*)const + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_toDouble_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "ok"); + if (value && pyArgs[0]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.toDouble(): got multiple values for keyword argument 'ok'."); + return {}; + } else if (value) { + pyArgs[0] = value; + if (!(pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) + goto Sbk_Katie_QStringFunc_toDouble_TypeError; + } + } + bool* cppArg0 = Q_NULLPTR; + if (pythonToCpp[0]) pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // toDouble(bool*)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + double cppResult = const_cast(cppSelf)->toDouble(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_toDouble_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.toDouble"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_toFloat(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 1) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.toFloat(): too many arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|O:toFloat", &(pyArgs[0]))) + return {}; + + + // Overloaded function decisor + // 0: QString::toFloat(bool*)const + if (numArgs == 0) { + overloadId = 0; // toFloat(bool*)const + } else if (PyBool_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + overloadId = 0; // toFloat(bool*)const + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_toFloat_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "ok"); + if (value && pyArgs[0]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.toFloat(): got multiple values for keyword argument 'ok'."); + return {}; + } else if (value) { + pyArgs[0] = value; + if (!(pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) + goto Sbk_Katie_QStringFunc_toFloat_TypeError; + } + } + bool* cppArg0 = Q_NULLPTR; + if (pythonToCpp[0]) pythonToCpp[0](pyArgs[0], &cppArg0); + + if (!PyErr_Occurred()) { + // toFloat(bool*)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + float cppResult = const_cast(cppSelf)->toFloat(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_toFloat_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.toFloat"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_toInt(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.toInt(): too many arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OO:toInt", &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QString::toInt(bool*,int)const + if (numArgs == 0) { + overloadId = 0; // toInt(bool*,int)const + } else if (PyBool_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // toInt(bool*,int)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // toInt(bool*,int)const + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_toInt_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "ok"); + if (value && pyArgs[0]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.toInt(): got multiple values for keyword argument 'ok'."); + return {}; + } else if (value) { + pyArgs[0] = value; + if (!(pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) + goto Sbk_Katie_QStringFunc_toInt_TypeError; + } + value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.toInt(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_toInt_TypeError; + } + } + bool* cppArg0 = Q_NULLPTR; + if (pythonToCpp[0]) pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // toInt(bool*,int)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + int cppResult = const_cast(cppSelf)->toInt(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_toInt_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.toInt"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_toLatin1(PyObject* self) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // toLatin1()const + Katie::QByteArray* cppResult = new Katie::QByteArray(const_cast(cppSelf)->toLatin1()); + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QStringFunc_toLocal8Bit(PyObject* self) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // toLocal8Bit()const + Katie::QByteArray* cppResult = new Katie::QByteArray(const_cast(cppSelf)->toLocal8Bit()); + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QStringFunc_toLong(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.toLong(): too many arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OO:toLong", &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QString::toLong(bool*,int)const + if (numArgs == 0) { + overloadId = 0; // toLong(bool*,int)const + } else if (PyBool_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // toLong(bool*,int)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // toLong(bool*,int)const + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_toLong_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "ok"); + if (value && pyArgs[0]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.toLong(): got multiple values for keyword argument 'ok'."); + return {}; + } else if (value) { + pyArgs[0] = value; + if (!(pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) + goto Sbk_Katie_QStringFunc_toLong_TypeError; + } + value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.toLong(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_toLong_TypeError; + } + } + bool* cppArg0 = Q_NULLPTR; + if (pythonToCpp[0]) pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // toLong(bool*,int)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + long cppResult = const_cast(cppSelf)->toLong(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_toLong_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.toLong"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_toLongLong(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.toLongLong(): too many arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OO:toLongLong", &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QString::toLongLong(bool*,int)const + if (numArgs == 0) { + overloadId = 0; // toLongLong(bool*,int)const + } else if (PyBool_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // toLongLong(bool*,int)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // toLongLong(bool*,int)const + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_toLongLong_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "ok"); + if (value && pyArgs[0]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.toLongLong(): got multiple values for keyword argument 'ok'."); + return {}; + } else if (value) { + pyArgs[0] = value; + if (!(pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) + goto Sbk_Katie_QStringFunc_toLongLong_TypeError; + } + value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.toLongLong(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_toLongLong_TypeError; + } + } + bool* cppArg0 = Q_NULLPTR; + if (pythonToCpp[0]) pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // toLongLong(bool*,int)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + long long cppResult = const_cast(cppSelf)->toLongLong(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_toLongLong_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.toLongLong"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_toLower(PyObject* self) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // toLower()const + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->toLower()); + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QStringFunc_toShort(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.toShort(): too many arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OO:toShort", &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QString::toShort(bool*,int)const + if (numArgs == 0) { + overloadId = 0; // toShort(bool*,int)const + } else if (PyBool_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // toShort(bool*,int)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // toShort(bool*,int)const + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_toShort_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "ok"); + if (value && pyArgs[0]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.toShort(): got multiple values for keyword argument 'ok'."); + return {}; + } else if (value) { + pyArgs[0] = value; + if (!(pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) + goto Sbk_Katie_QStringFunc_toShort_TypeError; + } + value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.toShort(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_toShort_TypeError; + } + } + bool* cppArg0 = Q_NULLPTR; + if (pythonToCpp[0]) pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // toShort(bool*,int)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + short cppResult = const_cast(cppSelf)->toShort(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_toShort_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.toShort"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_toStdString(PyObject* self) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // toStdString()const + std::string cppResult = const_cast(cppSelf)->toStdString(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QStringFunc_toUInt(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.toUInt(): too many arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OO:toUInt", &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QString::toUInt(bool*,int)const + if (numArgs == 0) { + overloadId = 0; // toUInt(bool*,int)const + } else if (PyBool_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // toUInt(bool*,int)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // toUInt(bool*,int)const + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_toUInt_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "ok"); + if (value && pyArgs[0]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.toUInt(): got multiple values for keyword argument 'ok'."); + return {}; + } else if (value) { + pyArgs[0] = value; + if (!(pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) + goto Sbk_Katie_QStringFunc_toUInt_TypeError; + } + value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.toUInt(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_toUInt_TypeError; + } + } + bool* cppArg0 = Q_NULLPTR; + if (pythonToCpp[0]) pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // toUInt(bool*,int)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + uint cppResult = const_cast(cppSelf)->toUInt(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_toUInt_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.toUInt"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_toULong(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.toULong(): too many arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OO:toULong", &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QString::toULong(bool*,int)const + if (numArgs == 0) { + overloadId = 0; // toULong(bool*,int)const + } else if (PyBool_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // toULong(bool*,int)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // toULong(bool*,int)const + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_toULong_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "ok"); + if (value && pyArgs[0]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.toULong(): got multiple values for keyword argument 'ok'."); + return {}; + } else if (value) { + pyArgs[0] = value; + if (!(pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) + goto Sbk_Katie_QStringFunc_toULong_TypeError; + } + value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.toULong(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_toULong_TypeError; + } + } + bool* cppArg0 = Q_NULLPTR; + if (pythonToCpp[0]) pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // toULong(bool*,int)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + ulong cppResult = const_cast(cppSelf)->toULong(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_toULong_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.toULong"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_toULongLong(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.toULongLong(): too many arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OO:toULongLong", &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QString::toULongLong(bool*,int)const + if (numArgs == 0) { + overloadId = 0; // toULongLong(bool*,int)const + } else if (PyBool_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // toULongLong(bool*,int)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // toULongLong(bool*,int)const + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_toULongLong_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "ok"); + if (value && pyArgs[0]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.toULongLong(): got multiple values for keyword argument 'ok'."); + return {}; + } else if (value) { + pyArgs[0] = value; + if (!(pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) + goto Sbk_Katie_QStringFunc_toULongLong_TypeError; + } + value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.toULongLong(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_toULongLong_TypeError; + } + } + bool* cppArg0 = Q_NULLPTR; + if (pythonToCpp[0]) pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // toULongLong(bool*,int)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + unsigned long long cppResult = const_cast(cppSelf)->toULongLong(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_toULongLong_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.toULongLong"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_toUShort(PyObject* self, PyObject* args, PyObject* kwds) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + int overloadId = -1; + PythonToCppFunc pythonToCpp[] = { nullptr, nullptr }; + SBK_UNUSED(pythonToCpp) + int numNamedArgs = (kwds ? PyDict_Size(kwds) : 0); + int numArgs = PyTuple_GET_SIZE(args); + SBK_UNUSED(numArgs) + PyObject* pyArgs[] = {0, 0}; + + // invalid argument lengths + if (numArgs + numNamedArgs > 2) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.toUShort(): too many arguments"); + return {}; + } + + if (!PyArg_ParseTuple(args, "|OO:toUShort", &(pyArgs[0]), &(pyArgs[1]))) + return {}; + + + // Overloaded function decisor + // 0: QString::toUShort(bool*,int)const + if (numArgs == 0) { + overloadId = 0; // toUShort(bool*,int)const + } else if (PyBool_Check(pyArgs[0]) && (pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) { + if (numArgs == 1) { + overloadId = 0; // toUShort(bool*,int)const + } else if ((pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) { + overloadId = 0; // toUShort(bool*,int)const + } + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_toUShort_TypeError; + + // Call function/method + { + if (kwds) { + PyObject* value = PyDict_GetItemString(kwds, "ok"); + if (value && pyArgs[0]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.toUShort(): got multiple values for keyword argument 'ok'."); + return {}; + } else if (value) { + pyArgs[0] = value; + if (!(pythonToCpp[0] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[0])))) + goto Sbk_Katie_QStringFunc_toUShort_TypeError; + } + value = PyDict_GetItemString(kwds, "base"); + if (value && pyArgs[1]) { + PyErr_SetString(PyExc_TypeError, "KtCore.Katie.QString.toUShort(): got multiple values for keyword argument 'base'."); + return {}; + } else if (value) { + pyArgs[1] = value; + if (!(pythonToCpp[1] = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArgs[1])))) + goto Sbk_Katie_QStringFunc_toUShort_TypeError; + } + } + bool* cppArg0 = Q_NULLPTR; + if (pythonToCpp[0]) pythonToCpp[0](pyArgs[0], &cppArg0); + int cppArg1 = 10; + if (pythonToCpp[1]) pythonToCpp[1](pyArgs[1], &cppArg1); + + if (!PyErr_Occurred()) { + // toUShort(bool*,int)const + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + ushort cppResult = const_cast(cppSelf)->toUShort(cppArg0, cppArg1); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; + + Sbk_Katie_QStringFunc_toUShort_TypeError: + Shiboken::setErrorAboutWrongArguments(args, "KtCore.Katie.QString.toUShort"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_toUpper(PyObject* self) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // toUpper()const + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->toUpper()); + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QStringFunc_toUtf8(PyObject* self) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // toUtf8()const + Katie::QByteArray* cppResult = new Katie::QByteArray(const_cast(cppSelf)->toUtf8()); + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QStringFunc_trimmed(PyObject* self) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // trimmed()const + Katie::QString* cppResult = new Katie::QString(const_cast(cppSelf)->trimmed()); + pyResult = Shiboken::Object::newObject(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), cppResult, true, true); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QStringFunc_truncate(PyObject* self, PyObject* pyArg) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QString::truncate(int) + if ((pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 0; // truncate(int) + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc_truncate_TypeError; + + // Call function/method + { + int cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // truncate(int) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + cppSelf->truncate(cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_RETURN_NONE; + + Sbk_Katie_QStringFunc_truncate_TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QString.truncate"); + return {}; +} + +static PyObject* Sbk_Katie_QStringFunc_unicode(PyObject* self) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // unicode()const + const Katie::QChar * cppResult = const_cast(cppSelf)->unicode(); + pyResult = Shiboken::Conversions::pointerToPython(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), cppResult); + Shiboken::Object::setParent(self, pyResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyObject* Sbk_Katie_QStringFunc_utf16(PyObject* self) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + PyObject* pyResult{}; + + // Call function/method + { + + if (!PyErr_Occurred()) { + // utf16()const + const ushort * cppResult = const_cast(cppSelf)->utf16(); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } + } + + if (PyErr_Occurred() || !pyResult) { + Py_XDECREF(pyResult); + return {}; + } + return pyResult; +} + +static PyMethodDef Sbk_Katie_QStringMethod_compare = { + "compare", reinterpret_cast(Sbk_Katie_QStringFunc_compare), METH_VARARGS|METH_KEYWORDS|METH_STATIC +}; + +static PyMethodDef Sbk_Katie_QStringMethod_localeAwareCompare = { + "localeAwareCompare", reinterpret_cast(Sbk_Katie_QStringFunc_localeAwareCompare), METH_VARARGS|METH_STATIC +}; + +static PyMethodDef Sbk_Katie_QString_methods[] = { + {"append", reinterpret_cast(Sbk_Katie_QStringFunc_append), METH_O}, + {"arg", reinterpret_cast(Sbk_Katie_QStringFunc_arg), METH_VARARGS|METH_KEYWORDS}, + {"at", reinterpret_cast(Sbk_Katie_QStringFunc_at), METH_O}, + {"begin", reinterpret_cast(Sbk_Katie_QStringFunc_begin), METH_NOARGS}, + {"capacity", reinterpret_cast(Sbk_Katie_QStringFunc_capacity), METH_NOARGS}, + {"chop", reinterpret_cast(Sbk_Katie_QStringFunc_chop), METH_O}, + {"clear", reinterpret_cast(Sbk_Katie_QStringFunc_clear), METH_NOARGS}, + Sbk_Katie_QStringMethod_compare, + {"constBegin", reinterpret_cast(Sbk_Katie_QStringFunc_constBegin), METH_NOARGS}, + {"constData", reinterpret_cast(Sbk_Katie_QStringFunc_constData), METH_NOARGS}, + {"constEnd", reinterpret_cast(Sbk_Katie_QStringFunc_constEnd), METH_NOARGS}, + {"contains", reinterpret_cast(Sbk_Katie_QStringFunc_contains), METH_VARARGS|METH_KEYWORDS}, + {"count", reinterpret_cast(Sbk_Katie_QStringFunc_count), METH_VARARGS|METH_KEYWORDS}, + {"data", reinterpret_cast(Sbk_Katie_QStringFunc_data), METH_NOARGS}, + {"detach", reinterpret_cast(Sbk_Katie_QStringFunc_detach), METH_NOARGS}, + {"end", reinterpret_cast(Sbk_Katie_QStringFunc_end), METH_NOARGS}, + {"endsWith", reinterpret_cast(Sbk_Katie_QStringFunc_endsWith), METH_VARARGS|METH_KEYWORDS}, + {"fill", reinterpret_cast(Sbk_Katie_QStringFunc_fill), METH_VARARGS|METH_KEYWORDS}, + {"fromAscii", reinterpret_cast(Sbk_Katie_QStringFunc_fromAscii), METH_VARARGS|METH_KEYWORDS|METH_STATIC}, + {"fromLatin1", reinterpret_cast(Sbk_Katie_QStringFunc_fromLatin1), METH_VARARGS|METH_KEYWORDS|METH_STATIC}, + {"fromLocal8Bit", reinterpret_cast(Sbk_Katie_QStringFunc_fromLocal8Bit), METH_VARARGS|METH_KEYWORDS|METH_STATIC}, + {"fromRawData", reinterpret_cast(Sbk_Katie_QStringFunc_fromRawData), METH_VARARGS|METH_STATIC}, + {"fromStdString", reinterpret_cast(Sbk_Katie_QStringFunc_fromStdString), METH_O|METH_STATIC}, + {"fromUcs4", reinterpret_cast(Sbk_Katie_QStringFunc_fromUcs4), METH_VARARGS|METH_KEYWORDS|METH_STATIC}, + {"fromUtf16", reinterpret_cast(Sbk_Katie_QStringFunc_fromUtf16), METH_VARARGS|METH_KEYWORDS|METH_STATIC}, + {"fromUtf8", reinterpret_cast(Sbk_Katie_QStringFunc_fromUtf8), METH_VARARGS|METH_KEYWORDS|METH_STATIC}, + {"indexOf", reinterpret_cast(Sbk_Katie_QStringFunc_indexOf), METH_VARARGS|METH_KEYWORDS}, + {"insert", reinterpret_cast(Sbk_Katie_QStringFunc_insert), METH_VARARGS}, + {"isDetached", reinterpret_cast(Sbk_Katie_QStringFunc_isDetached), METH_NOARGS}, + {"isEmpty", reinterpret_cast(Sbk_Katie_QStringFunc_isEmpty), METH_NOARGS}, + {"isNull", reinterpret_cast(Sbk_Katie_QStringFunc_isNull), METH_NOARGS}, + {"isRightToLeft", reinterpret_cast(Sbk_Katie_QStringFunc_isRightToLeft), METH_NOARGS}, + {"isSharedWith", reinterpret_cast(Sbk_Katie_QStringFunc_isSharedWith), METH_O}, + {"isSimpleText", reinterpret_cast(Sbk_Katie_QStringFunc_isSimpleText), METH_NOARGS}, + {"lastIndexOf", reinterpret_cast(Sbk_Katie_QStringFunc_lastIndexOf), METH_VARARGS|METH_KEYWORDS}, + {"left", reinterpret_cast(Sbk_Katie_QStringFunc_left), METH_O}, + {"leftJustified", reinterpret_cast(Sbk_Katie_QStringFunc_leftJustified), METH_VARARGS|METH_KEYWORDS}, + {"length", reinterpret_cast(Sbk_Katie_QStringFunc_length), METH_NOARGS}, + Sbk_Katie_QStringMethod_localeAwareCompare, + {"mid", reinterpret_cast(Sbk_Katie_QStringFunc_mid), METH_VARARGS|METH_KEYWORDS}, + {"normalized", reinterpret_cast(Sbk_Katie_QStringFunc_normalized), METH_VARARGS}, + {"number", reinterpret_cast(Sbk_Katie_QStringFunc_number), METH_VARARGS|METH_KEYWORDS|METH_STATIC}, + {"prepend", reinterpret_cast(Sbk_Katie_QStringFunc_prepend), METH_O}, + {"push_back", reinterpret_cast(Sbk_Katie_QStringFunc_push_back), METH_O}, + {"push_front", reinterpret_cast(Sbk_Katie_QStringFunc_push_front), METH_O}, + {"remove", reinterpret_cast(Sbk_Katie_QStringFunc_remove), METH_VARARGS|METH_KEYWORDS}, + {"repeated", reinterpret_cast(Sbk_Katie_QStringFunc_repeated), METH_O}, + {"replace", reinterpret_cast(Sbk_Katie_QStringFunc_replace), METH_VARARGS|METH_KEYWORDS}, + {"reserve", reinterpret_cast(Sbk_Katie_QStringFunc_reserve), METH_O}, + {"resize", reinterpret_cast(Sbk_Katie_QStringFunc_resize), METH_O}, + {"right", reinterpret_cast(Sbk_Katie_QStringFunc_right), METH_O}, + {"rightJustified", reinterpret_cast(Sbk_Katie_QStringFunc_rightJustified), METH_VARARGS|METH_KEYWORDS}, + {"section", reinterpret_cast(Sbk_Katie_QStringFunc_section), METH_VARARGS|METH_KEYWORDS}, + {"setNum", reinterpret_cast(Sbk_Katie_QStringFunc_setNum), METH_VARARGS|METH_KEYWORDS}, + {"setRawData", reinterpret_cast(Sbk_Katie_QStringFunc_setRawData), METH_VARARGS}, + {"setUnicode", reinterpret_cast(Sbk_Katie_QStringFunc_setUnicode), METH_VARARGS}, + {"setUtf16", reinterpret_cast(Sbk_Katie_QStringFunc_setUtf16), METH_VARARGS}, + {"simplified", reinterpret_cast(Sbk_Katie_QStringFunc_simplified), METH_NOARGS}, + {"size", reinterpret_cast(Sbk_Katie_QStringFunc_size), METH_NOARGS}, + {"sprintf", reinterpret_cast(Sbk_Katie_QStringFunc_sprintf), METH_O}, + {"squeeze", reinterpret_cast(Sbk_Katie_QStringFunc_squeeze), METH_NOARGS}, + {"startsWith", reinterpret_cast(Sbk_Katie_QStringFunc_startsWith), METH_VARARGS|METH_KEYWORDS}, + {"swap", reinterpret_cast(Sbk_Katie_QStringFunc_swap), METH_O}, + {"toAscii", reinterpret_cast(Sbk_Katie_QStringFunc_toAscii), METH_NOARGS}, + {"toCaseFolded", reinterpret_cast(Sbk_Katie_QStringFunc_toCaseFolded), METH_NOARGS}, + {"toDouble", reinterpret_cast(Sbk_Katie_QStringFunc_toDouble), METH_VARARGS|METH_KEYWORDS}, + {"toFloat", reinterpret_cast(Sbk_Katie_QStringFunc_toFloat), METH_VARARGS|METH_KEYWORDS}, + {"toInt", reinterpret_cast(Sbk_Katie_QStringFunc_toInt), METH_VARARGS|METH_KEYWORDS}, + {"toLatin1", reinterpret_cast(Sbk_Katie_QStringFunc_toLatin1), METH_NOARGS}, + {"toLocal8Bit", reinterpret_cast(Sbk_Katie_QStringFunc_toLocal8Bit), METH_NOARGS}, + {"toLong", reinterpret_cast(Sbk_Katie_QStringFunc_toLong), METH_VARARGS|METH_KEYWORDS}, + {"toLongLong", reinterpret_cast(Sbk_Katie_QStringFunc_toLongLong), METH_VARARGS|METH_KEYWORDS}, + {"toLower", reinterpret_cast(Sbk_Katie_QStringFunc_toLower), METH_NOARGS}, + {"toShort", reinterpret_cast(Sbk_Katie_QStringFunc_toShort), METH_VARARGS|METH_KEYWORDS}, + {"toStdString", reinterpret_cast(Sbk_Katie_QStringFunc_toStdString), METH_NOARGS}, + {"toUInt", reinterpret_cast(Sbk_Katie_QStringFunc_toUInt), METH_VARARGS|METH_KEYWORDS}, + {"toULong", reinterpret_cast(Sbk_Katie_QStringFunc_toULong), METH_VARARGS|METH_KEYWORDS}, + {"toULongLong", reinterpret_cast(Sbk_Katie_QStringFunc_toULongLong), METH_VARARGS|METH_KEYWORDS}, + {"toUShort", reinterpret_cast(Sbk_Katie_QStringFunc_toUShort), METH_VARARGS|METH_KEYWORDS}, + {"toUpper", reinterpret_cast(Sbk_Katie_QStringFunc_toUpper), METH_NOARGS}, + {"toUtf8", reinterpret_cast(Sbk_Katie_QStringFunc_toUtf8), METH_NOARGS}, + {"trimmed", reinterpret_cast(Sbk_Katie_QStringFunc_trimmed), METH_NOARGS}, + {"truncate", reinterpret_cast(Sbk_Katie_QStringFunc_truncate), METH_O}, + {"unicode", reinterpret_cast(Sbk_Katie_QStringFunc_unicode), METH_NOARGS}, + {"utf16", reinterpret_cast(Sbk_Katie_QStringFunc_utf16), METH_NOARGS}, + + {nullptr, nullptr} // Sentinel +}; + +static PyObject* Sbk_Katie_QString_getattro(PyObject* self, PyObject* name) +{ + if (self) { + // Search the method in the instance dict + if (reinterpret_cast(self)->ob_dict) { + PyObject* meth = PyDict_GetItem(reinterpret_cast(self)->ob_dict, name); + if (meth) { + Py_INCREF(meth); + return meth; + } + } + // Search the method in the type dict + if (Shiboken::Object::isUserType(self)) { + Shiboken::AutoDecRef tmp(_Pep_PrivateMangle(self, name)); + PyObject *meth = PyDict_GetItem(Py_TYPE(self)->tp_dict, tmp); + if (meth) + return PyFunction_Check(meth) ? SBK_PyMethod_New(meth, self) : PyObject_GenericGetAttr(self, name); + } + static PyMethodDef non_static_Sbk_Katie_QStringMethod_compare = { + Sbk_Katie_QStringMethod_compare.ml_name, + Sbk_Katie_QStringMethod_compare.ml_meth, + Sbk_Katie_QStringMethod_compare.ml_flags & (~METH_STATIC), + Sbk_Katie_QStringMethod_compare.ml_doc, + }; + if (Shiboken::String::compare(name, "compare") == 0) + return PyCFunction_NewEx(&non_static_Sbk_Katie_QStringMethod_compare, self, 0); + static PyMethodDef non_static_Sbk_Katie_QStringMethod_localeAwareCompare = { + Sbk_Katie_QStringMethod_localeAwareCompare.ml_name, + Sbk_Katie_QStringMethod_localeAwareCompare.ml_meth, + Sbk_Katie_QStringMethod_localeAwareCompare.ml_flags & (~METH_STATIC), + Sbk_Katie_QStringMethod_localeAwareCompare.ml_doc, + }; + if (Shiboken::String::compare(name, "localeAwareCompare") == 0) + return PyCFunction_NewEx(&non_static_Sbk_Katie_QStringMethod_localeAwareCompare, self, 0); + } + return PyObject_GenericGetAttr(self, name); +} + +static int Sbk_Katie_QString___nb_bool(PyObject* self) +{ + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return -1; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + return !cppSelf->isNull(); +} + +static PyObject* Sbk_Katie_QStringFunc___iadd__(PyObject* self, PyObject* pyArg) +{ + bool isReverse = SbkObject_TypeCheck(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], pyArg) + && !SbkObject_TypeCheck(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], self); + if (isReverse) + std::swap(self, pyArg); + ::Katie::QString* cppSelf = nullptr; + SBK_UNUSED(cppSelf) + if (!Shiboken::Object::isValid(self)) + return {}; + cppSelf = reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + int overloadId = -1; + PythonToCppFunc pythonToCpp{}; + SBK_UNUSED(pythonToCpp) + + // Overloaded function decisor + // 0: QString::operator+=(Katie::QChar) + // 1: QString::operator+=(Katie::QChar::SpecialCharacter) + // 2: QString::operator+=(char) + // 3: QString::operator+=(Katie::QByteArray) + // 4: QString::operator+=(Katie::QLatin1String) + // 5: QString::operator+=(Katie::QString) + // 6: QString::operator+=(const char*) + if (!isReverse + && (pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArg)))) { + overloadId = 5; // operator+=(Katie::QString) + } else if (!isReverse + && (pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QLATIN1STRING_IDX]), (pyArg)))) { + overloadId = 4; // operator+=(Katie::QLatin1String) + } else if (!isReverse + && (pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArg)))) { + overloadId = 3; // operator+=(Katie::QByteArray) + } else if (!isReverse + && SbkChar_Check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 2; // operator+=(char) + } else if (!isReverse + && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(*PepType_SGTP(SbkKtCoreTypes[SBK_KATIE_QCHAR_SPECIALCHARACTER_IDX])->converter, (pyArg)))) { + overloadId = 1; // operator+=(Katie::QChar::SpecialCharacter) + } else if (!isReverse + && Shiboken::String::check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + overloadId = 6; // operator+=(const char*) + } else if (!isReverse + && (pythonToCpp = Shiboken::Conversions::isPythonToCppValueConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]), (pyArg)))) { + overloadId = 0; // operator+=(Katie::QChar) + } + + if (isReverse && overloadId == -1) { + PyErr_SetString(PyExc_NotImplementedError, "reverse operator not implemented."); + return {}; + } + + // Function signature not found. + if (overloadId == -1) goto Sbk_Katie_QStringFunc___iadd___TypeError; + + // Call function/method + switch (overloadId) { + case 0: // operator+=(Katie::QChar c) + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QChar* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // operator+=(Katie::QChar) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + (*cppSelf) += cppArg0; + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 1: // operator+=(Katie::QChar::SpecialCharacter c) + { + ::Katie::QChar::SpecialCharacter cppArg0{Katie::QChar::Null}; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // operator+=(Katie::QChar::SpecialCharacter) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + (*cppSelf) += cppArg0; + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 2: // operator+=(char c) + { + char cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // operator+=(char) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + (*cppSelf) += cppArg0; + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 3: // operator+=(const Katie::QByteArray & s) + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QByteArray* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // operator+=(Katie::QByteArray) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + (*cppSelf) += (*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 4: // operator+=(const Katie::QLatin1String & s) + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QLatin1String* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // operator+=(Katie::QLatin1String) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + (*cppSelf) += (*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 5: // operator+=(const Katie::QString & s) + { + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // operator+=(Katie::QString) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + (*cppSelf) += (*cppArg0); + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + case 6: // operator+=(const char * s) + { + const char* cppArg0; + pythonToCpp(pyArg, &cppArg0); + + if (!PyErr_Occurred()) { + // operator+=(const char*) + PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS + (*cppSelf) += cppArg0; + PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS + } + break; + } + } + + if (PyErr_Occurred()) { + return {}; + } + Py_INCREF(self); + return self; + + Sbk_Katie_QStringFunc___iadd___TypeError: + Shiboken::setErrorAboutWrongArguments(pyArg, "KtCore.Katie.QString.__iadd__"); + return {}; +} + +// Rich comparison +static PyObject* Sbk_Katie_QString_richcompare(PyObject* self, PyObject* pyArg, int op) +{ + if (!Shiboken::Object::isValid(self)) + return {}; + ::Katie::QString& cppSelf = *reinterpret_cast< ::Katie::QString *>(Shiboken::Conversions::cppPointer(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX], reinterpret_cast(self))); + SBK_UNUSED(cppSelf) + PyObject* pyResult{}; + PythonToCppFunc pythonToCpp; + SBK_UNUSED(pythonToCpp) + + switch (op) { + case Py_NE: + if (Shiboken::String::check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + // operator!=(const char * s) const + const char* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf !=(cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArg)))) { + // operator!=(const Katie::QString & s) const + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf !=(*cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QLATIN1STRING_IDX]), (pyArg)))) { + // operator!=(const Katie::QLatin1String & s) const + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QLatin1String* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf !=(*cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArg)))) { + // operator!=(const Katie::QByteArray & s) const + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QByteArray* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf !=(*cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else { + pyResult = Py_True; + Py_INCREF(pyResult); + } + + break; + case Py_LT: + if (Shiboken::String::check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + // operator<(const char * s) const + const char* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf <(cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArg)))) { + // operator<(const Katie::QString & s) const + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf <(*cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QLATIN1STRING_IDX]), (pyArg)))) { + // operator<(const Katie::QLatin1String & s) const + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QLatin1String* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf <(*cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArg)))) { + // operator<(const Katie::QByteArray & s) const + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QByteArray* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf <(*cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else { + goto Sbk_Katie_QString_RichComparison_TypeError; + } + + break; + case Py_LE: + if (Shiboken::String::check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + // operator<=(const char * s2) const + const char* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf <=(cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArg)))) { + // operator<=(const Katie::QString & s) const + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf <=(*cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QLATIN1STRING_IDX]), (pyArg)))) { + // operator<=(const Katie::QLatin1String & s) const + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QLatin1String* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf <=(*cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArg)))) { + // operator<=(const Katie::QByteArray & s) const + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QByteArray* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf <=(*cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else { + goto Sbk_Katie_QString_RichComparison_TypeError; + } + + break; + case Py_EQ: + if (Shiboken::String::check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + // operator==(const char * s) const + const char* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf ==(cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArg)))) { + // operator==(const Katie::QString & s) const + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf ==(*cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QLATIN1STRING_IDX]), (pyArg)))) { + // operator==(const Katie::QLatin1String & s) const + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QLatin1String* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf ==(*cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArg)))) { + // operator==(const Katie::QByteArray & s) const + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QByteArray* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf ==(*cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else { + pyResult = Py_False; + Py_INCREF(pyResult); + } + + break; + case Py_GT: + if (Shiboken::String::check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + // operator>(const char * s2) const + const char* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf >(cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArg)))) { + // operator>(const Katie::QString & s) const + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf >(*cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QLATIN1STRING_IDX]), (pyArg)))) { + // operator>(const Katie::QLatin1String & s) const + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QLatin1String* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf >(*cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArg)))) { + // operator>(const Katie::QByteArray & s) const + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QByteArray* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf >(*cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else { + goto Sbk_Katie_QString_RichComparison_TypeError; + } + + break; + case Py_GE: + if (Shiboken::String::check(pyArg) && (pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), (pyArg)))) { + // operator>=(const char * s2) const + const char* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf >=(cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]), (pyArg)))) { + // operator>=(const Katie::QString & s) const + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QString* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf >=(*cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QLATIN1STRING_IDX]), (pyArg)))) { + // operator>=(const Katie::QLatin1String & s) const + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QLatin1String* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf >=(*cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppReferenceConvertible(reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]), (pyArg)))) { + // operator>=(const Katie::QByteArray & s) const + if (!Shiboken::Object::isValid(pyArg)) + return {}; + ::Katie::QByteArray* cppArg0; + pythonToCpp(pyArg, &cppArg0); + bool cppResult = cppSelf >=(*cppArg0); + pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &cppResult); + } else { + goto Sbk_Katie_QString_RichComparison_TypeError; + } + + break; + default: + goto Sbk_Katie_QString_RichComparison_TypeError; + } + + if (pyResult && !PyErr_Occurred()) + return pyResult; + Sbk_Katie_QString_RichComparison_TypeError: + PyErr_SetString(PyExc_NotImplementedError, "operator not implemented."); + return {}; + +} + +} // extern "C" + +static int Sbk_Katie_QString_traverse(PyObject* self, visitproc visit, void* arg) +{ + return reinterpret_cast(SbkObject_TypeF())->tp_traverse(self, visit, arg); +} +static int Sbk_Katie_QString_clear(PyObject* self) +{ + return reinterpret_cast(SbkObject_TypeF())->tp_clear(self); +} +// Class Definition ----------------------------------------------- +extern "C" { +static SbkObjectType *_Sbk_Katie_QString_Type = nullptr; +static SbkObjectType *Sbk_Katie_QString_TypeF(void) +{ + return _Sbk_Katie_QString_Type; +} + +static PyType_Slot Sbk_Katie_QString_slots[] = { + {Py_tp_base, nullptr}, // inserted by introduceWrapperType + {Py_tp_dealloc, reinterpret_cast(&SbkDeallocWrapper)}, + {Py_tp_repr, nullptr}, + {Py_tp_hash, nullptr}, + {Py_tp_call, nullptr}, + {Py_tp_str, nullptr}, + {Py_tp_getattro, reinterpret_cast(Sbk_Katie_QString_getattro)}, + {Py_tp_setattro, nullptr}, + {Py_tp_traverse, reinterpret_cast(Sbk_Katie_QString_traverse)}, + {Py_tp_clear, reinterpret_cast(Sbk_Katie_QString_clear)}, + {Py_tp_richcompare, reinterpret_cast(Sbk_Katie_QString_richcompare)}, + {Py_tp_iter, nullptr}, + {Py_tp_iternext, nullptr}, + {Py_tp_methods, reinterpret_cast(Sbk_Katie_QString_methods)}, + {Py_tp_getset, nullptr}, + {Py_tp_init, reinterpret_cast(Sbk_Katie_QString_Init)}, + {Py_tp_new, reinterpret_cast(SbkObjectTpNew)}, + // type supports number protocol + {Py_nb_inplace_add, (void *)Sbk_Katie_QStringFunc___iadd__}, +#ifdef IS_PY3K + {Py_nb_bool, (void *)Sbk_Katie_QString___nb_bool}, +#else + {Py_nb_nonzero, (void *)Sbk_Katie_QString___nb_bool}, +#endif + {0, nullptr} +}; +static PyType_Spec Sbk_Katie_QString_spec = { + "KtCore.Katie.QString", + sizeof(SbkObject), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_GC, + Sbk_Katie_QString_slots +}; + +} //extern "C" + + +// Type conversion functions. + +// Python to C++ enum conversion. +static void Katie_QString_SectionFlag_PythonToCpp_Katie_QString_SectionFlag(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::QString::SectionFlag*>(cppOut) = + static_cast<::Katie::QString::SectionFlag>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_QString_SectionFlag_PythonToCpp_Katie_QString_SectionFlag_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QSTRING_SECTIONFLAG_IDX])) + return Katie_QString_SectionFlag_PythonToCpp_Katie_QString_SectionFlag; + return {}; +} +static PyObject* Katie_QString_SectionFlag_CppToPython_Katie_QString_SectionFlag(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QSTRING_SECTIONFLAG_IDX], castCppIn); + +} + +static void Katie_QString_SplitBehavior_PythonToCpp_Katie_QString_SplitBehavior(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::QString::SplitBehavior*>(cppOut) = + static_cast<::Katie::QString::SplitBehavior>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_QString_SplitBehavior_PythonToCpp_Katie_QString_SplitBehavior_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QSTRING_SPLITBEHAVIOR_IDX])) + return Katie_QString_SplitBehavior_PythonToCpp_Katie_QString_SplitBehavior; + return {}; +} +static PyObject* Katie_QString_SplitBehavior_CppToPython_Katie_QString_SplitBehavior(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QSTRING_SPLITBEHAVIOR_IDX], castCppIn); + +} + +static void Katie_QString_NormalizationForm_PythonToCpp_Katie_QString_NormalizationForm(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::QString::NormalizationForm*>(cppOut) = + static_cast<::Katie::QString::NormalizationForm>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_QString_NormalizationForm_PythonToCpp_Katie_QString_NormalizationForm_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QSTRING_NORMALIZATIONFORM_IDX])) + return Katie_QString_NormalizationForm_PythonToCpp_Katie_QString_NormalizationForm; + return {}; +} +static PyObject* Katie_QString_NormalizationForm_CppToPython_Katie_QString_NormalizationForm(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QSTRING_NORMALIZATIONFORM_IDX], castCppIn); + +} + +// Python to C++ pointer conversion - returns the C++ object of the Python wrapper (keeps object identity). +static void QString_PythonToCpp_QString_PTR(PyObject* pyIn, void* cppOut) { + Shiboken::Conversions::pythonToCppPointer(Sbk_Katie_QString_TypeF(), pyIn, cppOut); +} +static PythonToCppFunc is_QString_PythonToCpp_QString_PTR_Convertible(PyObject* pyIn) { + if (pyIn == Py_None) + return Shiboken::Conversions::nonePythonToCppNullPtr; + if (PyObject_TypeCheck(pyIn, reinterpret_cast(Sbk_Katie_QString_TypeF()))) + return QString_PythonToCpp_QString_PTR; + return {}; +} + +// C++ to Python pointer conversion - tries to find the Python wrapper for the C++ object (keeps object identity). +static PyObject* QString_PTR_CppToPython_QString(const void* cppIn) { + auto pyOut = reinterpret_cast(Shiboken::BindingManager::instance().retrieveWrapper(cppIn)); + if (pyOut) { + Py_INCREF(pyOut); + return pyOut; + } + bool changedTypeName = false; + auto tCppIn = reinterpret_cast(cppIn); + const char *typeName = typeid(*tCppIn).name(); + auto sbkType = Shiboken::ObjectType::typeForTypeName(typeName); + if (sbkType && Shiboken::ObjectType::hasSpecialCastFunction(sbkType)) { + typeName = typeNameOf(tCppIn); + changedTypeName = true; + } + PyObject *result = Shiboken::Object::newObject(Sbk_Katie_QString_TypeF(), const_cast(cppIn), false, /* exactType */ changedTypeName, typeName); + if (changedTypeName) + delete [] typeName; + return result; +} + +// The signatures string for the functions. +// Multiple signatures have their index "n:" in front. +static const char *Katie_QString_SignatureStrings[] = { + "8:KtCore.Katie.QString()", + "7:KtCore.Katie.QString(a:KtCore.Katie.QByteArray)", + "6:KtCore.Katie.QString(unicode:KtCore.Katie.QChar,size:int=-1)", + "5:KtCore.Katie.QString(c:KtCore.Katie.QChar)", + "4:KtCore.Katie.QString(latin1:KtCore.Katie.QLatin1String)", + "3:KtCore.Katie.QString(arg__1:KtCore.Katie.QString)", + "2:KtCore.Katie.QString(ch:str)", + "1:KtCore.Katie.QString(size:int,c:KtCore.Katie.QChar)", + "0:KtCore.Katie.QString(size:int,arg__2:KtCore.Katie.Qt.Initialization)", + "4:KtCore.Katie.QString.append(c:KtCore.Katie.QChar)->KtCore.Katie.QString", + "3:KtCore.Katie.QString.append(s:KtCore.Katie.QByteArray)->KtCore.Katie.QString", + "2:KtCore.Katie.QString.append(s:KtCore.Katie.QLatin1String)->KtCore.Katie.QString", + "1:KtCore.Katie.QString.append(s:KtCore.Katie.QString)->KtCore.Katie.QString", + "0:KtCore.Katie.QString.append(s:str)->KtCore.Katie.QString", + "19:KtCore.Katie.QString.arg(a:KtCore.Katie.QChar,fieldWidth:int=0,fillChar:KtCore.Katie.QChar=QLatin1Char(' '))->KtCore.Katie.QString", + "18:KtCore.Katie.QString.arg(a:char,fieldWidth:int=0,fillChar:KtCore.Katie.QChar=QLatin1Char(' '))->KtCore.Katie.QString", + "17:KtCore.Katie.QString.arg(a:KtCore.Katie.QString,fieldWidth:int=0,fillChar:KtCore.Katie.QChar=QLatin1Char(' '))->KtCore.Katie.QString", + "16:KtCore.Katie.QString.arg(a1:KtCore.Katie.QString,a2:KtCore.Katie.QString)->KtCore.Katie.QString", + "15:KtCore.Katie.QString.arg(a1:KtCore.Katie.QString,a2:KtCore.Katie.QString,a3:KtCore.Katie.QString)->KtCore.Katie.QString", + "14:KtCore.Katie.QString.arg(a1:KtCore.Katie.QString,a2:KtCore.Katie.QString,a3:KtCore.Katie.QString,a4:KtCore.Katie.QString)->KtCore.Katie.QString", + "13:KtCore.Katie.QString.arg(a1:KtCore.Katie.QString,a2:KtCore.Katie.QString,a3:KtCore.Katie.QString,a4:KtCore.Katie.QString,a5:KtCore.Katie.QString)->KtCore.Katie.QString", + "12:KtCore.Katie.QString.arg(a1:KtCore.Katie.QString,a2:KtCore.Katie.QString,a3:KtCore.Katie.QString,a4:KtCore.Katie.QString,a5:KtCore.Katie.QString,a6:KtCore.Katie.QString)->KtCore.Katie.QString", + "11:KtCore.Katie.QString.arg(a1:KtCore.Katie.QString,a2:KtCore.Katie.QString,a3:KtCore.Katie.QString,a4:KtCore.Katie.QString,a5:KtCore.Katie.QString,a6:KtCore.Katie.QString,a7:KtCore.Katie.QString)->KtCore.Katie.QString", + "10:KtCore.Katie.QString.arg(a1:KtCore.Katie.QString,a2:KtCore.Katie.QString,a3:KtCore.Katie.QString,a4:KtCore.Katie.QString,a5:KtCore.Katie.QString,a6:KtCore.Katie.QString,a7:KtCore.Katie.QString,a8:KtCore.Katie.QString)->KtCore.Katie.QString", + "9:KtCore.Katie.QString.arg(a1:KtCore.Katie.QString,a2:KtCore.Katie.QString,a3:KtCore.Katie.QString,a4:KtCore.Katie.QString,a5:KtCore.Katie.QString,a6:KtCore.Katie.QString,a7:KtCore.Katie.QString,a8:KtCore.Katie.QString,a9:KtCore.Katie.QString)->KtCore.Katie.QString", + "8:KtCore.Katie.QString.arg(a:double,fieldWidth:int=0,fmt:char='g',prec:int=-1,fillChar:KtCore.Katie.QChar=QLatin1Char(' '))->KtCore.Katie.QString", + "7:KtCore.Katie.QString.arg(a:int,fieldWidth:int=0,base:int=10,fillChar:KtCore.Katie.QChar=QLatin1Char(' '))->KtCore.Katie.QString", + "6:KtCore.Katie.QString.arg(a:long,fieldwidth:int=0,base:int=10,fillChar:KtCore.Katie.QChar=QLatin1Char(' '))->KtCore.Katie.QString", + "5:KtCore.Katie.QString.arg(a:long long,fieldwidth:int=0,base:int=10,fillChar:KtCore.Katie.QChar=QLatin1Char(' '))->KtCore.Katie.QString", + "4:KtCore.Katie.QString.arg(a:short,fieldWidth:int=0,base:int=10,fillChar:KtCore.Katie.QChar=QLatin1Char(' '))->KtCore.Katie.QString", + "3:KtCore.Katie.QString.arg(a:unsigned int,fieldWidth:int=0,base:int=10,fillChar:KtCore.Katie.QChar=QLatin1Char(' '))->KtCore.Katie.QString", + "2:KtCore.Katie.QString.arg(a:ulong,fieldwidth:int=0,base:int=10,fillChar:KtCore.Katie.QChar=QLatin1Char(' '))->KtCore.Katie.QString", + "1:KtCore.Katie.QString.arg(a:unsigned long long,fieldwidth:int=0,base:int=10,fillChar:KtCore.Katie.QChar=QLatin1Char(' '))->KtCore.Katie.QString", + "0:KtCore.Katie.QString.arg(a:ushort,fieldWidth:int=0,base:int=10,fillChar:KtCore.Katie.QChar=QLatin1Char(' '))->KtCore.Katie.QString", + "KtCore.Katie.QString.at(i:int)->KtCore.Katie.QChar", + "1:KtCore.Katie.QString.begin()->KtCore.Katie.QChar", + "0:KtCore.Katie.QString.begin()->KtCore.Katie.QChar", + "KtCore.Katie.QString.capacity()->int", + "KtCore.Katie.QString.chop(n:int)", + "KtCore.Katie.QString.clear()", + "4:KtCore.Katie.QString.compare(other:KtCore.Katie.QLatin1String,cs:KtCore.Katie.Qt.CaseSensitivity=Qt.CaseSensitive)->int", + "3:KtCore.Katie.QString.compare(s1:KtCore.Katie.QLatin1String,s2:KtCore.Katie.QString,cs:KtCore.Katie.Qt.CaseSensitivity=Qt.CaseSensitive)->int", + "2:KtCore.Katie.QString.compare(s:KtCore.Katie.QString,cs:KtCore.Katie.Qt.CaseSensitivity=Qt.CaseSensitive)->int", + "1:KtCore.Katie.QString.compare(s1:KtCore.Katie.QString,s2:KtCore.Katie.QLatin1String,cs:KtCore.Katie.Qt.CaseSensitivity=Qt.CaseSensitive)->int", + "0:KtCore.Katie.QString.compare(s1:KtCore.Katie.QString,s2:KtCore.Katie.QString,cs:KtCore.Katie.Qt.CaseSensitivity=Qt.CaseSensitive)->int", + "KtCore.Katie.QString.constBegin()->KtCore.Katie.QChar", + "KtCore.Katie.QString.constData()->KtCore.Katie.QChar", + "KtCore.Katie.QString.constEnd()->KtCore.Katie.QChar", + "1:KtCore.Katie.QString.contains(c:KtCore.Katie.QChar,cs:KtCore.Katie.Qt.CaseSensitivity=Qt.CaseSensitive)->bool", + "0:KtCore.Katie.QString.contains(s:KtCore.Katie.QString,cs:KtCore.Katie.Qt.CaseSensitivity=Qt.CaseSensitive)->bool", + "2:KtCore.Katie.QString.count()->int", + "1:KtCore.Katie.QString.count(c:KtCore.Katie.QChar,cs:KtCore.Katie.Qt.CaseSensitivity=Qt.CaseSensitive)->int", + "0:KtCore.Katie.QString.count(s:KtCore.Katie.QString,cs:KtCore.Katie.Qt.CaseSensitivity=Qt.CaseSensitive)->int", + "1:KtCore.Katie.QString.data()->KtCore.Katie.QChar", + "0:KtCore.Katie.QString.data()->KtCore.Katie.QChar", + "KtCore.Katie.QString.detach()", + "1:KtCore.Katie.QString.end()->KtCore.Katie.QChar", + "0:KtCore.Katie.QString.end()->KtCore.Katie.QChar", + "2:KtCore.Katie.QString.endsWith(c:KtCore.Katie.QChar,cs:KtCore.Katie.Qt.CaseSensitivity=Qt.CaseSensitive)->bool", + "1:KtCore.Katie.QString.endsWith(s:KtCore.Katie.QLatin1String,cs:KtCore.Katie.Qt.CaseSensitivity=Qt.CaseSensitive)->bool", + "0:KtCore.Katie.QString.endsWith(s:KtCore.Katie.QString,cs:KtCore.Katie.Qt.CaseSensitivity=Qt.CaseSensitive)->bool", + "KtCore.Katie.QString.fill(c:KtCore.Katie.QChar,size:int=-1)->KtCore.Katie.QString", + "KtCore.Katie.QString.fromAscii(arg__1:str,size:int=-1)->KtCore.Katie.QString", + "KtCore.Katie.QString.fromLatin1(arg__1:str,size:int=-1)->KtCore.Katie.QString", + "KtCore.Katie.QString.fromLocal8Bit(arg__1:str,size:int=-1)->KtCore.Katie.QString", + "KtCore.Katie.QString.fromRawData(arg__1:KtCore.Katie.QChar,size:int)->KtCore.Katie.QString", + "KtCore.Katie.QString.fromStdString(s:std.string)->KtCore.Katie.QString", + "KtCore.Katie.QString.fromUcs4(arg__1:KtCore.uint,size:int=-1)->KtCore.Katie.QString", + "KtCore.Katie.QString.fromUtf16(arg__1:KtCore.ushort,size:int=-1)->KtCore.Katie.QString", + "KtCore.Katie.QString.fromUtf8(arg__1:str,size:int=-1)->KtCore.Katie.QString", + "2:KtCore.Katie.QString.indexOf(c:KtCore.Katie.QChar,from:int=0,cs:KtCore.Katie.Qt.CaseSensitivity=Qt.CaseSensitive)->int", + "1:KtCore.Katie.QString.indexOf(s:KtCore.Katie.QLatin1String,from:int=0,cs:KtCore.Katie.Qt.CaseSensitivity=Qt.CaseSensitive)->int", + "0:KtCore.Katie.QString.indexOf(s:KtCore.Katie.QString,from:int=0,cs:KtCore.Katie.Qt.CaseSensitivity=Qt.CaseSensitive)->int", + "3:KtCore.Katie.QString.insert(i:int,c:KtCore.Katie.QChar)->KtCore.Katie.QString", + "2:KtCore.Katie.QString.insert(i:int,uc:KtCore.Katie.QChar,len:int)->KtCore.Katie.QString", + "1:KtCore.Katie.QString.insert(i:int,s:KtCore.Katie.QLatin1String)->KtCore.Katie.QString", + "0:KtCore.Katie.QString.insert(i:int,s:KtCore.Katie.QString)->KtCore.Katie.QString", + "KtCore.Katie.QString.isDetached()->bool", + "KtCore.Katie.QString.isEmpty()->bool", + "KtCore.Katie.QString.isNull()->bool", + "KtCore.Katie.QString.isRightToLeft()->bool", + "KtCore.Katie.QString.isSharedWith(other:KtCore.Katie.QString)->bool", + "KtCore.Katie.QString.isSimpleText()->bool", + "2:KtCore.Katie.QString.lastIndexOf(c:KtCore.Katie.QChar,from:int=-1,cs:KtCore.Katie.Qt.CaseSensitivity=Qt.CaseSensitive)->int", + "1:KtCore.Katie.QString.lastIndexOf(s:KtCore.Katie.QLatin1String,from:int=-1,cs:KtCore.Katie.Qt.CaseSensitivity=Qt.CaseSensitive)->int", + "0:KtCore.Katie.QString.lastIndexOf(s:KtCore.Katie.QString,from:int=-1,cs:KtCore.Katie.Qt.CaseSensitivity=Qt.CaseSensitive)->int", + "KtCore.Katie.QString.left(n:int)->KtCore.Katie.QString", + "KtCore.Katie.QString.leftJustified(width:int,fill:KtCore.Katie.QChar=QLatin1Char(' '),trunc:bool=false)->KtCore.Katie.QString", + "KtCore.Katie.QString.length()->int", + "1:KtCore.Katie.QString.localeAwareCompare(s:KtCore.Katie.QString)->int", + "0:KtCore.Katie.QString.localeAwareCompare(s1:KtCore.Katie.QString,s2:KtCore.Katie.QString)->int", + "KtCore.Katie.QString.mid(position:int,n:int=-1)->KtCore.Katie.QString", + "1:KtCore.Katie.QString.normalized(mode:KtCore.Katie.QString.NormalizationForm)->KtCore.Katie.QString", + "0:KtCore.Katie.QString.normalized(mode:KtCore.Katie.QString.NormalizationForm,version:KtCore.Katie.QChar.UnicodeVersion)->KtCore.Katie.QString", + "6:KtCore.Katie.QString.number(arg__1:double,f:char='g',prec:int=6)->KtCore.Katie.QString", + "5:KtCore.Katie.QString.number(arg__1:int,base:int=10)->KtCore.Katie.QString", + "4:KtCore.Katie.QString.number(arg__1:long,base:int=10)->KtCore.Katie.QString", + "3:KtCore.Katie.QString.number(arg__1:long long,base:int=10)->KtCore.Katie.QString", + "2:KtCore.Katie.QString.number(arg__1:unsigned int,base:int=10)->KtCore.Katie.QString", + "1:KtCore.Katie.QString.number(arg__1:ulong,base:int=10)->KtCore.Katie.QString", + "0:KtCore.Katie.QString.number(arg__1:unsigned long long,base:int=10)->KtCore.Katie.QString", + "4:KtCore.Katie.QString.prepend(c:KtCore.Katie.QChar)->KtCore.Katie.QString", + "3:KtCore.Katie.QString.prepend(s:KtCore.Katie.QByteArray)->KtCore.Katie.QString", + "2:KtCore.Katie.QString.prepend(s:KtCore.Katie.QLatin1String)->KtCore.Katie.QString", + "1:KtCore.Katie.QString.prepend(s:KtCore.Katie.QString)->KtCore.Katie.QString", + "0:KtCore.Katie.QString.prepend(s:str)->KtCore.Katie.QString", + "1:KtCore.Katie.QString.push_back(c:KtCore.Katie.QChar)", + "0:KtCore.Katie.QString.push_back(s:KtCore.Katie.QString)", + "1:KtCore.Katie.QString.push_front(c:KtCore.Katie.QChar)", + "0:KtCore.Katie.QString.push_front(s:KtCore.Katie.QString)", + "2:KtCore.Katie.QString.remove(c:KtCore.Katie.QChar,cs:KtCore.Katie.Qt.CaseSensitivity=Qt.CaseSensitive)->KtCore.Katie.QString", + "1:KtCore.Katie.QString.remove(s:KtCore.Katie.QString,cs:KtCore.Katie.Qt.CaseSensitivity=Qt.CaseSensitive)->KtCore.Katie.QString", + "0:KtCore.Katie.QString.remove(i:int,len:int)->KtCore.Katie.QString", + "KtCore.Katie.QString.repeated(times:int)->KtCore.Katie.QString", + "10:KtCore.Katie.QString.replace(before:KtCore.Katie.QChar,after:KtCore.Katie.QChar,cs:KtCore.Katie.Qt.CaseSensitivity=Qt.CaseSensitive)->KtCore.Katie.QString", + "9:KtCore.Katie.QString.replace(c:KtCore.Katie.QChar,after:KtCore.Katie.QLatin1String,cs:KtCore.Katie.Qt.CaseSensitivity=Qt.CaseSensitive)->KtCore.Katie.QString", + "8:KtCore.Katie.QString.replace(c:KtCore.Katie.QChar,after:KtCore.Katie.QString,cs:KtCore.Katie.Qt.CaseSensitivity=Qt.CaseSensitive)->KtCore.Katie.QString", + "7:KtCore.Katie.QString.replace(before:KtCore.Katie.QChar,blen:int,after:KtCore.Katie.QChar,alen:int,cs:KtCore.Katie.Qt.CaseSensitivity=Qt.CaseSensitive)->KtCore.Katie.QString", + "6:KtCore.Katie.QString.replace(before:KtCore.Katie.QLatin1String,after:KtCore.Katie.QLatin1String,cs:KtCore.Katie.Qt.CaseSensitivity=Qt.CaseSensitive)->KtCore.Katie.QString", + "5:KtCore.Katie.QString.replace(before:KtCore.Katie.QLatin1String,after:KtCore.Katie.QString,cs:KtCore.Katie.Qt.CaseSensitivity=Qt.CaseSensitive)->KtCore.Katie.QString", + "4:KtCore.Katie.QString.replace(before:KtCore.Katie.QString,after:KtCore.Katie.QLatin1String,cs:KtCore.Katie.Qt.CaseSensitivity=Qt.CaseSensitive)->KtCore.Katie.QString", + "3:KtCore.Katie.QString.replace(before:KtCore.Katie.QString,after:KtCore.Katie.QString,cs:KtCore.Katie.Qt.CaseSensitivity=Qt.CaseSensitive)->KtCore.Katie.QString", + "2:KtCore.Katie.QString.replace(i:int,len:int,after:KtCore.Katie.QChar)->KtCore.Katie.QString", + "1:KtCore.Katie.QString.replace(i:int,len:int,s:KtCore.Katie.QChar,slen:int)->KtCore.Katie.QString", + "0:KtCore.Katie.QString.replace(i:int,len:int,after:KtCore.Katie.QString)->KtCore.Katie.QString", + "KtCore.Katie.QString.reserve(size:int)", + "KtCore.Katie.QString.resize(size:int)", + "KtCore.Katie.QString.right(n:int)->KtCore.Katie.QString", + "KtCore.Katie.QString.rightJustified(width:int,fill:KtCore.Katie.QChar=QLatin1Char(' '),trunc:bool=false)->KtCore.Katie.QString", + "1:KtCore.Katie.QString.section(sep:KtCore.Katie.QChar,start:int,end:int=-1,flags:Katie.QString.SectionFlags=SectionDefault)->KtCore.Katie.QString", + "0:KtCore.Katie.QString.section(in_sep:KtCore.Katie.QString,start:int,end:int=-1,flags:Katie.QString.SectionFlags=SectionDefault)->KtCore.Katie.QString", + "9:KtCore.Katie.QString.setNum(arg__1:double,f:char='g',prec:int=6)->KtCore.Katie.QString", + "8:KtCore.Katie.QString.setNum(arg__1:float,f:char='g',prec:int=6)->KtCore.Katie.QString", + "7:KtCore.Katie.QString.setNum(arg__1:int,base:int=10)->KtCore.Katie.QString", + "6:KtCore.Katie.QString.setNum(arg__1:long,base:int=10)->KtCore.Katie.QString", + "5:KtCore.Katie.QString.setNum(arg__1:long long,base:int=10)->KtCore.Katie.QString", + "4:KtCore.Katie.QString.setNum(arg__1:short,base:int=10)->KtCore.Katie.QString", + "3:KtCore.Katie.QString.setNum(arg__1:unsigned int,base:int=10)->KtCore.Katie.QString", + "2:KtCore.Katie.QString.setNum(arg__1:ulong,base:int=10)->KtCore.Katie.QString", + "1:KtCore.Katie.QString.setNum(arg__1:unsigned long long,base:int=10)->KtCore.Katie.QString", + "0:KtCore.Katie.QString.setNum(arg__1:ushort,base:int=10)->KtCore.Katie.QString", + "KtCore.Katie.QString.setRawData(unicode:KtCore.Katie.QChar,size:int)->KtCore.Katie.QString", + "KtCore.Katie.QString.setUnicode(unicode:KtCore.Katie.QChar,size:int)->KtCore.Katie.QString", + "KtCore.Katie.QString.setUtf16(utf16:KtCore.ushort,size:int)->KtCore.Katie.QString", + "KtCore.Katie.QString.simplified()->KtCore.Katie.QString", + "KtCore.Katie.QString.size()->int", + "KtCore.Katie.QString.sprintf(format:str)->KtCore.Katie.QString", + "KtCore.Katie.QString.squeeze()", + "2:KtCore.Katie.QString.startsWith(c:KtCore.Katie.QChar,cs:KtCore.Katie.Qt.CaseSensitivity=Qt.CaseSensitive)->bool", + "1:KtCore.Katie.QString.startsWith(s:KtCore.Katie.QLatin1String,cs:KtCore.Katie.Qt.CaseSensitivity=Qt.CaseSensitive)->bool", + "0:KtCore.Katie.QString.startsWith(s:KtCore.Katie.QString,cs:KtCore.Katie.Qt.CaseSensitivity=Qt.CaseSensitive)->bool", + "KtCore.Katie.QString.swap(other:KtCore.Katie.QString)", + "KtCore.Katie.QString.toAscii()->KtCore.Katie.QByteArray", + "KtCore.Katie.QString.toCaseFolded()->KtCore.Katie.QString", + "KtCore.Katie.QString.toDouble(ok:KtCore.bool=Q_NULLPTR)->double", + "KtCore.Katie.QString.toFloat(ok:KtCore.bool=Q_NULLPTR)->float", + "KtCore.Katie.QString.toInt(ok:KtCore.bool=Q_NULLPTR,base:int=10)->int", + "KtCore.Katie.QString.toLatin1()->KtCore.Katie.QByteArray", + "KtCore.Katie.QString.toLocal8Bit()->KtCore.Katie.QByteArray", + "KtCore.Katie.QString.toLong(ok:KtCore.bool=Q_NULLPTR,base:int=10)->long", + "KtCore.Katie.QString.toLongLong(ok:KtCore.bool=Q_NULLPTR,base:int=10)->long long", + "KtCore.Katie.QString.toLower()->KtCore.Katie.QString", + "KtCore.Katie.QString.toShort(ok:KtCore.bool=Q_NULLPTR,base:int=10)->short", + "KtCore.Katie.QString.toStdString()->std.string", + "KtCore.Katie.QString.toUInt(ok:KtCore.bool=Q_NULLPTR,base:int=10)->unsigned int", + "KtCore.Katie.QString.toULong(ok:KtCore.bool=Q_NULLPTR,base:int=10)->ulong", + "KtCore.Katie.QString.toULongLong(ok:KtCore.bool=Q_NULLPTR,base:int=10)->unsigned long long", + "KtCore.Katie.QString.toUShort(ok:KtCore.bool=Q_NULLPTR,base:int=10)->ushort", + "KtCore.Katie.QString.toUpper()->KtCore.Katie.QString", + "KtCore.Katie.QString.toUtf8()->KtCore.Katie.QByteArray", + "KtCore.Katie.QString.trimmed()->KtCore.Katie.QString", + "KtCore.Katie.QString.truncate(pos:int)", + "KtCore.Katie.QString.unicode()->KtCore.Katie.QChar", + "KtCore.Katie.QString.utf16()->KtCore.ushort", + "6:KtCore.Katie.QString.__iadd__(c:KtCore.Katie.QChar)->KtCore.Katie.QString", + "5:KtCore.Katie.QString.__iadd__(c:KtCore.Katie.QChar.SpecialCharacter)->KtCore.Katie.QString", + "4:KtCore.Katie.QString.__iadd__(c:char)->KtCore.Katie.QString", + "3:KtCore.Katie.QString.__iadd__(s:KtCore.Katie.QByteArray)->KtCore.Katie.QString", + "2:KtCore.Katie.QString.__iadd__(s:KtCore.Katie.QLatin1String)->KtCore.Katie.QString", + "1:KtCore.Katie.QString.__iadd__(s:KtCore.Katie.QString)->KtCore.Katie.QString", + "0:KtCore.Katie.QString.__iadd__(s:str)->KtCore.Katie.QString", + nullptr}; // Sentinel + +void init_Katie_QString(PyObject* module) +{ + _Sbk_Katie_QString_Type = Shiboken::ObjectType::introduceWrapperType( + module, + "QString", + "Katie::QString*", + &Sbk_Katie_QString_spec, + Katie_QString_SignatureStrings, + &Shiboken::callCppDestructor< ::Katie::QString >, + 0, + 0, + 0 ); + + SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX] + = reinterpret_cast(Sbk_Katie_QString_TypeF()); + + // Register Converter + SbkConverter* converter = Shiboken::Conversions::createConverter(Sbk_Katie_QString_TypeF(), + QString_PythonToCpp_QString_PTR, + is_QString_PythonToCpp_QString_PTR_Convertible, + QString_PTR_CppToPython_QString); + + Shiboken::Conversions::registerConverterName(converter, "Katie::QString"); + Shiboken::Conversions::registerConverterName(converter, "Katie::QString*"); + Shiboken::Conversions::registerConverterName(converter, "Katie::QString&"); + Shiboken::Conversions::registerConverterName(converter, "QString"); + Shiboken::Conversions::registerConverterName(converter, "QString*"); + Shiboken::Conversions::registerConverterName(converter, "QString&"); + Shiboken::Conversions::registerConverterName(converter, typeid(::Katie::QString).name()); + + + // Initialization of enums. + + // Initialization of enum 'SectionFlag'. + SbkKtCoreTypes[SBK_KATIE_QSTRING_SECTIONFLAG_IDX] = Shiboken::Enum::createScopedEnum(Sbk_Katie_QString_TypeF(), + "SectionFlag", + "KtCore.Katie.QString.SectionFlag", + "Katie::QString::SectionFlag"); + if (!SbkKtCoreTypes[SBK_KATIE_QSTRING_SECTIONFLAG_IDX]) + return; + + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QSTRING_SECTIONFLAG_IDX], + Sbk_Katie_QString_TypeF(), "SectionDefault", (long) Katie::QString::SectionFlag::SectionDefault)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QSTRING_SECTIONFLAG_IDX], + Sbk_Katie_QString_TypeF(), "SectionSkipEmpty", (long) Katie::QString::SectionFlag::SectionSkipEmpty)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QSTRING_SECTIONFLAG_IDX], + Sbk_Katie_QString_TypeF(), "SectionIncludeLeadingSep", (long) Katie::QString::SectionFlag::SectionIncludeLeadingSep)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QSTRING_SECTIONFLAG_IDX], + Sbk_Katie_QString_TypeF(), "SectionIncludeTrailingSep", (long) Katie::QString::SectionFlag::SectionIncludeTrailingSep)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QSTRING_SECTIONFLAG_IDX], + Sbk_Katie_QString_TypeF(), "SectionCaseInsensitiveSeps", (long) Katie::QString::SectionFlag::SectionCaseInsensitiveSeps)) + return; + // Register converter for enum 'Katie::QString::SectionFlag'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QSTRING_SECTIONFLAG_IDX], + Katie_QString_SectionFlag_CppToPython_Katie_QString_SectionFlag); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_QString_SectionFlag_PythonToCpp_Katie_QString_SectionFlag, + is_Katie_QString_SectionFlag_PythonToCpp_Katie_QString_SectionFlag_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QSTRING_SECTIONFLAG_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::QString::SectionFlag"); + Shiboken::Conversions::registerConverterName(converter, "QString::SectionFlag"); + Shiboken::Conversions::registerConverterName(converter, "SectionFlag"); + } + // End of 'SectionFlag' enum. + + // Initialization of enum 'SplitBehavior'. + SbkKtCoreTypes[SBK_KATIE_QSTRING_SPLITBEHAVIOR_IDX] = Shiboken::Enum::createScopedEnum(Sbk_Katie_QString_TypeF(), + "SplitBehavior", + "KtCore.Katie.QString.SplitBehavior", + "Katie::QString::SplitBehavior"); + if (!SbkKtCoreTypes[SBK_KATIE_QSTRING_SPLITBEHAVIOR_IDX]) + return; + + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QSTRING_SPLITBEHAVIOR_IDX], + Sbk_Katie_QString_TypeF(), "KeepEmptyParts", (long) Katie::QString::SplitBehavior::KeepEmptyParts)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QSTRING_SPLITBEHAVIOR_IDX], + Sbk_Katie_QString_TypeF(), "SkipEmptyParts", (long) Katie::QString::SplitBehavior::SkipEmptyParts)) + return; + // Register converter for enum 'Katie::QString::SplitBehavior'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QSTRING_SPLITBEHAVIOR_IDX], + Katie_QString_SplitBehavior_CppToPython_Katie_QString_SplitBehavior); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_QString_SplitBehavior_PythonToCpp_Katie_QString_SplitBehavior, + is_Katie_QString_SplitBehavior_PythonToCpp_Katie_QString_SplitBehavior_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QSTRING_SPLITBEHAVIOR_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::QString::SplitBehavior"); + Shiboken::Conversions::registerConverterName(converter, "QString::SplitBehavior"); + Shiboken::Conversions::registerConverterName(converter, "SplitBehavior"); + } + // End of 'SplitBehavior' enum. + + // Initialization of enum 'NormalizationForm'. + SbkKtCoreTypes[SBK_KATIE_QSTRING_NORMALIZATIONFORM_IDX] = Shiboken::Enum::createScopedEnum(Sbk_Katie_QString_TypeF(), + "NormalizationForm", + "KtCore.Katie.QString.NormalizationForm", + "Katie::QString::NormalizationForm"); + if (!SbkKtCoreTypes[SBK_KATIE_QSTRING_NORMALIZATIONFORM_IDX]) + return; + + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QSTRING_NORMALIZATIONFORM_IDX], + Sbk_Katie_QString_TypeF(), "NormalizationForm_D", (long) Katie::QString::NormalizationForm::NormalizationForm_D)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QSTRING_NORMALIZATIONFORM_IDX], + Sbk_Katie_QString_TypeF(), "NormalizationForm_C", (long) Katie::QString::NormalizationForm::NormalizationForm_C)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QSTRING_NORMALIZATIONFORM_IDX], + Sbk_Katie_QString_TypeF(), "NormalizationForm_KD", (long) Katie::QString::NormalizationForm::NormalizationForm_KD)) + return; + if (!Shiboken::Enum::createScopedEnumItem(SbkKtCoreTypes[SBK_KATIE_QSTRING_NORMALIZATIONFORM_IDX], + Sbk_Katie_QString_TypeF(), "NormalizationForm_KC", (long) Katie::QString::NormalizationForm::NormalizationForm_KC)) + return; + // Register converter for enum 'Katie::QString::NormalizationForm'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QSTRING_NORMALIZATIONFORM_IDX], + Katie_QString_NormalizationForm_CppToPython_Katie_QString_NormalizationForm); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_QString_NormalizationForm_PythonToCpp_Katie_QString_NormalizationForm, + is_Katie_QString_NormalizationForm_PythonToCpp_Katie_QString_NormalizationForm_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QSTRING_NORMALIZATIONFORM_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::QString::NormalizationForm"); + Shiboken::Conversions::registerConverterName(converter, "QString::NormalizationForm"); + Shiboken::Conversions::registerConverterName(converter, "NormalizationForm"); + } + // End of 'NormalizationForm' enum. + + +} diff --git a/bindings/KtCore/katie_qstring_wrapper.h b/bindings/KtCore/katie_qstring_wrapper.h new file mode 100644 index 000000000..be32b2ef9 --- /dev/null +++ b/bindings/KtCore/katie_qstring_wrapper.h @@ -0,0 +1,47 @@ +/**************************************************************************** +** +** Copyright (C) 2015 The Qt Company Ltd. +** Contact: http://www.qt.io/licensing/ +** +** This file is part of the FOO module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of The Qt Company Ltd nor the names of its +** contributors may be used to endorse or promote products derived +** from this software without specific prior written permission. +** +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef SBK_KATIE_QSTRING_H +#define SBK_KATIE_QSTRING_H + +#include + +#endif // SBK_KATIE_QSTRING_H + diff --git a/bindings/KtCore/ktcore_module_wrapper.cpp b/bindings/KtCore/ktcore_module_wrapper.cpp new file mode 100644 index 000000000..8384cb89a --- /dev/null +++ b/bindings/KtCore/ktcore_module_wrapper.cpp @@ -0,0 +1,5770 @@ +/**************************************************************************** +** +** Copyright (C) 2015 The Qt Company Ltd. +** Contact: http://www.qt.io/licensing/ +** +** This file is part of the FOO module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of The Qt Company Ltd nor the names of its +** contributors may be used to endorse or promote products derived +** from this software without specific prior written permission. +** +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + +#include +#include +#include +#include +#include "ktcore_python.h" + + + +// Extra includes + +// Current module's type array. +PyTypeObject** SbkKtCoreTypes = nullptr; +// Current module's PyObject pointer. +PyObject* SbkKtCoreModuleObject = nullptr; +// Current module's converter array. +SbkConverter** SbkKtCoreTypeConverters = nullptr; +// Global functions ------------------------------------------------------------ + +static PyMethodDef KtCore_methods[] = { + {0} // Sentinel +}; + +// Classes initialization functions ------------------------------------------------------------ +void init_Katie_QObject(PyObject* module); +void init_Katie_QLatin1String(PyObject* module); +void init_Katie_QLatin1Char(PyObject* module); +void init_Katie_QCoreApplication(PyObject* module); +void init_Katie_QChar(PyObject* module); +void init_Katie_QString(PyObject* module); +void init_Katie_QByteArray(PyObject* module); + +// Enum definitions ------------------------------------------------------------ +static void Katie_QtMsgType_PythonToCpp_Katie_QtMsgType(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::QtMsgType*>(cppOut) = + static_cast<::Katie::QtMsgType>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_QtMsgType_PythonToCpp_Katie_QtMsgType_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QTMSGTYPE_IDX])) + return Katie_QtMsgType_PythonToCpp_Katie_QtMsgType; + return {}; +} +static PyObject* Katie_QtMsgType_CppToPython_Katie_QtMsgType(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QTMSGTYPE_IDX], castCppIn); + +} + + +static void Katie_Qt_GlobalColor_PythonToCpp_Katie_Qt_GlobalColor(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::GlobalColor*>(cppOut) = + static_cast<::Katie::Qt::GlobalColor>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_GlobalColor_PythonToCpp_Katie_Qt_GlobalColor_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_GLOBALCOLOR_IDX])) + return Katie_Qt_GlobalColor_PythonToCpp_Katie_Qt_GlobalColor; + return {}; +} +static PyObject* Katie_Qt_GlobalColor_CppToPython_Katie_Qt_GlobalColor(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_GLOBALCOLOR_IDX], castCppIn); + +} + + +static void Katie_Qt_KeyboardModifier_PythonToCpp_Katie_Qt_KeyboardModifier(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::KeyboardModifier*>(cppOut) = + static_cast<::Katie::Qt::KeyboardModifier>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_KeyboardModifier_PythonToCpp_Katie_Qt_KeyboardModifier_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_KEYBOARDMODIFIER_IDX])) + return Katie_Qt_KeyboardModifier_PythonToCpp_Katie_Qt_KeyboardModifier; + return {}; +} +static PyObject* Katie_Qt_KeyboardModifier_CppToPython_Katie_Qt_KeyboardModifier(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_KEYBOARDMODIFIER_IDX], castCppIn); + +} + + +static void Katie_Qt_Modifier_PythonToCpp_Katie_Qt_Modifier(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::Modifier*>(cppOut) = + static_cast<::Katie::Qt::Modifier>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_Modifier_PythonToCpp_Katie_Qt_Modifier_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_MODIFIER_IDX])) + return Katie_Qt_Modifier_PythonToCpp_Katie_Qt_Modifier; + return {}; +} +static PyObject* Katie_Qt_Modifier_CppToPython_Katie_Qt_Modifier(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_MODIFIER_IDX], castCppIn); + +} + + +static void Katie_Qt_MouseButton_PythonToCpp_Katie_Qt_MouseButton(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::MouseButton*>(cppOut) = + static_cast<::Katie::Qt::MouseButton>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_MouseButton_PythonToCpp_Katie_Qt_MouseButton_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_MOUSEBUTTON_IDX])) + return Katie_Qt_MouseButton_PythonToCpp_Katie_Qt_MouseButton; + return {}; +} +static PyObject* Katie_Qt_MouseButton_CppToPython_Katie_Qt_MouseButton(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_MOUSEBUTTON_IDX], castCppIn); + +} + + +static void Katie_Qt_Orientation_PythonToCpp_Katie_Qt_Orientation(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::Orientation*>(cppOut) = + static_cast<::Katie::Qt::Orientation>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_Orientation_PythonToCpp_Katie_Qt_Orientation_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_ORIENTATION_IDX])) + return Katie_Qt_Orientation_PythonToCpp_Katie_Qt_Orientation; + return {}; +} +static PyObject* Katie_Qt_Orientation_CppToPython_Katie_Qt_Orientation(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_ORIENTATION_IDX], castCppIn); + +} + + +static void Katie_Qt_FocusPolicy_PythonToCpp_Katie_Qt_FocusPolicy(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::FocusPolicy*>(cppOut) = + static_cast<::Katie::Qt::FocusPolicy>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_FocusPolicy_PythonToCpp_Katie_Qt_FocusPolicy_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_FOCUSPOLICY_IDX])) + return Katie_Qt_FocusPolicy_PythonToCpp_Katie_Qt_FocusPolicy; + return {}; +} +static PyObject* Katie_Qt_FocusPolicy_CppToPython_Katie_Qt_FocusPolicy(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_FOCUSPOLICY_IDX], castCppIn); + +} + + +static void Katie_Qt_SortOrder_PythonToCpp_Katie_Qt_SortOrder(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::SortOrder*>(cppOut) = + static_cast<::Katie::Qt::SortOrder>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_SortOrder_PythonToCpp_Katie_Qt_SortOrder_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_SORTORDER_IDX])) + return Katie_Qt_SortOrder_PythonToCpp_Katie_Qt_SortOrder; + return {}; +} +static PyObject* Katie_Qt_SortOrder_CppToPython_Katie_Qt_SortOrder(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_SORTORDER_IDX], castCppIn); + +} + + +static void Katie_Qt_TileRule_PythonToCpp_Katie_Qt_TileRule(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::TileRule*>(cppOut) = + static_cast<::Katie::Qt::TileRule>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_TileRule_PythonToCpp_Katie_Qt_TileRule_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_TILERULE_IDX])) + return Katie_Qt_TileRule_PythonToCpp_Katie_Qt_TileRule; + return {}; +} +static PyObject* Katie_Qt_TileRule_CppToPython_Katie_Qt_TileRule(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_TILERULE_IDX], castCppIn); + +} + + +static void Katie_Qt_AlignmentFlag_PythonToCpp_Katie_Qt_AlignmentFlag(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::AlignmentFlag*>(cppOut) = + static_cast<::Katie::Qt::AlignmentFlag>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_AlignmentFlag_PythonToCpp_Katie_Qt_AlignmentFlag_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_ALIGNMENTFLAG_IDX])) + return Katie_Qt_AlignmentFlag_PythonToCpp_Katie_Qt_AlignmentFlag; + return {}; +} +static PyObject* Katie_Qt_AlignmentFlag_CppToPython_Katie_Qt_AlignmentFlag(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_ALIGNMENTFLAG_IDX], castCppIn); + +} + + +static void Katie_Qt_TextFlag_PythonToCpp_Katie_Qt_TextFlag(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::TextFlag*>(cppOut) = + static_cast<::Katie::Qt::TextFlag>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_TextFlag_PythonToCpp_Katie_Qt_TextFlag_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_TEXTFLAG_IDX])) + return Katie_Qt_TextFlag_PythonToCpp_Katie_Qt_TextFlag; + return {}; +} +static PyObject* Katie_Qt_TextFlag_CppToPython_Katie_Qt_TextFlag(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_TEXTFLAG_IDX], castCppIn); + +} + + +static void Katie_Qt_TextElideMode_PythonToCpp_Katie_Qt_TextElideMode(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::TextElideMode*>(cppOut) = + static_cast<::Katie::Qt::TextElideMode>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_TextElideMode_PythonToCpp_Katie_Qt_TextElideMode_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_TEXTELIDEMODE_IDX])) + return Katie_Qt_TextElideMode_PythonToCpp_Katie_Qt_TextElideMode; + return {}; +} +static PyObject* Katie_Qt_TextElideMode_CppToPython_Katie_Qt_TextElideMode(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_TEXTELIDEMODE_IDX], castCppIn); + +} + + +static void Katie_Qt_WindowType_PythonToCpp_Katie_Qt_WindowType(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::WindowType*>(cppOut) = + static_cast<::Katie::Qt::WindowType>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_WindowType_PythonToCpp_Katie_Qt_WindowType_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_WINDOWTYPE_IDX])) + return Katie_Qt_WindowType_PythonToCpp_Katie_Qt_WindowType; + return {}; +} +static PyObject* Katie_Qt_WindowType_CppToPython_Katie_Qt_WindowType(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWTYPE_IDX], castCppIn); + +} + + +static void Katie_Qt_WindowState_PythonToCpp_Katie_Qt_WindowState(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::WindowState*>(cppOut) = + static_cast<::Katie::Qt::WindowState>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_WindowState_PythonToCpp_Katie_Qt_WindowState_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_WINDOWSTATE_IDX])) + return Katie_Qt_WindowState_PythonToCpp_Katie_Qt_WindowState; + return {}; +} +static PyObject* Katie_Qt_WindowState_CppToPython_Katie_Qt_WindowState(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWSTATE_IDX], castCppIn); + +} + + +static void Katie_Qt_WidgetAttribute_PythonToCpp_Katie_Qt_WidgetAttribute(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::WidgetAttribute*>(cppOut) = + static_cast<::Katie::Qt::WidgetAttribute>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_WidgetAttribute_PythonToCpp_Katie_Qt_WidgetAttribute_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX])) + return Katie_Qt_WidgetAttribute_PythonToCpp_Katie_Qt_WidgetAttribute; + return {}; +} +static PyObject* Katie_Qt_WidgetAttribute_CppToPython_Katie_Qt_WidgetAttribute(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], castCppIn); + +} + + +static void Katie_Qt_ApplicationAttribute_PythonToCpp_Katie_Qt_ApplicationAttribute(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::ApplicationAttribute*>(cppOut) = + static_cast<::Katie::Qt::ApplicationAttribute>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_ApplicationAttribute_PythonToCpp_Katie_Qt_ApplicationAttribute_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_APPLICATIONATTRIBUTE_IDX])) + return Katie_Qt_ApplicationAttribute_PythonToCpp_Katie_Qt_ApplicationAttribute; + return {}; +} +static PyObject* Katie_Qt_ApplicationAttribute_CppToPython_Katie_Qt_ApplicationAttribute(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_APPLICATIONATTRIBUTE_IDX], castCppIn); + +} + + +static void Katie_Qt_ImageConversionFlag_PythonToCpp_Katie_Qt_ImageConversionFlag(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::ImageConversionFlag*>(cppOut) = + static_cast<::Katie::Qt::ImageConversionFlag>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_ImageConversionFlag_PythonToCpp_Katie_Qt_ImageConversionFlag_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_IMAGECONVERSIONFLAG_IDX])) + return Katie_Qt_ImageConversionFlag_PythonToCpp_Katie_Qt_ImageConversionFlag; + return {}; +} +static PyObject* Katie_Qt_ImageConversionFlag_CppToPython_Katie_Qt_ImageConversionFlag(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_IMAGECONVERSIONFLAG_IDX], castCppIn); + +} + + +static void Katie_Qt_BGMode_PythonToCpp_Katie_Qt_BGMode(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::BGMode*>(cppOut) = + static_cast<::Katie::Qt::BGMode>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_BGMode_PythonToCpp_Katie_Qt_BGMode_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_BGMODE_IDX])) + return Katie_Qt_BGMode_PythonToCpp_Katie_Qt_BGMode; + return {}; +} +static PyObject* Katie_Qt_BGMode_CppToPython_Katie_Qt_BGMode(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_BGMODE_IDX], castCppIn); + +} + + +static void Katie_Qt_Key_PythonToCpp_Katie_Qt_Key(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::Key*>(cppOut) = + static_cast<::Katie::Qt::Key>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_Key_PythonToCpp_Katie_Qt_Key_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX])) + return Katie_Qt_Key_PythonToCpp_Katie_Qt_Key; + return {}; +} +static PyObject* Katie_Qt_Key_CppToPython_Katie_Qt_Key(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], castCppIn); + +} + + +static void Katie_Qt_ArrowType_PythonToCpp_Katie_Qt_ArrowType(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::ArrowType*>(cppOut) = + static_cast<::Katie::Qt::ArrowType>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_ArrowType_PythonToCpp_Katie_Qt_ArrowType_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_ARROWTYPE_IDX])) + return Katie_Qt_ArrowType_PythonToCpp_Katie_Qt_ArrowType; + return {}; +} +static PyObject* Katie_Qt_ArrowType_CppToPython_Katie_Qt_ArrowType(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_ARROWTYPE_IDX], castCppIn); + +} + + +static void Katie_Qt_PenStyle_PythonToCpp_Katie_Qt_PenStyle(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::PenStyle*>(cppOut) = + static_cast<::Katie::Qt::PenStyle>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_PenStyle_PythonToCpp_Katie_Qt_PenStyle_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_PENSTYLE_IDX])) + return Katie_Qt_PenStyle_PythonToCpp_Katie_Qt_PenStyle; + return {}; +} +static PyObject* Katie_Qt_PenStyle_CppToPython_Katie_Qt_PenStyle(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_PENSTYLE_IDX], castCppIn); + +} + + +static void Katie_Qt_PenCapStyle_PythonToCpp_Katie_Qt_PenCapStyle(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::PenCapStyle*>(cppOut) = + static_cast<::Katie::Qt::PenCapStyle>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_PenCapStyle_PythonToCpp_Katie_Qt_PenCapStyle_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_PENCAPSTYLE_IDX])) + return Katie_Qt_PenCapStyle_PythonToCpp_Katie_Qt_PenCapStyle; + return {}; +} +static PyObject* Katie_Qt_PenCapStyle_CppToPython_Katie_Qt_PenCapStyle(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_PENCAPSTYLE_IDX], castCppIn); + +} + + +static void Katie_Qt_PenJoinStyle_PythonToCpp_Katie_Qt_PenJoinStyle(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::PenJoinStyle*>(cppOut) = + static_cast<::Katie::Qt::PenJoinStyle>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_PenJoinStyle_PythonToCpp_Katie_Qt_PenJoinStyle_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_PENJOINSTYLE_IDX])) + return Katie_Qt_PenJoinStyle_PythonToCpp_Katie_Qt_PenJoinStyle; + return {}; +} +static PyObject* Katie_Qt_PenJoinStyle_CppToPython_Katie_Qt_PenJoinStyle(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_PENJOINSTYLE_IDX], castCppIn); + +} + + +static void Katie_Qt_BrushStyle_PythonToCpp_Katie_Qt_BrushStyle(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::BrushStyle*>(cppOut) = + static_cast<::Katie::Qt::BrushStyle>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_BrushStyle_PythonToCpp_Katie_Qt_BrushStyle_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_BRUSHSTYLE_IDX])) + return Katie_Qt_BrushStyle_PythonToCpp_Katie_Qt_BrushStyle; + return {}; +} +static PyObject* Katie_Qt_BrushStyle_CppToPython_Katie_Qt_BrushStyle(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_BRUSHSTYLE_IDX], castCppIn); + +} + + +static void Katie_Qt_SizeMode_PythonToCpp_Katie_Qt_SizeMode(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::SizeMode*>(cppOut) = + static_cast<::Katie::Qt::SizeMode>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_SizeMode_PythonToCpp_Katie_Qt_SizeMode_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_SIZEMODE_IDX])) + return Katie_Qt_SizeMode_PythonToCpp_Katie_Qt_SizeMode; + return {}; +} +static PyObject* Katie_Qt_SizeMode_CppToPython_Katie_Qt_SizeMode(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_SIZEMODE_IDX], castCppIn); + +} + + +static void Katie_Qt_UIEffect_PythonToCpp_Katie_Qt_UIEffect(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::UIEffect*>(cppOut) = + static_cast<::Katie::Qt::UIEffect>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_UIEffect_PythonToCpp_Katie_Qt_UIEffect_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_UIEFFECT_IDX])) + return Katie_Qt_UIEffect_PythonToCpp_Katie_Qt_UIEffect; + return {}; +} +static PyObject* Katie_Qt_UIEffect_CppToPython_Katie_Qt_UIEffect(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_UIEFFECT_IDX], castCppIn); + +} + + +static void Katie_Qt_CursorShape_PythonToCpp_Katie_Qt_CursorShape(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::CursorShape*>(cppOut) = + static_cast<::Katie::Qt::CursorShape>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_CursorShape_PythonToCpp_Katie_Qt_CursorShape_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_CURSORSHAPE_IDX])) + return Katie_Qt_CursorShape_PythonToCpp_Katie_Qt_CursorShape; + return {}; +} +static PyObject* Katie_Qt_CursorShape_CppToPython_Katie_Qt_CursorShape(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_CURSORSHAPE_IDX], castCppIn); + +} + + +static void Katie_Qt_TextFormat_PythonToCpp_Katie_Qt_TextFormat(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::TextFormat*>(cppOut) = + static_cast<::Katie::Qt::TextFormat>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_TextFormat_PythonToCpp_Katie_Qt_TextFormat_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_TEXTFORMAT_IDX])) + return Katie_Qt_TextFormat_PythonToCpp_Katie_Qt_TextFormat; + return {}; +} +static PyObject* Katie_Qt_TextFormat_CppToPython_Katie_Qt_TextFormat(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_TEXTFORMAT_IDX], castCppIn); + +} + + +static void Katie_Qt_AspectRatioMode_PythonToCpp_Katie_Qt_AspectRatioMode(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::AspectRatioMode*>(cppOut) = + static_cast<::Katie::Qt::AspectRatioMode>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_AspectRatioMode_PythonToCpp_Katie_Qt_AspectRatioMode_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_ASPECTRATIOMODE_IDX])) + return Katie_Qt_AspectRatioMode_PythonToCpp_Katie_Qt_AspectRatioMode; + return {}; +} +static PyObject* Katie_Qt_AspectRatioMode_CppToPython_Katie_Qt_AspectRatioMode(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_ASPECTRATIOMODE_IDX], castCppIn); + +} + + +static void Katie_Qt_AnchorAttribute_PythonToCpp_Katie_Qt_AnchorAttribute(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::AnchorAttribute*>(cppOut) = + static_cast<::Katie::Qt::AnchorAttribute>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_AnchorAttribute_PythonToCpp_Katie_Qt_AnchorAttribute_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_ANCHORATTRIBUTE_IDX])) + return Katie_Qt_AnchorAttribute_PythonToCpp_Katie_Qt_AnchorAttribute; + return {}; +} +static PyObject* Katie_Qt_AnchorAttribute_CppToPython_Katie_Qt_AnchorAttribute(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_ANCHORATTRIBUTE_IDX], castCppIn); + +} + + +static void Katie_Qt_DockWidgetArea_PythonToCpp_Katie_Qt_DockWidgetArea(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::DockWidgetArea*>(cppOut) = + static_cast<::Katie::Qt::DockWidgetArea>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_DockWidgetArea_PythonToCpp_Katie_Qt_DockWidgetArea_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_DOCKWIDGETAREA_IDX])) + return Katie_Qt_DockWidgetArea_PythonToCpp_Katie_Qt_DockWidgetArea; + return {}; +} +static PyObject* Katie_Qt_DockWidgetArea_CppToPython_Katie_Qt_DockWidgetArea(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_DOCKWIDGETAREA_IDX], castCppIn); + +} + + +static void Katie_Qt_DockWidgetAreaSizes_PythonToCpp_Katie_Qt_DockWidgetAreaSizes(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::DockWidgetAreaSizes*>(cppOut) = + static_cast<::Katie::Qt::DockWidgetAreaSizes>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_DockWidgetAreaSizes_PythonToCpp_Katie_Qt_DockWidgetAreaSizes_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_DOCKWIDGETAREASIZES_IDX])) + return Katie_Qt_DockWidgetAreaSizes_PythonToCpp_Katie_Qt_DockWidgetAreaSizes; + return {}; +} +static PyObject* Katie_Qt_DockWidgetAreaSizes_CppToPython_Katie_Qt_DockWidgetAreaSizes(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_DOCKWIDGETAREASIZES_IDX], castCppIn); + +} + + +static void Katie_Qt_ToolBarArea_PythonToCpp_Katie_Qt_ToolBarArea(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::ToolBarArea*>(cppOut) = + static_cast<::Katie::Qt::ToolBarArea>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_ToolBarArea_PythonToCpp_Katie_Qt_ToolBarArea_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_TOOLBARAREA_IDX])) + return Katie_Qt_ToolBarArea_PythonToCpp_Katie_Qt_ToolBarArea; + return {}; +} +static PyObject* Katie_Qt_ToolBarArea_CppToPython_Katie_Qt_ToolBarArea(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_TOOLBARAREA_IDX], castCppIn); + +} + + +static void Katie_Qt_ToolBarAreaSizes_PythonToCpp_Katie_Qt_ToolBarAreaSizes(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::ToolBarAreaSizes*>(cppOut) = + static_cast<::Katie::Qt::ToolBarAreaSizes>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_ToolBarAreaSizes_PythonToCpp_Katie_Qt_ToolBarAreaSizes_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_TOOLBARAREASIZES_IDX])) + return Katie_Qt_ToolBarAreaSizes_PythonToCpp_Katie_Qt_ToolBarAreaSizes; + return {}; +} +static PyObject* Katie_Qt_ToolBarAreaSizes_CppToPython_Katie_Qt_ToolBarAreaSizes(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_TOOLBARAREASIZES_IDX], castCppIn); + +} + + +static void Katie_Qt_DateFormat_PythonToCpp_Katie_Qt_DateFormat(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::DateFormat*>(cppOut) = + static_cast<::Katie::Qt::DateFormat>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_DateFormat_PythonToCpp_Katie_Qt_DateFormat_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_DATEFORMAT_IDX])) + return Katie_Qt_DateFormat_PythonToCpp_Katie_Qt_DateFormat; + return {}; +} +static PyObject* Katie_Qt_DateFormat_CppToPython_Katie_Qt_DateFormat(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_DATEFORMAT_IDX], castCppIn); + +} + + +static void Katie_Qt_TimeSpec_PythonToCpp_Katie_Qt_TimeSpec(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::TimeSpec*>(cppOut) = + static_cast<::Katie::Qt::TimeSpec>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_TimeSpec_PythonToCpp_Katie_Qt_TimeSpec_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_TIMESPEC_IDX])) + return Katie_Qt_TimeSpec_PythonToCpp_Katie_Qt_TimeSpec; + return {}; +} +static PyObject* Katie_Qt_TimeSpec_CppToPython_Katie_Qt_TimeSpec(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_TIMESPEC_IDX], castCppIn); + +} + + +static void Katie_Qt_DayOfWeek_PythonToCpp_Katie_Qt_DayOfWeek(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::DayOfWeek*>(cppOut) = + static_cast<::Katie::Qt::DayOfWeek>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_DayOfWeek_PythonToCpp_Katie_Qt_DayOfWeek_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_DAYOFWEEK_IDX])) + return Katie_Qt_DayOfWeek_PythonToCpp_Katie_Qt_DayOfWeek; + return {}; +} +static PyObject* Katie_Qt_DayOfWeek_CppToPython_Katie_Qt_DayOfWeek(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_DAYOFWEEK_IDX], castCppIn); + +} + + +static void Katie_Qt_ScrollBarPolicy_PythonToCpp_Katie_Qt_ScrollBarPolicy(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::ScrollBarPolicy*>(cppOut) = + static_cast<::Katie::Qt::ScrollBarPolicy>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_ScrollBarPolicy_PythonToCpp_Katie_Qt_ScrollBarPolicy_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_SCROLLBARPOLICY_IDX])) + return Katie_Qt_ScrollBarPolicy_PythonToCpp_Katie_Qt_ScrollBarPolicy; + return {}; +} +static PyObject* Katie_Qt_ScrollBarPolicy_CppToPython_Katie_Qt_ScrollBarPolicy(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_SCROLLBARPOLICY_IDX], castCppIn); + +} + + +static void Katie_Qt_CaseSensitivity_PythonToCpp_Katie_Qt_CaseSensitivity(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::CaseSensitivity*>(cppOut) = + static_cast<::Katie::Qt::CaseSensitivity>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_CaseSensitivity_PythonToCpp_Katie_Qt_CaseSensitivity_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX])) + return Katie_Qt_CaseSensitivity_PythonToCpp_Katie_Qt_CaseSensitivity; + return {}; +} +static PyObject* Katie_Qt_CaseSensitivity_CppToPython_Katie_Qt_CaseSensitivity(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX], castCppIn); + +} + + +static void Katie_Qt_Corner_PythonToCpp_Katie_Qt_Corner(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::Corner*>(cppOut) = + static_cast<::Katie::Qt::Corner>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_Corner_PythonToCpp_Katie_Qt_Corner_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_CORNER_IDX])) + return Katie_Qt_Corner_PythonToCpp_Katie_Qt_Corner; + return {}; +} +static PyObject* Katie_Qt_Corner_CppToPython_Katie_Qt_Corner(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_CORNER_IDX], castCppIn); + +} + + +static void Katie_Qt_ConnectionType_PythonToCpp_Katie_Qt_ConnectionType(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::ConnectionType*>(cppOut) = + static_cast<::Katie::Qt::ConnectionType>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_ConnectionType_PythonToCpp_Katie_Qt_ConnectionType_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_CONNECTIONTYPE_IDX])) + return Katie_Qt_ConnectionType_PythonToCpp_Katie_Qt_ConnectionType; + return {}; +} +static PyObject* Katie_Qt_ConnectionType_CppToPython_Katie_Qt_ConnectionType(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_CONNECTIONTYPE_IDX], castCppIn); + +} + + +static void Katie_Qt_ShortcutContext_PythonToCpp_Katie_Qt_ShortcutContext(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::ShortcutContext*>(cppOut) = + static_cast<::Katie::Qt::ShortcutContext>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_ShortcutContext_PythonToCpp_Katie_Qt_ShortcutContext_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_SHORTCUTCONTEXT_IDX])) + return Katie_Qt_ShortcutContext_PythonToCpp_Katie_Qt_ShortcutContext; + return {}; +} +static PyObject* Katie_Qt_ShortcutContext_CppToPython_Katie_Qt_ShortcutContext(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_SHORTCUTCONTEXT_IDX], castCppIn); + +} + + +static void Katie_Qt_FillRule_PythonToCpp_Katie_Qt_FillRule(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::FillRule*>(cppOut) = + static_cast<::Katie::Qt::FillRule>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_FillRule_PythonToCpp_Katie_Qt_FillRule_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_FILLRULE_IDX])) + return Katie_Qt_FillRule_PythonToCpp_Katie_Qt_FillRule; + return {}; +} +static PyObject* Katie_Qt_FillRule_CppToPython_Katie_Qt_FillRule(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_FILLRULE_IDX], castCppIn); + +} + + +static void Katie_Qt_MaskMode_PythonToCpp_Katie_Qt_MaskMode(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::MaskMode*>(cppOut) = + static_cast<::Katie::Qt::MaskMode>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_MaskMode_PythonToCpp_Katie_Qt_MaskMode_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_MASKMODE_IDX])) + return Katie_Qt_MaskMode_PythonToCpp_Katie_Qt_MaskMode; + return {}; +} +static PyObject* Katie_Qt_MaskMode_CppToPython_Katie_Qt_MaskMode(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_MASKMODE_IDX], castCppIn); + +} + + +static void Katie_Qt_ClipOperation_PythonToCpp_Katie_Qt_ClipOperation(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::ClipOperation*>(cppOut) = + static_cast<::Katie::Qt::ClipOperation>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_ClipOperation_PythonToCpp_Katie_Qt_ClipOperation_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_CLIPOPERATION_IDX])) + return Katie_Qt_ClipOperation_PythonToCpp_Katie_Qt_ClipOperation; + return {}; +} +static PyObject* Katie_Qt_ClipOperation_CppToPython_Katie_Qt_ClipOperation(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_CLIPOPERATION_IDX], castCppIn); + +} + + +static void Katie_Qt_ItemSelectionMode_PythonToCpp_Katie_Qt_ItemSelectionMode(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::ItemSelectionMode*>(cppOut) = + static_cast<::Katie::Qt::ItemSelectionMode>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_ItemSelectionMode_PythonToCpp_Katie_Qt_ItemSelectionMode_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_ITEMSELECTIONMODE_IDX])) + return Katie_Qt_ItemSelectionMode_PythonToCpp_Katie_Qt_ItemSelectionMode; + return {}; +} +static PyObject* Katie_Qt_ItemSelectionMode_CppToPython_Katie_Qt_ItemSelectionMode(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_ITEMSELECTIONMODE_IDX], castCppIn); + +} + + +static void Katie_Qt_TransformationMode_PythonToCpp_Katie_Qt_TransformationMode(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::TransformationMode*>(cppOut) = + static_cast<::Katie::Qt::TransformationMode>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_TransformationMode_PythonToCpp_Katie_Qt_TransformationMode_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_TRANSFORMATIONMODE_IDX])) + return Katie_Qt_TransformationMode_PythonToCpp_Katie_Qt_TransformationMode; + return {}; +} +static PyObject* Katie_Qt_TransformationMode_CppToPython_Katie_Qt_TransformationMode(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_TRANSFORMATIONMODE_IDX], castCppIn); + +} + + +static void Katie_Qt_Axis_PythonToCpp_Katie_Qt_Axis(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::Axis*>(cppOut) = + static_cast<::Katie::Qt::Axis>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_Axis_PythonToCpp_Katie_Qt_Axis_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_AXIS_IDX])) + return Katie_Qt_Axis_PythonToCpp_Katie_Qt_Axis; + return {}; +} +static PyObject* Katie_Qt_Axis_CppToPython_Katie_Qt_Axis(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_AXIS_IDX], castCppIn); + +} + + +static void Katie_Qt_FocusReason_PythonToCpp_Katie_Qt_FocusReason(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::FocusReason*>(cppOut) = + static_cast<::Katie::Qt::FocusReason>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_FocusReason_PythonToCpp_Katie_Qt_FocusReason_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_FOCUSREASON_IDX])) + return Katie_Qt_FocusReason_PythonToCpp_Katie_Qt_FocusReason; + return {}; +} +static PyObject* Katie_Qt_FocusReason_CppToPython_Katie_Qt_FocusReason(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_FOCUSREASON_IDX], castCppIn); + +} + + +static void Katie_Qt_ContextMenuPolicy_PythonToCpp_Katie_Qt_ContextMenuPolicy(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::ContextMenuPolicy*>(cppOut) = + static_cast<::Katie::Qt::ContextMenuPolicy>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_ContextMenuPolicy_PythonToCpp_Katie_Qt_ContextMenuPolicy_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_CONTEXTMENUPOLICY_IDX])) + return Katie_Qt_ContextMenuPolicy_PythonToCpp_Katie_Qt_ContextMenuPolicy; + return {}; +} +static PyObject* Katie_Qt_ContextMenuPolicy_CppToPython_Katie_Qt_ContextMenuPolicy(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_CONTEXTMENUPOLICY_IDX], castCppIn); + +} + + +static void Katie_Qt_ToolButtonStyle_PythonToCpp_Katie_Qt_ToolButtonStyle(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::ToolButtonStyle*>(cppOut) = + static_cast<::Katie::Qt::ToolButtonStyle>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_ToolButtonStyle_PythonToCpp_Katie_Qt_ToolButtonStyle_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_TOOLBUTTONSTYLE_IDX])) + return Katie_Qt_ToolButtonStyle_PythonToCpp_Katie_Qt_ToolButtonStyle; + return {}; +} +static PyObject* Katie_Qt_ToolButtonStyle_CppToPython_Katie_Qt_ToolButtonStyle(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_TOOLBUTTONSTYLE_IDX], castCppIn); + +} + + +static void Katie_Qt_LayoutDirection_PythonToCpp_Katie_Qt_LayoutDirection(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::LayoutDirection*>(cppOut) = + static_cast<::Katie::Qt::LayoutDirection>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_LayoutDirection_PythonToCpp_Katie_Qt_LayoutDirection_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_LAYOUTDIRECTION_IDX])) + return Katie_Qt_LayoutDirection_PythonToCpp_Katie_Qt_LayoutDirection; + return {}; +} +static PyObject* Katie_Qt_LayoutDirection_CppToPython_Katie_Qt_LayoutDirection(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_LAYOUTDIRECTION_IDX], castCppIn); + +} + + +static void Katie_Qt_AnchorPoint_PythonToCpp_Katie_Qt_AnchorPoint(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::AnchorPoint*>(cppOut) = + static_cast<::Katie::Qt::AnchorPoint>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_AnchorPoint_PythonToCpp_Katie_Qt_AnchorPoint_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_ANCHORPOINT_IDX])) + return Katie_Qt_AnchorPoint_PythonToCpp_Katie_Qt_AnchorPoint; + return {}; +} +static PyObject* Katie_Qt_AnchorPoint_CppToPython_Katie_Qt_AnchorPoint(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_ANCHORPOINT_IDX], castCppIn); + +} + + +static void Katie_Qt_DropAction_PythonToCpp_Katie_Qt_DropAction(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::DropAction*>(cppOut) = + static_cast<::Katie::Qt::DropAction>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_DropAction_PythonToCpp_Katie_Qt_DropAction_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_DROPACTION_IDX])) + return Katie_Qt_DropAction_PythonToCpp_Katie_Qt_DropAction; + return {}; +} +static PyObject* Katie_Qt_DropAction_CppToPython_Katie_Qt_DropAction(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_DROPACTION_IDX], castCppIn); + +} + + +static void Katie_Qt_CheckState_PythonToCpp_Katie_Qt_CheckState(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::CheckState*>(cppOut) = + static_cast<::Katie::Qt::CheckState>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_CheckState_PythonToCpp_Katie_Qt_CheckState_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_CHECKSTATE_IDX])) + return Katie_Qt_CheckState_PythonToCpp_Katie_Qt_CheckState; + return {}; +} +static PyObject* Katie_Qt_CheckState_CppToPython_Katie_Qt_CheckState(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_CHECKSTATE_IDX], castCppIn); + +} + + +static void Katie_Qt_ItemDataRole_PythonToCpp_Katie_Qt_ItemDataRole(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::ItemDataRole*>(cppOut) = + static_cast<::Katie::Qt::ItemDataRole>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_ItemDataRole_PythonToCpp_Katie_Qt_ItemDataRole_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_ITEMDATAROLE_IDX])) + return Katie_Qt_ItemDataRole_PythonToCpp_Katie_Qt_ItemDataRole; + return {}; +} +static PyObject* Katie_Qt_ItemDataRole_CppToPython_Katie_Qt_ItemDataRole(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_ITEMDATAROLE_IDX], castCppIn); + +} + + +static void Katie_Qt_ItemFlag_PythonToCpp_Katie_Qt_ItemFlag(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::ItemFlag*>(cppOut) = + static_cast<::Katie::Qt::ItemFlag>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_ItemFlag_PythonToCpp_Katie_Qt_ItemFlag_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_ITEMFLAG_IDX])) + return Katie_Qt_ItemFlag_PythonToCpp_Katie_Qt_ItemFlag; + return {}; +} +static PyObject* Katie_Qt_ItemFlag_CppToPython_Katie_Qt_ItemFlag(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_ITEMFLAG_IDX], castCppIn); + +} + + +static void Katie_Qt_MatchFlag_PythonToCpp_Katie_Qt_MatchFlag(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::MatchFlag*>(cppOut) = + static_cast<::Katie::Qt::MatchFlag>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_MatchFlag_PythonToCpp_Katie_Qt_MatchFlag_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_MATCHFLAG_IDX])) + return Katie_Qt_MatchFlag_PythonToCpp_Katie_Qt_MatchFlag; + return {}; +} +static PyObject* Katie_Qt_MatchFlag_CppToPython_Katie_Qt_MatchFlag(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_MATCHFLAG_IDX], castCppIn); + +} + + +static void Katie_Qt_WindowModality_PythonToCpp_Katie_Qt_WindowModality(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::WindowModality*>(cppOut) = + static_cast<::Katie::Qt::WindowModality>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_WindowModality_PythonToCpp_Katie_Qt_WindowModality_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_WINDOWMODALITY_IDX])) + return Katie_Qt_WindowModality_PythonToCpp_Katie_Qt_WindowModality; + return {}; +} +static PyObject* Katie_Qt_WindowModality_CppToPython_Katie_Qt_WindowModality(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWMODALITY_IDX], castCppIn); + +} + + +static void Katie_Qt_TextInteractionFlag_PythonToCpp_Katie_Qt_TextInteractionFlag(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::TextInteractionFlag*>(cppOut) = + static_cast<::Katie::Qt::TextInteractionFlag>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_TextInteractionFlag_PythonToCpp_Katie_Qt_TextInteractionFlag_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_TEXTINTERACTIONFLAG_IDX])) + return Katie_Qt_TextInteractionFlag_PythonToCpp_Katie_Qt_TextInteractionFlag; + return {}; +} +static PyObject* Katie_Qt_TextInteractionFlag_CppToPython_Katie_Qt_TextInteractionFlag(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_TEXTINTERACTIONFLAG_IDX], castCppIn); + +} + + +static void Katie_Qt_EventPriority_PythonToCpp_Katie_Qt_EventPriority(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::EventPriority*>(cppOut) = + static_cast<::Katie::Qt::EventPriority>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_EventPriority_PythonToCpp_Katie_Qt_EventPriority_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_EVENTPRIORITY_IDX])) + return Katie_Qt_EventPriority_PythonToCpp_Katie_Qt_EventPriority; + return {}; +} +static PyObject* Katie_Qt_EventPriority_CppToPython_Katie_Qt_EventPriority(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_EVENTPRIORITY_IDX], castCppIn); + +} + + +static void Katie_Qt_SizeHint_PythonToCpp_Katie_Qt_SizeHint(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::SizeHint*>(cppOut) = + static_cast<::Katie::Qt::SizeHint>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_SizeHint_PythonToCpp_Katie_Qt_SizeHint_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_SIZEHINT_IDX])) + return Katie_Qt_SizeHint_PythonToCpp_Katie_Qt_SizeHint; + return {}; +} +static PyObject* Katie_Qt_SizeHint_CppToPython_Katie_Qt_SizeHint(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_SIZEHINT_IDX], castCppIn); + +} + + +static void Katie_Qt_WindowFrameSection_PythonToCpp_Katie_Qt_WindowFrameSection(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::WindowFrameSection*>(cppOut) = + static_cast<::Katie::Qt::WindowFrameSection>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_WindowFrameSection_PythonToCpp_Katie_Qt_WindowFrameSection_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_WINDOWFRAMESECTION_IDX])) + return Katie_Qt_WindowFrameSection_PythonToCpp_Katie_Qt_WindowFrameSection; + return {}; +} +static PyObject* Katie_Qt_WindowFrameSection_CppToPython_Katie_Qt_WindowFrameSection(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWFRAMESECTION_IDX], castCppIn); + +} + + +static void Katie_Qt_Initialization_PythonToCpp_Katie_Qt_Initialization(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::Initialization*>(cppOut) = + static_cast<::Katie::Qt::Initialization>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_Initialization_PythonToCpp_Katie_Qt_Initialization_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_INITIALIZATION_IDX])) + return Katie_Qt_Initialization_PythonToCpp_Katie_Qt_Initialization; + return {}; +} +static PyObject* Katie_Qt_Initialization_CppToPython_Katie_Qt_Initialization(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_INITIALIZATION_IDX], castCppIn); + +} + + +static void Katie_Qt_CoordinateSystem_PythonToCpp_Katie_Qt_CoordinateSystem(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::CoordinateSystem*>(cppOut) = + static_cast<::Katie::Qt::CoordinateSystem>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_CoordinateSystem_PythonToCpp_Katie_Qt_CoordinateSystem_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_COORDINATESYSTEM_IDX])) + return Katie_Qt_CoordinateSystem_PythonToCpp_Katie_Qt_CoordinateSystem; + return {}; +} +static PyObject* Katie_Qt_CoordinateSystem_CppToPython_Katie_Qt_CoordinateSystem(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_COORDINATESYSTEM_IDX], castCppIn); + +} + + +static void Katie_Qt_TouchPointState_PythonToCpp_Katie_Qt_TouchPointState(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::TouchPointState*>(cppOut) = + static_cast<::Katie::Qt::TouchPointState>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_TouchPointState_PythonToCpp_Katie_Qt_TouchPointState_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_TOUCHPOINTSTATE_IDX])) + return Katie_Qt_TouchPointState_PythonToCpp_Katie_Qt_TouchPointState; + return {}; +} +static PyObject* Katie_Qt_TouchPointState_CppToPython_Katie_Qt_TouchPointState(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_TOUCHPOINTSTATE_IDX], castCppIn); + +} + + +static void Katie_Qt_GestureState_PythonToCpp_Katie_Qt_GestureState(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::GestureState*>(cppOut) = + static_cast<::Katie::Qt::GestureState>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_GestureState_PythonToCpp_Katie_Qt_GestureState_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_GESTURESTATE_IDX])) + return Katie_Qt_GestureState_PythonToCpp_Katie_Qt_GestureState; + return {}; +} +static PyObject* Katie_Qt_GestureState_CppToPython_Katie_Qt_GestureState(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_GESTURESTATE_IDX], castCppIn); + +} + + +static void Katie_Qt_GestureType_PythonToCpp_Katie_Qt_GestureType(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::GestureType*>(cppOut) = + static_cast<::Katie::Qt::GestureType>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_GestureType_PythonToCpp_Katie_Qt_GestureType_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_GESTURETYPE_IDX])) + return Katie_Qt_GestureType_PythonToCpp_Katie_Qt_GestureType; + return {}; +} +static PyObject* Katie_Qt_GestureType_CppToPython_Katie_Qt_GestureType(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_GESTURETYPE_IDX], castCppIn); + +} + + +static void Katie_Qt_GestureFlag_PythonToCpp_Katie_Qt_GestureFlag(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::GestureFlag*>(cppOut) = + static_cast<::Katie::Qt::GestureFlag>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_GestureFlag_PythonToCpp_Katie_Qt_GestureFlag_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_GESTUREFLAG_IDX])) + return Katie_Qt_GestureFlag_PythonToCpp_Katie_Qt_GestureFlag; + return {}; +} +static PyObject* Katie_Qt_GestureFlag_CppToPython_Katie_Qt_GestureFlag(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_GESTUREFLAG_IDX], castCppIn); + +} + + +static void Katie_Qt_NavigationMode_PythonToCpp_Katie_Qt_NavigationMode(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::NavigationMode*>(cppOut) = + static_cast<::Katie::Qt::NavigationMode>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_NavigationMode_PythonToCpp_Katie_Qt_NavigationMode_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_NAVIGATIONMODE_IDX])) + return Katie_Qt_NavigationMode_PythonToCpp_Katie_Qt_NavigationMode; + return {}; +} +static PyObject* Katie_Qt_NavigationMode_CppToPython_Katie_Qt_NavigationMode(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_NAVIGATIONMODE_IDX], castCppIn); + +} + + +static void Katie_Qt_CursorMoveStyle_PythonToCpp_Katie_Qt_CursorMoveStyle(PyObject* pyIn, void* cppOut) { + *reinterpret_cast<::Katie::Qt::CursorMoveStyle*>(cppOut) = + static_cast<::Katie::Qt::CursorMoveStyle>(Shiboken::Enum::getValue(pyIn)); + +} +static PythonToCppFunc is_Katie_Qt_CursorMoveStyle_PythonToCpp_Katie_Qt_CursorMoveStyle_Convertible(PyObject* pyIn) { + if (PyObject_TypeCheck(pyIn, SbkKtCoreTypes[SBK_KATIE_QT_CURSORMOVESTYLE_IDX])) + return Katie_Qt_CursorMoveStyle_PythonToCpp_Katie_Qt_CursorMoveStyle; + return {}; +} +static PyObject* Katie_Qt_CursorMoveStyle_CppToPython_Katie_Qt_CursorMoveStyle(const void* cppIn) { + const int castCppIn = int(*reinterpret_cast(cppIn)); + return Shiboken::Enum::newItem(SbkKtCoreTypes[SBK_KATIE_QT_CURSORMOVESTYLE_IDX], castCppIn); + +} + + + +// Module initialization ------------------------------------------------------------ +#if defined _WIN32 || defined __CYGWIN__ + #define SBK_EXPORT_MODULE __declspec(dllexport) +#elif __GNUC__ >= 4 + #define SBK_EXPORT_MODULE __attribute__ ((visibility("default"))) +#else + #define SBK_EXPORT_MODULE +#endif + +#ifdef IS_PY3K +static struct PyModuleDef moduledef = { + /* m_base */ PyModuleDef_HEAD_INIT, + /* m_name */ "KtCore", + /* m_doc */ nullptr, + /* m_size */ -1, + /* m_methods */ KtCore_methods, + /* m_reload */ nullptr, + /* m_traverse */ nullptr, + /* m_clear */ nullptr, + /* m_free */ nullptr +}; + +#endif + +// The signatures string for the global functions. +// Multiple signatures have their index "n:" in front. +static const char *KtCore_SignatureStrings[] = { + nullptr}; // Sentinel + +SBK_MODULE_INIT_FUNCTION_BEGIN(KtCore) + // Create an array of wrapper types for the current module. + static PyTypeObject* cppApi[SBK_KtCore_IDX_COUNT]; + SbkKtCoreTypes = cppApi; + + // Create an array of primitive type converters for the current module. + static SbkConverter* sbkConverters[SBK_KtCore_CONVERTERS_IDX_COUNT]; + SbkKtCoreTypeConverters = sbkConverters; + +#ifdef IS_PY3K + PyObject* module = Shiboken::Module::create("KtCore", &moduledef); +#else + PyObject* module = Shiboken::Module::create("KtCore", KtCore_methods); +#endif + + // Make module available from global scope + SbkKtCoreModuleObject = module; + + // Initialize classes in the type system + init_Katie_QObject(module); + init_Katie_QLatin1String(module); + init_Katie_QLatin1Char(module); + init_Katie_QCoreApplication(module); + init_Katie_QChar(module); + init_Katie_QString(module); + init_Katie_QByteArray(module); + // Initialization of enums. + + // Initialization of enum 'QtMsgType'. + SbkKtCoreTypes[SBK_KATIE_QTMSGTYPE_IDX] = Shiboken::Enum::createGlobalEnum(module, + "QtMsgType", + "KtCore.Katie.QtMsgType", + "Katie::QtMsgType"); + if (!SbkKtCoreTypes[SBK_KATIE_QTMSGTYPE_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QTMSGTYPE_IDX], + module, "QtDebugMsg", (long) Katie::QtMsgType::QtDebugMsg)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QTMSGTYPE_IDX], + module, "QtWarningMsg", (long) Katie::QtMsgType::QtWarningMsg)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QTMSGTYPE_IDX], + module, "QtCriticalMsg", (long) Katie::QtMsgType::QtCriticalMsg)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QTMSGTYPE_IDX], + module, "QtFatalMsg", (long) Katie::QtMsgType::QtFatalMsg)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QTMSGTYPE_IDX], + module, "QtSystemMsg", (long) Katie::QtMsgType::QtSystemMsg)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::QtMsgType'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QTMSGTYPE_IDX], + Katie_QtMsgType_CppToPython_Katie_QtMsgType); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_QtMsgType_PythonToCpp_Katie_QtMsgType, + is_Katie_QtMsgType_PythonToCpp_Katie_QtMsgType_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QTMSGTYPE_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::QtMsgType"); + Shiboken::Conversions::registerConverterName(converter, "QtMsgType"); + } + // End of 'QtMsgType' enum. + + // Initialization of enum 'GlobalColor'. + SbkKtCoreTypes[SBK_KATIE_QT_GLOBALCOLOR_IDX] = Shiboken::Enum::createGlobalEnum(module, + "GlobalColor", + "KtCore.Katie.Qt.GlobalColor", + "Katie::Qt::GlobalColor"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_GLOBALCOLOR_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_GLOBALCOLOR_IDX], + module, "color0", (long) Katie::Qt::GlobalColor::color0)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_GLOBALCOLOR_IDX], + module, "color1", (long) Katie::Qt::GlobalColor::color1)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_GLOBALCOLOR_IDX], + module, "black", (long) Katie::Qt::GlobalColor::black)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_GLOBALCOLOR_IDX], + module, "white", (long) Katie::Qt::GlobalColor::white)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_GLOBALCOLOR_IDX], + module, "darkGray", (long) Katie::Qt::GlobalColor::darkGray)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_GLOBALCOLOR_IDX], + module, "gray", (long) Katie::Qt::GlobalColor::gray)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_GLOBALCOLOR_IDX], + module, "lightGray", (long) Katie::Qt::GlobalColor::lightGray)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_GLOBALCOLOR_IDX], + module, "red", (long) Katie::Qt::GlobalColor::red)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_GLOBALCOLOR_IDX], + module, "green", (long) Katie::Qt::GlobalColor::green)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_GLOBALCOLOR_IDX], + module, "blue", (long) Katie::Qt::GlobalColor::blue)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_GLOBALCOLOR_IDX], + module, "cyan", (long) Katie::Qt::GlobalColor::cyan)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_GLOBALCOLOR_IDX], + module, "magenta", (long) Katie::Qt::GlobalColor::magenta)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_GLOBALCOLOR_IDX], + module, "yellow", (long) Katie::Qt::GlobalColor::yellow)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_GLOBALCOLOR_IDX], + module, "darkRed", (long) Katie::Qt::GlobalColor::darkRed)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_GLOBALCOLOR_IDX], + module, "darkGreen", (long) Katie::Qt::GlobalColor::darkGreen)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_GLOBALCOLOR_IDX], + module, "darkBlue", (long) Katie::Qt::GlobalColor::darkBlue)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_GLOBALCOLOR_IDX], + module, "darkCyan", (long) Katie::Qt::GlobalColor::darkCyan)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_GLOBALCOLOR_IDX], + module, "darkMagenta", (long) Katie::Qt::GlobalColor::darkMagenta)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_GLOBALCOLOR_IDX], + module, "darkYellow", (long) Katie::Qt::GlobalColor::darkYellow)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_GLOBALCOLOR_IDX], + module, "transparent", (long) Katie::Qt::GlobalColor::transparent)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::GlobalColor'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_GLOBALCOLOR_IDX], + Katie_Qt_GlobalColor_CppToPython_Katie_Qt_GlobalColor); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_GlobalColor_PythonToCpp_Katie_Qt_GlobalColor, + is_Katie_Qt_GlobalColor_PythonToCpp_Katie_Qt_GlobalColor_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_GLOBALCOLOR_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::GlobalColor"); + Shiboken::Conversions::registerConverterName(converter, "Qt::GlobalColor"); + Shiboken::Conversions::registerConverterName(converter, "GlobalColor"); + } + // End of 'GlobalColor' enum. + + // Initialization of enum 'KeyboardModifier'. + SbkKtCoreTypes[SBK_KATIE_QT_KEYBOARDMODIFIER_IDX] = Shiboken::Enum::createGlobalEnum(module, + "KeyboardModifier", + "KtCore.Katie.Qt.KeyboardModifier", + "Katie::Qt::KeyboardModifier"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_KEYBOARDMODIFIER_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEYBOARDMODIFIER_IDX], + module, "NoModifier", (long) Katie::Qt::KeyboardModifier::NoModifier)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEYBOARDMODIFIER_IDX], + module, "ShiftModifier", (long) Katie::Qt::KeyboardModifier::ShiftModifier)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEYBOARDMODIFIER_IDX], + module, "ControlModifier", (long) Katie::Qt::KeyboardModifier::ControlModifier)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEYBOARDMODIFIER_IDX], + module, "AltModifier", (long) Katie::Qt::KeyboardModifier::AltModifier)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEYBOARDMODIFIER_IDX], + module, "MetaModifier", (long) Katie::Qt::KeyboardModifier::MetaModifier)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEYBOARDMODIFIER_IDX], + module, "KeypadModifier", (long) Katie::Qt::KeyboardModifier::KeypadModifier)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEYBOARDMODIFIER_IDX], + module, "GroupSwitchModifier", (long) Katie::Qt::KeyboardModifier::GroupSwitchModifier)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEYBOARDMODIFIER_IDX], + module, "KeyboardModifierMask", (long) Katie::Qt::KeyboardModifier::KeyboardModifierMask)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::KeyboardModifier'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_KEYBOARDMODIFIER_IDX], + Katie_Qt_KeyboardModifier_CppToPython_Katie_Qt_KeyboardModifier); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_KeyboardModifier_PythonToCpp_Katie_Qt_KeyboardModifier, + is_Katie_Qt_KeyboardModifier_PythonToCpp_Katie_Qt_KeyboardModifier_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_KEYBOARDMODIFIER_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::KeyboardModifier"); + Shiboken::Conversions::registerConverterName(converter, "Qt::KeyboardModifier"); + Shiboken::Conversions::registerConverterName(converter, "KeyboardModifier"); + } + // End of 'KeyboardModifier' enum. + + // Initialization of enum 'Modifier'. + SbkKtCoreTypes[SBK_KATIE_QT_MODIFIER_IDX] = Shiboken::Enum::createGlobalEnum(module, + "Modifier", + "KtCore.Katie.Qt.Modifier", + "Katie::Qt::Modifier"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_MODIFIER_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_MODIFIER_IDX], + module, "META", (long) Katie::Qt::Modifier::META)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_MODIFIER_IDX], + module, "SHIFT", (long) Katie::Qt::Modifier::SHIFT)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_MODIFIER_IDX], + module, "CTRL", (long) Katie::Qt::Modifier::CTRL)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_MODIFIER_IDX], + module, "ALT", (long) Katie::Qt::Modifier::ALT)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_MODIFIER_IDX], + module, "MODIFIER_MASK", (long) Katie::Qt::Modifier::MODIFIER_MASK)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_MODIFIER_IDX], + module, "UNICODE_ACCEL", (long) Katie::Qt::Modifier::UNICODE_ACCEL)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::Modifier'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_MODIFIER_IDX], + Katie_Qt_Modifier_CppToPython_Katie_Qt_Modifier); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_Modifier_PythonToCpp_Katie_Qt_Modifier, + is_Katie_Qt_Modifier_PythonToCpp_Katie_Qt_Modifier_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_MODIFIER_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::Modifier"); + Shiboken::Conversions::registerConverterName(converter, "Qt::Modifier"); + Shiboken::Conversions::registerConverterName(converter, "Modifier"); + } + // End of 'Modifier' enum. + + // Initialization of enum 'MouseButton'. + SbkKtCoreTypes[SBK_KATIE_QT_MOUSEBUTTON_IDX] = Shiboken::Enum::createGlobalEnum(module, + "MouseButton", + "KtCore.Katie.Qt.MouseButton", + "Katie::Qt::MouseButton"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_MOUSEBUTTON_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_MOUSEBUTTON_IDX], + module, "NoButton", (long) Katie::Qt::MouseButton::NoButton)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_MOUSEBUTTON_IDX], + module, "LeftButton", (long) Katie::Qt::MouseButton::LeftButton)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_MOUSEBUTTON_IDX], + module, "RightButton", (long) Katie::Qt::MouseButton::RightButton)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_MOUSEBUTTON_IDX], + module, "MiddleButton", (long) Katie::Qt::MouseButton::MiddleButton)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_MOUSEBUTTON_IDX], + module, "XButton1", (long) Katie::Qt::MouseButton::XButton1)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_MOUSEBUTTON_IDX], + module, "XButton2", (long) Katie::Qt::MouseButton::XButton2)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_MOUSEBUTTON_IDX], + module, "MouseButtonMask", (long) Katie::Qt::MouseButton::MouseButtonMask)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::MouseButton'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_MOUSEBUTTON_IDX], + Katie_Qt_MouseButton_CppToPython_Katie_Qt_MouseButton); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_MouseButton_PythonToCpp_Katie_Qt_MouseButton, + is_Katie_Qt_MouseButton_PythonToCpp_Katie_Qt_MouseButton_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_MOUSEBUTTON_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::MouseButton"); + Shiboken::Conversions::registerConverterName(converter, "Qt::MouseButton"); + Shiboken::Conversions::registerConverterName(converter, "MouseButton"); + } + // End of 'MouseButton' enum. + + // Initialization of enum 'Orientation'. + SbkKtCoreTypes[SBK_KATIE_QT_ORIENTATION_IDX] = Shiboken::Enum::createGlobalEnum(module, + "Orientation", + "KtCore.Katie.Qt.Orientation", + "Katie::Qt::Orientation"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_ORIENTATION_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ORIENTATION_IDX], + module, "Horizontal", (long) Katie::Qt::Orientation::Horizontal)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ORIENTATION_IDX], + module, "Vertical", (long) Katie::Qt::Orientation::Vertical)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::Orientation'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_ORIENTATION_IDX], + Katie_Qt_Orientation_CppToPython_Katie_Qt_Orientation); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_Orientation_PythonToCpp_Katie_Qt_Orientation, + is_Katie_Qt_Orientation_PythonToCpp_Katie_Qt_Orientation_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_ORIENTATION_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::Orientation"); + Shiboken::Conversions::registerConverterName(converter, "Qt::Orientation"); + Shiboken::Conversions::registerConverterName(converter, "Orientation"); + } + // End of 'Orientation' enum. + + // Initialization of enum 'FocusPolicy'. + SbkKtCoreTypes[SBK_KATIE_QT_FOCUSPOLICY_IDX] = Shiboken::Enum::createGlobalEnum(module, + "FocusPolicy", + "KtCore.Katie.Qt.FocusPolicy", + "Katie::Qt::FocusPolicy"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_FOCUSPOLICY_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_FOCUSPOLICY_IDX], + module, "NoFocus", (long) Katie::Qt::FocusPolicy::NoFocus)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_FOCUSPOLICY_IDX], + module, "TabFocus", (long) Katie::Qt::FocusPolicy::TabFocus)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_FOCUSPOLICY_IDX], + module, "ClickFocus", (long) Katie::Qt::FocusPolicy::ClickFocus)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_FOCUSPOLICY_IDX], + module, "StrongFocus", (long) Katie::Qt::FocusPolicy::StrongFocus)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_FOCUSPOLICY_IDX], + module, "WheelFocus", (long) Katie::Qt::FocusPolicy::WheelFocus)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::FocusPolicy'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_FOCUSPOLICY_IDX], + Katie_Qt_FocusPolicy_CppToPython_Katie_Qt_FocusPolicy); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_FocusPolicy_PythonToCpp_Katie_Qt_FocusPolicy, + is_Katie_Qt_FocusPolicy_PythonToCpp_Katie_Qt_FocusPolicy_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_FOCUSPOLICY_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::FocusPolicy"); + Shiboken::Conversions::registerConverterName(converter, "Qt::FocusPolicy"); + Shiboken::Conversions::registerConverterName(converter, "FocusPolicy"); + } + // End of 'FocusPolicy' enum. + + // Initialization of enum 'SortOrder'. + SbkKtCoreTypes[SBK_KATIE_QT_SORTORDER_IDX] = Shiboken::Enum::createGlobalEnum(module, + "SortOrder", + "KtCore.Katie.Qt.SortOrder", + "Katie::Qt::SortOrder"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_SORTORDER_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_SORTORDER_IDX], + module, "AscendingOrder", (long) Katie::Qt::SortOrder::AscendingOrder)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_SORTORDER_IDX], + module, "DescendingOrder", (long) Katie::Qt::SortOrder::DescendingOrder)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::SortOrder'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_SORTORDER_IDX], + Katie_Qt_SortOrder_CppToPython_Katie_Qt_SortOrder); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_SortOrder_PythonToCpp_Katie_Qt_SortOrder, + is_Katie_Qt_SortOrder_PythonToCpp_Katie_Qt_SortOrder_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_SORTORDER_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::SortOrder"); + Shiboken::Conversions::registerConverterName(converter, "Qt::SortOrder"); + Shiboken::Conversions::registerConverterName(converter, "SortOrder"); + } + // End of 'SortOrder' enum. + + // Initialization of enum 'TileRule'. + SbkKtCoreTypes[SBK_KATIE_QT_TILERULE_IDX] = Shiboken::Enum::createGlobalEnum(module, + "TileRule", + "KtCore.Katie.Qt.TileRule", + "Katie::Qt::TileRule"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_TILERULE_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TILERULE_IDX], + module, "StretchTile", (long) Katie::Qt::TileRule::StretchTile)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TILERULE_IDX], + module, "RepeatTile", (long) Katie::Qt::TileRule::RepeatTile)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TILERULE_IDX], + module, "RoundTile", (long) Katie::Qt::TileRule::RoundTile)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::TileRule'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_TILERULE_IDX], + Katie_Qt_TileRule_CppToPython_Katie_Qt_TileRule); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_TileRule_PythonToCpp_Katie_Qt_TileRule, + is_Katie_Qt_TileRule_PythonToCpp_Katie_Qt_TileRule_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_TILERULE_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::TileRule"); + Shiboken::Conversions::registerConverterName(converter, "Qt::TileRule"); + Shiboken::Conversions::registerConverterName(converter, "TileRule"); + } + // End of 'TileRule' enum. + + // Initialization of enum 'AlignmentFlag'. + SbkKtCoreTypes[SBK_KATIE_QT_ALIGNMENTFLAG_IDX] = Shiboken::Enum::createGlobalEnum(module, + "AlignmentFlag", + "KtCore.Katie.Qt.AlignmentFlag", + "Katie::Qt::AlignmentFlag"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_ALIGNMENTFLAG_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ALIGNMENTFLAG_IDX], + module, "AlignLeft", (long) Katie::Qt::AlignmentFlag::AlignLeft)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ALIGNMENTFLAG_IDX], + module, "AlignLeading", (long) Katie::Qt::AlignmentFlag::AlignLeading)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ALIGNMENTFLAG_IDX], + module, "AlignRight", (long) Katie::Qt::AlignmentFlag::AlignRight)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ALIGNMENTFLAG_IDX], + module, "AlignTrailing", (long) Katie::Qt::AlignmentFlag::AlignTrailing)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ALIGNMENTFLAG_IDX], + module, "AlignHCenter", (long) Katie::Qt::AlignmentFlag::AlignHCenter)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ALIGNMENTFLAG_IDX], + module, "AlignJustify", (long) Katie::Qt::AlignmentFlag::AlignJustify)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ALIGNMENTFLAG_IDX], + module, "AlignAbsolute", (long) Katie::Qt::AlignmentFlag::AlignAbsolute)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ALIGNMENTFLAG_IDX], + module, "AlignHorizontal_Mask", (long) Katie::Qt::AlignmentFlag::AlignHorizontal_Mask)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ALIGNMENTFLAG_IDX], + module, "AlignTop", (long) Katie::Qt::AlignmentFlag::AlignTop)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ALIGNMENTFLAG_IDX], + module, "AlignBottom", (long) Katie::Qt::AlignmentFlag::AlignBottom)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ALIGNMENTFLAG_IDX], + module, "AlignVCenter", (long) Katie::Qt::AlignmentFlag::AlignVCenter)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ALIGNMENTFLAG_IDX], + module, "AlignVertical_Mask", (long) Katie::Qt::AlignmentFlag::AlignVertical_Mask)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ALIGNMENTFLAG_IDX], + module, "AlignCenter", (long) Katie::Qt::AlignmentFlag::AlignCenter)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::AlignmentFlag'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_ALIGNMENTFLAG_IDX], + Katie_Qt_AlignmentFlag_CppToPython_Katie_Qt_AlignmentFlag); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_AlignmentFlag_PythonToCpp_Katie_Qt_AlignmentFlag, + is_Katie_Qt_AlignmentFlag_PythonToCpp_Katie_Qt_AlignmentFlag_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_ALIGNMENTFLAG_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::AlignmentFlag"); + Shiboken::Conversions::registerConverterName(converter, "Qt::AlignmentFlag"); + Shiboken::Conversions::registerConverterName(converter, "AlignmentFlag"); + } + // End of 'AlignmentFlag' enum. + + // Initialization of enum 'TextFlag'. + SbkKtCoreTypes[SBK_KATIE_QT_TEXTFLAG_IDX] = Shiboken::Enum::createGlobalEnum(module, + "TextFlag", + "KtCore.Katie.Qt.TextFlag", + "Katie::Qt::TextFlag"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_TEXTFLAG_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TEXTFLAG_IDX], + module, "TextSingleLine", (long) Katie::Qt::TextFlag::TextSingleLine)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TEXTFLAG_IDX], + module, "TextDontClip", (long) Katie::Qt::TextFlag::TextDontClip)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TEXTFLAG_IDX], + module, "TextExpandTabs", (long) Katie::Qt::TextFlag::TextExpandTabs)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TEXTFLAG_IDX], + module, "TextShowMnemonic", (long) Katie::Qt::TextFlag::TextShowMnemonic)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TEXTFLAG_IDX], + module, "TextWordWrap", (long) Katie::Qt::TextFlag::TextWordWrap)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TEXTFLAG_IDX], + module, "TextWrapAnywhere", (long) Katie::Qt::TextFlag::TextWrapAnywhere)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TEXTFLAG_IDX], + module, "TextDontPrint", (long) Katie::Qt::TextFlag::TextDontPrint)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TEXTFLAG_IDX], + module, "TextIncludeTrailingSpaces", (long) Katie::Qt::TextFlag::TextIncludeTrailingSpaces)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TEXTFLAG_IDX], + module, "TextHideMnemonic", (long) Katie::Qt::TextFlag::TextHideMnemonic)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TEXTFLAG_IDX], + module, "TextJustificationForced", (long) Katie::Qt::TextFlag::TextJustificationForced)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TEXTFLAG_IDX], + module, "TextForceLeftToRight", (long) Katie::Qt::TextFlag::TextForceLeftToRight)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TEXTFLAG_IDX], + module, "TextForceRightToLeft", (long) Katie::Qt::TextFlag::TextForceRightToLeft)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TEXTFLAG_IDX], + module, "TextLongestVariant", (long) Katie::Qt::TextFlag::TextLongestVariant)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TEXTFLAG_IDX], + module, "TextBypassShaping", (long) Katie::Qt::TextFlag::TextBypassShaping)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::TextFlag'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_TEXTFLAG_IDX], + Katie_Qt_TextFlag_CppToPython_Katie_Qt_TextFlag); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_TextFlag_PythonToCpp_Katie_Qt_TextFlag, + is_Katie_Qt_TextFlag_PythonToCpp_Katie_Qt_TextFlag_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_TEXTFLAG_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::TextFlag"); + Shiboken::Conversions::registerConverterName(converter, "Qt::TextFlag"); + Shiboken::Conversions::registerConverterName(converter, "TextFlag"); + } + // End of 'TextFlag' enum. + + // Initialization of enum 'TextElideMode'. + SbkKtCoreTypes[SBK_KATIE_QT_TEXTELIDEMODE_IDX] = Shiboken::Enum::createGlobalEnum(module, + "TextElideMode", + "KtCore.Katie.Qt.TextElideMode", + "Katie::Qt::TextElideMode"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_TEXTELIDEMODE_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TEXTELIDEMODE_IDX], + module, "ElideLeft", (long) Katie::Qt::TextElideMode::ElideLeft)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TEXTELIDEMODE_IDX], + module, "ElideRight", (long) Katie::Qt::TextElideMode::ElideRight)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TEXTELIDEMODE_IDX], + module, "ElideMiddle", (long) Katie::Qt::TextElideMode::ElideMiddle)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TEXTELIDEMODE_IDX], + module, "ElideNone", (long) Katie::Qt::TextElideMode::ElideNone)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::TextElideMode'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_TEXTELIDEMODE_IDX], + Katie_Qt_TextElideMode_CppToPython_Katie_Qt_TextElideMode); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_TextElideMode_PythonToCpp_Katie_Qt_TextElideMode, + is_Katie_Qt_TextElideMode_PythonToCpp_Katie_Qt_TextElideMode_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_TEXTELIDEMODE_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::TextElideMode"); + Shiboken::Conversions::registerConverterName(converter, "Qt::TextElideMode"); + Shiboken::Conversions::registerConverterName(converter, "TextElideMode"); + } + // End of 'TextElideMode' enum. + + // Initialization of enum 'WindowType'. + SbkKtCoreTypes[SBK_KATIE_QT_WINDOWTYPE_IDX] = Shiboken::Enum::createGlobalEnum(module, + "WindowType", + "KtCore.Katie.Qt.WindowType", + "Katie::Qt::WindowType"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_WINDOWTYPE_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWTYPE_IDX], + module, "Widget", (long) Katie::Qt::WindowType::Widget)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWTYPE_IDX], + module, "Window", (long) Katie::Qt::WindowType::Window)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWTYPE_IDX], + module, "Dialog", (long) Katie::Qt::WindowType::Dialog)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWTYPE_IDX], + module, "Sheet", (long) Katie::Qt::WindowType::Sheet)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWTYPE_IDX], + module, "Drawer", (long) Katie::Qt::WindowType::Drawer)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWTYPE_IDX], + module, "Popup", (long) Katie::Qt::WindowType::Popup)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWTYPE_IDX], + module, "Tool", (long) Katie::Qt::WindowType::Tool)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWTYPE_IDX], + module, "ToolTip", (long) Katie::Qt::WindowType::ToolTip)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWTYPE_IDX], + module, "SplashScreen", (long) Katie::Qt::WindowType::SplashScreen)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWTYPE_IDX], + module, "Desktop", (long) Katie::Qt::WindowType::Desktop)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWTYPE_IDX], + module, "SubWindow", (long) Katie::Qt::WindowType::SubWindow)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWTYPE_IDX], + module, "WindowType_Mask", (long) Katie::Qt::WindowType::WindowType_Mask)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWTYPE_IDX], + module, "X11BypassWindowManagerHint", (long) Katie::Qt::WindowType::X11BypassWindowManagerHint)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWTYPE_IDX], + module, "FramelessWindowHint", (long) Katie::Qt::WindowType::FramelessWindowHint)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWTYPE_IDX], + module, "WindowTitleHint", (long) Katie::Qt::WindowType::WindowTitleHint)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWTYPE_IDX], + module, "WindowSystemMenuHint", (long) Katie::Qt::WindowType::WindowSystemMenuHint)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWTYPE_IDX], + module, "WindowMinimizeButtonHint", (long) Katie::Qt::WindowType::WindowMinimizeButtonHint)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWTYPE_IDX], + module, "WindowMaximizeButtonHint", (long) Katie::Qt::WindowType::WindowMaximizeButtonHint)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWTYPE_IDX], + module, "WindowMinMaxButtonsHint", (long) Katie::Qt::WindowType::WindowMinMaxButtonsHint)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWTYPE_IDX], + module, "WindowContextHelpButtonHint", (long) Katie::Qt::WindowType::WindowContextHelpButtonHint)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWTYPE_IDX], + module, "WindowShadeButtonHint", (long) Katie::Qt::WindowType::WindowShadeButtonHint)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWTYPE_IDX], + module, "WindowStaysOnTopHint", (long) Katie::Qt::WindowType::WindowStaysOnTopHint)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWTYPE_IDX], + module, "CustomizeWindowHint", (long) Katie::Qt::WindowType::CustomizeWindowHint)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWTYPE_IDX], + module, "WindowStaysOnBottomHint", (long) Katie::Qt::WindowType::WindowStaysOnBottomHint)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWTYPE_IDX], + module, "WindowCloseButtonHint", (long) Katie::Qt::WindowType::WindowCloseButtonHint)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWTYPE_IDX], + module, "BypassGraphicsProxyWidget", (long) Katie::Qt::WindowType::BypassGraphicsProxyWidget)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::WindowType'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWTYPE_IDX], + Katie_Qt_WindowType_CppToPython_Katie_Qt_WindowType); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_WindowType_PythonToCpp_Katie_Qt_WindowType, + is_Katie_Qt_WindowType_PythonToCpp_Katie_Qt_WindowType_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWTYPE_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::WindowType"); + Shiboken::Conversions::registerConverterName(converter, "Qt::WindowType"); + Shiboken::Conversions::registerConverterName(converter, "WindowType"); + } + // End of 'WindowType' enum. + + // Initialization of enum 'WindowState'. + SbkKtCoreTypes[SBK_KATIE_QT_WINDOWSTATE_IDX] = Shiboken::Enum::createGlobalEnum(module, + "WindowState", + "KtCore.Katie.Qt.WindowState", + "Katie::Qt::WindowState"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_WINDOWSTATE_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWSTATE_IDX], + module, "WindowNoState", (long) Katie::Qt::WindowState::WindowNoState)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWSTATE_IDX], + module, "WindowMinimized", (long) Katie::Qt::WindowState::WindowMinimized)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWSTATE_IDX], + module, "WindowMaximized", (long) Katie::Qt::WindowState::WindowMaximized)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWSTATE_IDX], + module, "WindowFullScreen", (long) Katie::Qt::WindowState::WindowFullScreen)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWSTATE_IDX], + module, "WindowActive", (long) Katie::Qt::WindowState::WindowActive)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::WindowState'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWSTATE_IDX], + Katie_Qt_WindowState_CppToPython_Katie_Qt_WindowState); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_WindowState_PythonToCpp_Katie_Qt_WindowState, + is_Katie_Qt_WindowState_PythonToCpp_Katie_Qt_WindowState_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWSTATE_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::WindowState"); + Shiboken::Conversions::registerConverterName(converter, "Qt::WindowState"); + Shiboken::Conversions::registerConverterName(converter, "WindowState"); + } + // End of 'WindowState' enum. + + // Initialization of enum 'WidgetAttribute'. + SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX] = Shiboken::Enum::createGlobalEnum(module, + "WidgetAttribute", + "KtCore.Katie.Qt.WidgetAttribute", + "Katie::Qt::WidgetAttribute"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_Disabled", (long) Katie::Qt::WidgetAttribute::WA_Disabled)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_UnderMouse", (long) Katie::Qt::WidgetAttribute::WA_UnderMouse)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_MouseTracking", (long) Katie::Qt::WidgetAttribute::WA_MouseTracking)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_ContentsPropagated", (long) Katie::Qt::WidgetAttribute::WA_ContentsPropagated)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_OpaquePaintEvent", (long) Katie::Qt::WidgetAttribute::WA_OpaquePaintEvent)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_NoBackground", (long) Katie::Qt::WidgetAttribute::WA_NoBackground)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_StaticContents", (long) Katie::Qt::WidgetAttribute::WA_StaticContents)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_LaidOut", (long) Katie::Qt::WidgetAttribute::WA_LaidOut)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_PaintOnScreen", (long) Katie::Qt::WidgetAttribute::WA_PaintOnScreen)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_NoSystemBackground", (long) Katie::Qt::WidgetAttribute::WA_NoSystemBackground)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_UpdatesDisabled", (long) Katie::Qt::WidgetAttribute::WA_UpdatesDisabled)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_Mapped", (long) Katie::Qt::WidgetAttribute::WA_Mapped)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_PaintOutsidePaintEvent", (long) Katie::Qt::WidgetAttribute::WA_PaintOutsidePaintEvent)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_WState_Visible", (long) Katie::Qt::WidgetAttribute::WA_WState_Visible)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_WState_Hidden", (long) Katie::Qt::WidgetAttribute::WA_WState_Hidden)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_ForceDisabled", (long) Katie::Qt::WidgetAttribute::WA_ForceDisabled)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_PendingMoveEvent", (long) Katie::Qt::WidgetAttribute::WA_PendingMoveEvent)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_PendingResizeEvent", (long) Katie::Qt::WidgetAttribute::WA_PendingResizeEvent)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_SetPalette", (long) Katie::Qt::WidgetAttribute::WA_SetPalette)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_SetFont", (long) Katie::Qt::WidgetAttribute::WA_SetFont)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_SetCursor", (long) Katie::Qt::WidgetAttribute::WA_SetCursor)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_NoChildEventsFromChildren", (long) Katie::Qt::WidgetAttribute::WA_NoChildEventsFromChildren)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_WindowModified", (long) Katie::Qt::WidgetAttribute::WA_WindowModified)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_Resized", (long) Katie::Qt::WidgetAttribute::WA_Resized)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_Moved", (long) Katie::Qt::WidgetAttribute::WA_Moved)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_PendingUpdate", (long) Katie::Qt::WidgetAttribute::WA_PendingUpdate)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_InvalidSize", (long) Katie::Qt::WidgetAttribute::WA_InvalidSize)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_CustomWhatsThis", (long) Katie::Qt::WidgetAttribute::WA_CustomWhatsThis)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_LayoutOnEntireRect", (long) Katie::Qt::WidgetAttribute::WA_LayoutOnEntireRect)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_OutsideWSRange", (long) Katie::Qt::WidgetAttribute::WA_OutsideWSRange)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_GrabbedShortcut", (long) Katie::Qt::WidgetAttribute::WA_GrabbedShortcut)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_TransparentForMouseEvents", (long) Katie::Qt::WidgetAttribute::WA_TransparentForMouseEvents)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_PaintUnclipped", (long) Katie::Qt::WidgetAttribute::WA_PaintUnclipped)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_SetWindowIcon", (long) Katie::Qt::WidgetAttribute::WA_SetWindowIcon)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_NoMouseReplay", (long) Katie::Qt::WidgetAttribute::WA_NoMouseReplay)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_DeleteOnClose", (long) Katie::Qt::WidgetAttribute::WA_DeleteOnClose)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_RightToLeft", (long) Katie::Qt::WidgetAttribute::WA_RightToLeft)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_SetLayoutDirection", (long) Katie::Qt::WidgetAttribute::WA_SetLayoutDirection)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_NoChildEventsForParent", (long) Katie::Qt::WidgetAttribute::WA_NoChildEventsForParent)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_ForceUpdatesDisabled", (long) Katie::Qt::WidgetAttribute::WA_ForceUpdatesDisabled)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_WState_Created", (long) Katie::Qt::WidgetAttribute::WA_WState_Created)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_WState_CompressKeys", (long) Katie::Qt::WidgetAttribute::WA_WState_CompressKeys)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_WState_InPaintEvent", (long) Katie::Qt::WidgetAttribute::WA_WState_InPaintEvent)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_WState_Reparented", (long) Katie::Qt::WidgetAttribute::WA_WState_Reparented)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_WState_ConfigPending", (long) Katie::Qt::WidgetAttribute::WA_WState_ConfigPending)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_WState_Polished", (long) Katie::Qt::WidgetAttribute::WA_WState_Polished)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_WState_DND", (long) Katie::Qt::WidgetAttribute::WA_WState_DND)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_WState_OwnSizePolicy", (long) Katie::Qt::WidgetAttribute::WA_WState_OwnSizePolicy)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_WState_ExplicitShowHide", (long) Katie::Qt::WidgetAttribute::WA_WState_ExplicitShowHide)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_ShowModal", (long) Katie::Qt::WidgetAttribute::WA_ShowModal)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_MouseNoMask", (long) Katie::Qt::WidgetAttribute::WA_MouseNoMask)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_GroupLeader", (long) Katie::Qt::WidgetAttribute::WA_GroupLeader)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_NoMousePropagation", (long) Katie::Qt::WidgetAttribute::WA_NoMousePropagation)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_Hover", (long) Katie::Qt::WidgetAttribute::WA_Hover)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_QuitOnClose", (long) Katie::Qt::WidgetAttribute::WA_QuitOnClose)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_KeyboardFocusChange", (long) Katie::Qt::WidgetAttribute::WA_KeyboardFocusChange)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_AcceptDrops", (long) Katie::Qt::WidgetAttribute::WA_AcceptDrops)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_DropSiteRegistered", (long) Katie::Qt::WidgetAttribute::WA_DropSiteRegistered)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_WindowPropagation", (long) Katie::Qt::WidgetAttribute::WA_WindowPropagation)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_TintedBackground", (long) Katie::Qt::WidgetAttribute::WA_TintedBackground)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_AlwaysShowToolTips", (long) Katie::Qt::WidgetAttribute::WA_AlwaysShowToolTips)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_SetStyle", (long) Katie::Qt::WidgetAttribute::WA_SetStyle)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_SetLocale", (long) Katie::Qt::WidgetAttribute::WA_SetLocale)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_LayoutUsesWidgetRect", (long) Katie::Qt::WidgetAttribute::WA_LayoutUsesWidgetRect)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_StyledBackground", (long) Katie::Qt::WidgetAttribute::WA_StyledBackground)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_CanHostQMdiSubWindowTitleBar", (long) Katie::Qt::WidgetAttribute::WA_CanHostQMdiSubWindowTitleBar)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_StyleSheet", (long) Katie::Qt::WidgetAttribute::WA_StyleSheet)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_ShowWithoutActivating", (long) Katie::Qt::WidgetAttribute::WA_ShowWithoutActivating)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_X11BypassTransientForHint", (long) Katie::Qt::WidgetAttribute::WA_X11BypassTransientForHint)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_NativeWindow", (long) Katie::Qt::WidgetAttribute::WA_NativeWindow)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_DontCreateNativeAncestors", (long) Katie::Qt::WidgetAttribute::WA_DontCreateNativeAncestors)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_DontShowOnScreen", (long) Katie::Qt::WidgetAttribute::WA_DontShowOnScreen)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_X11NetWmWindowTypeDesktop", (long) Katie::Qt::WidgetAttribute::WA_X11NetWmWindowTypeDesktop)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_X11NetWmWindowTypeDock", (long) Katie::Qt::WidgetAttribute::WA_X11NetWmWindowTypeDock)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_X11NetWmWindowTypeToolBar", (long) Katie::Qt::WidgetAttribute::WA_X11NetWmWindowTypeToolBar)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_X11NetWmWindowTypeMenu", (long) Katie::Qt::WidgetAttribute::WA_X11NetWmWindowTypeMenu)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_X11NetWmWindowTypeUtility", (long) Katie::Qt::WidgetAttribute::WA_X11NetWmWindowTypeUtility)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_X11NetWmWindowTypeSplash", (long) Katie::Qt::WidgetAttribute::WA_X11NetWmWindowTypeSplash)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_X11NetWmWindowTypeDialog", (long) Katie::Qt::WidgetAttribute::WA_X11NetWmWindowTypeDialog)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_X11NetWmWindowTypeDropDownMenu", (long) Katie::Qt::WidgetAttribute::WA_X11NetWmWindowTypeDropDownMenu)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_X11NetWmWindowTypePopupMenu", (long) Katie::Qt::WidgetAttribute::WA_X11NetWmWindowTypePopupMenu)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_X11NetWmWindowTypeToolTip", (long) Katie::Qt::WidgetAttribute::WA_X11NetWmWindowTypeToolTip)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_X11NetWmWindowTypeNotification", (long) Katie::Qt::WidgetAttribute::WA_X11NetWmWindowTypeNotification)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_X11NetWmWindowTypeCombo", (long) Katie::Qt::WidgetAttribute::WA_X11NetWmWindowTypeCombo)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_X11NetWmWindowTypeDND", (long) Katie::Qt::WidgetAttribute::WA_X11NetWmWindowTypeDND)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_SetWindowModality", (long) Katie::Qt::WidgetAttribute::WA_SetWindowModality)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_WState_WindowOpacitySet", (long) Katie::Qt::WidgetAttribute::WA_WState_WindowOpacitySet)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_TranslucentBackground", (long) Katie::Qt::WidgetAttribute::WA_TranslucentBackground)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_AcceptTouchEvents", (long) Katie::Qt::WidgetAttribute::WA_AcceptTouchEvents)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_WState_AcceptedTouchBeginEvent", (long) Katie::Qt::WidgetAttribute::WA_WState_AcceptedTouchBeginEvent)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_TouchPadAcceptSingleTouchEvents", (long) Katie::Qt::WidgetAttribute::WA_TouchPadAcceptSingleTouchEvents)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_LockPortraitOrientation", (long) Katie::Qt::WidgetAttribute::WA_LockPortraitOrientation)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_LockLandscapeOrientation", (long) Katie::Qt::WidgetAttribute::WA_LockLandscapeOrientation)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_AutoOrientation", (long) Katie::Qt::WidgetAttribute::WA_AutoOrientation)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_X11DoNotAcceptFocus", (long) Katie::Qt::WidgetAttribute::WA_X11DoNotAcceptFocus)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + module, "WA_AttributeCount", (long) Katie::Qt::WidgetAttribute::WA_AttributeCount)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::WidgetAttribute'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], + Katie_Qt_WidgetAttribute_CppToPython_Katie_Qt_WidgetAttribute); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_WidgetAttribute_PythonToCpp_Katie_Qt_WidgetAttribute, + is_Katie_Qt_WidgetAttribute_PythonToCpp_Katie_Qt_WidgetAttribute_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::WidgetAttribute"); + Shiboken::Conversions::registerConverterName(converter, "Qt::WidgetAttribute"); + Shiboken::Conversions::registerConverterName(converter, "WidgetAttribute"); + } + // End of 'WidgetAttribute' enum. + + // Initialization of enum 'ApplicationAttribute'. + SbkKtCoreTypes[SBK_KATIE_QT_APPLICATIONATTRIBUTE_IDX] = Shiboken::Enum::createGlobalEnum(module, + "ApplicationAttribute", + "KtCore.Katie.Qt.ApplicationAttribute", + "Katie::Qt::ApplicationAttribute"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_APPLICATIONATTRIBUTE_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_APPLICATIONATTRIBUTE_IDX], + module, "AA_ImmediateWidgetCreation", (long) Katie::Qt::ApplicationAttribute::AA_ImmediateWidgetCreation)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_APPLICATIONATTRIBUTE_IDX], + module, "AA_DontShowIconsInMenus", (long) Katie::Qt::ApplicationAttribute::AA_DontShowIconsInMenus)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_APPLICATIONATTRIBUTE_IDX], + module, "AA_NativeWindows", (long) Katie::Qt::ApplicationAttribute::AA_NativeWindows)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_APPLICATIONATTRIBUTE_IDX], + module, "AA_DontCreateNativeWidgetSiblings", (long) Katie::Qt::ApplicationAttribute::AA_DontCreateNativeWidgetSiblings)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_APPLICATIONATTRIBUTE_IDX], + module, "AA_X11InitThreads", (long) Katie::Qt::ApplicationAttribute::AA_X11InitThreads)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_APPLICATIONATTRIBUTE_IDX], + module, "AA_CaptureMultimediaKeys", (long) Katie::Qt::ApplicationAttribute::AA_CaptureMultimediaKeys)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_APPLICATIONATTRIBUTE_IDX], + module, "AA_AttributeCount", (long) Katie::Qt::ApplicationAttribute::AA_AttributeCount)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::ApplicationAttribute'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_APPLICATIONATTRIBUTE_IDX], + Katie_Qt_ApplicationAttribute_CppToPython_Katie_Qt_ApplicationAttribute); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_ApplicationAttribute_PythonToCpp_Katie_Qt_ApplicationAttribute, + is_Katie_Qt_ApplicationAttribute_PythonToCpp_Katie_Qt_ApplicationAttribute_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_APPLICATIONATTRIBUTE_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::ApplicationAttribute"); + Shiboken::Conversions::registerConverterName(converter, "Qt::ApplicationAttribute"); + Shiboken::Conversions::registerConverterName(converter, "ApplicationAttribute"); + } + // End of 'ApplicationAttribute' enum. + + // Initialization of enum 'ImageConversionFlag'. + SbkKtCoreTypes[SBK_KATIE_QT_IMAGECONVERSIONFLAG_IDX] = Shiboken::Enum::createGlobalEnum(module, + "ImageConversionFlag", + "KtCore.Katie.Qt.ImageConversionFlag", + "Katie::Qt::ImageConversionFlag"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_IMAGECONVERSIONFLAG_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_IMAGECONVERSIONFLAG_IDX], + module, "ColorMode_Mask", (long) Katie::Qt::ImageConversionFlag::ColorMode_Mask)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_IMAGECONVERSIONFLAG_IDX], + module, "AutoColor", (long) Katie::Qt::ImageConversionFlag::AutoColor)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_IMAGECONVERSIONFLAG_IDX], + module, "ColorOnly", (long) Katie::Qt::ImageConversionFlag::ColorOnly)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_IMAGECONVERSIONFLAG_IDX], + module, "MonoOnly", (long) Katie::Qt::ImageConversionFlag::MonoOnly)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_IMAGECONVERSIONFLAG_IDX], + module, "AlphaDither_Mask", (long) Katie::Qt::ImageConversionFlag::AlphaDither_Mask)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_IMAGECONVERSIONFLAG_IDX], + module, "ThresholdAlphaDither", (long) Katie::Qt::ImageConversionFlag::ThresholdAlphaDither)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_IMAGECONVERSIONFLAG_IDX], + module, "OrderedAlphaDither", (long) Katie::Qt::ImageConversionFlag::OrderedAlphaDither)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_IMAGECONVERSIONFLAG_IDX], + module, "DiffuseAlphaDither", (long) Katie::Qt::ImageConversionFlag::DiffuseAlphaDither)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_IMAGECONVERSIONFLAG_IDX], + module, "NoAlpha", (long) Katie::Qt::ImageConversionFlag::NoAlpha)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_IMAGECONVERSIONFLAG_IDX], + module, "Dither_Mask", (long) Katie::Qt::ImageConversionFlag::Dither_Mask)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_IMAGECONVERSIONFLAG_IDX], + module, "DiffuseDither", (long) Katie::Qt::ImageConversionFlag::DiffuseDither)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_IMAGECONVERSIONFLAG_IDX], + module, "OrderedDither", (long) Katie::Qt::ImageConversionFlag::OrderedDither)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_IMAGECONVERSIONFLAG_IDX], + module, "ThresholdDither", (long) Katie::Qt::ImageConversionFlag::ThresholdDither)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_IMAGECONVERSIONFLAG_IDX], + module, "DitherMode_Mask", (long) Katie::Qt::ImageConversionFlag::DitherMode_Mask)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_IMAGECONVERSIONFLAG_IDX], + module, "AutoDither", (long) Katie::Qt::ImageConversionFlag::AutoDither)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_IMAGECONVERSIONFLAG_IDX], + module, "PreferDither", (long) Katie::Qt::ImageConversionFlag::PreferDither)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_IMAGECONVERSIONFLAG_IDX], + module, "AvoidDither", (long) Katie::Qt::ImageConversionFlag::AvoidDither)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_IMAGECONVERSIONFLAG_IDX], + module, "NoOpaqueDetection", (long) Katie::Qt::ImageConversionFlag::NoOpaqueDetection)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_IMAGECONVERSIONFLAG_IDX], + module, "NoFormatConversion", (long) Katie::Qt::ImageConversionFlag::NoFormatConversion)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::ImageConversionFlag'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_IMAGECONVERSIONFLAG_IDX], + Katie_Qt_ImageConversionFlag_CppToPython_Katie_Qt_ImageConversionFlag); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_ImageConversionFlag_PythonToCpp_Katie_Qt_ImageConversionFlag, + is_Katie_Qt_ImageConversionFlag_PythonToCpp_Katie_Qt_ImageConversionFlag_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_IMAGECONVERSIONFLAG_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::ImageConversionFlag"); + Shiboken::Conversions::registerConverterName(converter, "Qt::ImageConversionFlag"); + Shiboken::Conversions::registerConverterName(converter, "ImageConversionFlag"); + } + // End of 'ImageConversionFlag' enum. + + // Initialization of enum 'BGMode'. + SbkKtCoreTypes[SBK_KATIE_QT_BGMODE_IDX] = Shiboken::Enum::createGlobalEnum(module, + "BGMode", + "KtCore.Katie.Qt.BGMode", + "Katie::Qt::BGMode"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_BGMODE_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_BGMODE_IDX], + module, "TransparentMode", (long) Katie::Qt::BGMode::TransparentMode)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_BGMODE_IDX], + module, "OpaqueMode", (long) Katie::Qt::BGMode::OpaqueMode)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::BGMode'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_BGMODE_IDX], + Katie_Qt_BGMode_CppToPython_Katie_Qt_BGMode); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_BGMode_PythonToCpp_Katie_Qt_BGMode, + is_Katie_Qt_BGMode_PythonToCpp_Katie_Qt_BGMode_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_BGMODE_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::BGMode"); + Shiboken::Conversions::registerConverterName(converter, "Qt::BGMode"); + Shiboken::Conversions::registerConverterName(converter, "BGMode"); + } + // End of 'BGMode' enum. + + // Initialization of enum 'Key'. + SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX] = Shiboken::Enum::createGlobalEnum(module, + "Key", + "KtCore.Katie.Qt.Key", + "Katie::Qt::Key"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Escape", (long) Katie::Qt::Key::Key_Escape)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Tab", (long) Katie::Qt::Key::Key_Tab)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Backtab", (long) Katie::Qt::Key::Key_Backtab)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Backspace", (long) Katie::Qt::Key::Key_Backspace)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Return", (long) Katie::Qt::Key::Key_Return)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Enter", (long) Katie::Qt::Key::Key_Enter)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Insert", (long) Katie::Qt::Key::Key_Insert)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Delete", (long) Katie::Qt::Key::Key_Delete)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Pause", (long) Katie::Qt::Key::Key_Pause)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Print", (long) Katie::Qt::Key::Key_Print)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_SysReq", (long) Katie::Qt::Key::Key_SysReq)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Clear", (long) Katie::Qt::Key::Key_Clear)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Home", (long) Katie::Qt::Key::Key_Home)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_End", (long) Katie::Qt::Key::Key_End)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Left", (long) Katie::Qt::Key::Key_Left)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Up", (long) Katie::Qt::Key::Key_Up)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Right", (long) Katie::Qt::Key::Key_Right)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Down", (long) Katie::Qt::Key::Key_Down)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_PageUp", (long) Katie::Qt::Key::Key_PageUp)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_PageDown", (long) Katie::Qt::Key::Key_PageDown)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Shift", (long) Katie::Qt::Key::Key_Shift)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Control", (long) Katie::Qt::Key::Key_Control)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Meta", (long) Katie::Qt::Key::Key_Meta)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Alt", (long) Katie::Qt::Key::Key_Alt)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_CapsLock", (long) Katie::Qt::Key::Key_CapsLock)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_NumLock", (long) Katie::Qt::Key::Key_NumLock)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_ScrollLock", (long) Katie::Qt::Key::Key_ScrollLock)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_F1", (long) Katie::Qt::Key::Key_F1)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_F2", (long) Katie::Qt::Key::Key_F2)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_F3", (long) Katie::Qt::Key::Key_F3)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_F4", (long) Katie::Qt::Key::Key_F4)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_F5", (long) Katie::Qt::Key::Key_F5)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_F6", (long) Katie::Qt::Key::Key_F6)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_F7", (long) Katie::Qt::Key::Key_F7)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_F8", (long) Katie::Qt::Key::Key_F8)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_F9", (long) Katie::Qt::Key::Key_F9)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_F10", (long) Katie::Qt::Key::Key_F10)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_F11", (long) Katie::Qt::Key::Key_F11)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_F12", (long) Katie::Qt::Key::Key_F12)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_F13", (long) Katie::Qt::Key::Key_F13)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_F14", (long) Katie::Qt::Key::Key_F14)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_F15", (long) Katie::Qt::Key::Key_F15)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_F16", (long) Katie::Qt::Key::Key_F16)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_F17", (long) Katie::Qt::Key::Key_F17)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_F18", (long) Katie::Qt::Key::Key_F18)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_F19", (long) Katie::Qt::Key::Key_F19)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_F20", (long) Katie::Qt::Key::Key_F20)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_F21", (long) Katie::Qt::Key::Key_F21)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_F22", (long) Katie::Qt::Key::Key_F22)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_F23", (long) Katie::Qt::Key::Key_F23)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_F24", (long) Katie::Qt::Key::Key_F24)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_F25", (long) Katie::Qt::Key::Key_F25)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_F26", (long) Katie::Qt::Key::Key_F26)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_F27", (long) Katie::Qt::Key::Key_F27)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_F28", (long) Katie::Qt::Key::Key_F28)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_F29", (long) Katie::Qt::Key::Key_F29)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_F30", (long) Katie::Qt::Key::Key_F30)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_F31", (long) Katie::Qt::Key::Key_F31)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_F32", (long) Katie::Qt::Key::Key_F32)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_F33", (long) Katie::Qt::Key::Key_F33)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_F34", (long) Katie::Qt::Key::Key_F34)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_F35", (long) Katie::Qt::Key::Key_F35)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Super_L", (long) Katie::Qt::Key::Key_Super_L)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Super_R", (long) Katie::Qt::Key::Key_Super_R)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Menu", (long) Katie::Qt::Key::Key_Menu)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Hyper_L", (long) Katie::Qt::Key::Key_Hyper_L)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Hyper_R", (long) Katie::Qt::Key::Key_Hyper_R)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Help", (long) Katie::Qt::Key::Key_Help)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Direction_L", (long) Katie::Qt::Key::Key_Direction_L)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Direction_R", (long) Katie::Qt::Key::Key_Direction_R)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Space", (long) Katie::Qt::Key::Key_Space)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Any", (long) Katie::Qt::Key::Key_Any)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Exclam", (long) Katie::Qt::Key::Key_Exclam)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_QuoteDbl", (long) Katie::Qt::Key::Key_QuoteDbl)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_NumberSign", (long) Katie::Qt::Key::Key_NumberSign)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Dollar", (long) Katie::Qt::Key::Key_Dollar)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Percent", (long) Katie::Qt::Key::Key_Percent)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Ampersand", (long) Katie::Qt::Key::Key_Ampersand)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Apostrophe", (long) Katie::Qt::Key::Key_Apostrophe)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_ParenLeft", (long) Katie::Qt::Key::Key_ParenLeft)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_ParenRight", (long) Katie::Qt::Key::Key_ParenRight)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Asterisk", (long) Katie::Qt::Key::Key_Asterisk)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Plus", (long) Katie::Qt::Key::Key_Plus)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Comma", (long) Katie::Qt::Key::Key_Comma)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Minus", (long) Katie::Qt::Key::Key_Minus)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Period", (long) Katie::Qt::Key::Key_Period)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Slash", (long) Katie::Qt::Key::Key_Slash)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_0", (long) Katie::Qt::Key::Key_0)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_1", (long) Katie::Qt::Key::Key_1)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_2", (long) Katie::Qt::Key::Key_2)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_3", (long) Katie::Qt::Key::Key_3)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_4", (long) Katie::Qt::Key::Key_4)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_5", (long) Katie::Qt::Key::Key_5)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_6", (long) Katie::Qt::Key::Key_6)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_7", (long) Katie::Qt::Key::Key_7)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_8", (long) Katie::Qt::Key::Key_8)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_9", (long) Katie::Qt::Key::Key_9)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Colon", (long) Katie::Qt::Key::Key_Colon)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Semicolon", (long) Katie::Qt::Key::Key_Semicolon)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Less", (long) Katie::Qt::Key::Key_Less)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Equal", (long) Katie::Qt::Key::Key_Equal)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Greater", (long) Katie::Qt::Key::Key_Greater)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Question", (long) Katie::Qt::Key::Key_Question)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_At", (long) Katie::Qt::Key::Key_At)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_A", (long) Katie::Qt::Key::Key_A)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_B", (long) Katie::Qt::Key::Key_B)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_C", (long) Katie::Qt::Key::Key_C)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_D", (long) Katie::Qt::Key::Key_D)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_E", (long) Katie::Qt::Key::Key_E)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_F", (long) Katie::Qt::Key::Key_F)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_G", (long) Katie::Qt::Key::Key_G)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_H", (long) Katie::Qt::Key::Key_H)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_I", (long) Katie::Qt::Key::Key_I)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_J", (long) Katie::Qt::Key::Key_J)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_K", (long) Katie::Qt::Key::Key_K)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_L", (long) Katie::Qt::Key::Key_L)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_M", (long) Katie::Qt::Key::Key_M)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_N", (long) Katie::Qt::Key::Key_N)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_O", (long) Katie::Qt::Key::Key_O)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_P", (long) Katie::Qt::Key::Key_P)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Q", (long) Katie::Qt::Key::Key_Q)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_R", (long) Katie::Qt::Key::Key_R)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_S", (long) Katie::Qt::Key::Key_S)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_T", (long) Katie::Qt::Key::Key_T)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_U", (long) Katie::Qt::Key::Key_U)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_V", (long) Katie::Qt::Key::Key_V)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_W", (long) Katie::Qt::Key::Key_W)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_X", (long) Katie::Qt::Key::Key_X)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Y", (long) Katie::Qt::Key::Key_Y)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Z", (long) Katie::Qt::Key::Key_Z)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_BracketLeft", (long) Katie::Qt::Key::Key_BracketLeft)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Backslash", (long) Katie::Qt::Key::Key_Backslash)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_BracketRight", (long) Katie::Qt::Key::Key_BracketRight)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_AsciiCircum", (long) Katie::Qt::Key::Key_AsciiCircum)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Underscore", (long) Katie::Qt::Key::Key_Underscore)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_QuoteLeft", (long) Katie::Qt::Key::Key_QuoteLeft)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_BraceLeft", (long) Katie::Qt::Key::Key_BraceLeft)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Bar", (long) Katie::Qt::Key::Key_Bar)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_BraceRight", (long) Katie::Qt::Key::Key_BraceRight)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_AsciiTilde", (long) Katie::Qt::Key::Key_AsciiTilde)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_nobreakspace", (long) Katie::Qt::Key::Key_nobreakspace)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_exclamdown", (long) Katie::Qt::Key::Key_exclamdown)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_cent", (long) Katie::Qt::Key::Key_cent)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_sterling", (long) Katie::Qt::Key::Key_sterling)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_currency", (long) Katie::Qt::Key::Key_currency)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_yen", (long) Katie::Qt::Key::Key_yen)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_brokenbar", (long) Katie::Qt::Key::Key_brokenbar)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_section", (long) Katie::Qt::Key::Key_section)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_diaeresis", (long) Katie::Qt::Key::Key_diaeresis)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_copyright", (long) Katie::Qt::Key::Key_copyright)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_ordfeminine", (long) Katie::Qt::Key::Key_ordfeminine)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_guillemotleft", (long) Katie::Qt::Key::Key_guillemotleft)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_notsign", (long) Katie::Qt::Key::Key_notsign)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_hyphen", (long) Katie::Qt::Key::Key_hyphen)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_registered", (long) Katie::Qt::Key::Key_registered)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_macron", (long) Katie::Qt::Key::Key_macron)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_degree", (long) Katie::Qt::Key::Key_degree)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_plusminus", (long) Katie::Qt::Key::Key_plusminus)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_twosuperior", (long) Katie::Qt::Key::Key_twosuperior)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_threesuperior", (long) Katie::Qt::Key::Key_threesuperior)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_acute", (long) Katie::Qt::Key::Key_acute)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_mu", (long) Katie::Qt::Key::Key_mu)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_paragraph", (long) Katie::Qt::Key::Key_paragraph)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_periodcentered", (long) Katie::Qt::Key::Key_periodcentered)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_cedilla", (long) Katie::Qt::Key::Key_cedilla)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_onesuperior", (long) Katie::Qt::Key::Key_onesuperior)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_masculine", (long) Katie::Qt::Key::Key_masculine)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_guillemotright", (long) Katie::Qt::Key::Key_guillemotright)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_onequarter", (long) Katie::Qt::Key::Key_onequarter)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_onehalf", (long) Katie::Qt::Key::Key_onehalf)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_threequarters", (long) Katie::Qt::Key::Key_threequarters)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_questiondown", (long) Katie::Qt::Key::Key_questiondown)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Agrave", (long) Katie::Qt::Key::Key_Agrave)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Aacute", (long) Katie::Qt::Key::Key_Aacute)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Acircumflex", (long) Katie::Qt::Key::Key_Acircumflex)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Atilde", (long) Katie::Qt::Key::Key_Atilde)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Adiaeresis", (long) Katie::Qt::Key::Key_Adiaeresis)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Aring", (long) Katie::Qt::Key::Key_Aring)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_AE", (long) Katie::Qt::Key::Key_AE)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Ccedilla", (long) Katie::Qt::Key::Key_Ccedilla)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Egrave", (long) Katie::Qt::Key::Key_Egrave)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Eacute", (long) Katie::Qt::Key::Key_Eacute)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Ecircumflex", (long) Katie::Qt::Key::Key_Ecircumflex)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Ediaeresis", (long) Katie::Qt::Key::Key_Ediaeresis)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Igrave", (long) Katie::Qt::Key::Key_Igrave)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Iacute", (long) Katie::Qt::Key::Key_Iacute)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Icircumflex", (long) Katie::Qt::Key::Key_Icircumflex)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Idiaeresis", (long) Katie::Qt::Key::Key_Idiaeresis)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_ETH", (long) Katie::Qt::Key::Key_ETH)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Ntilde", (long) Katie::Qt::Key::Key_Ntilde)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Ograve", (long) Katie::Qt::Key::Key_Ograve)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Oacute", (long) Katie::Qt::Key::Key_Oacute)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Ocircumflex", (long) Katie::Qt::Key::Key_Ocircumflex)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Otilde", (long) Katie::Qt::Key::Key_Otilde)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Odiaeresis", (long) Katie::Qt::Key::Key_Odiaeresis)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_multiply", (long) Katie::Qt::Key::Key_multiply)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Ooblique", (long) Katie::Qt::Key::Key_Ooblique)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Ugrave", (long) Katie::Qt::Key::Key_Ugrave)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Uacute", (long) Katie::Qt::Key::Key_Uacute)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Ucircumflex", (long) Katie::Qt::Key::Key_Ucircumflex)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Udiaeresis", (long) Katie::Qt::Key::Key_Udiaeresis)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Yacute", (long) Katie::Qt::Key::Key_Yacute)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_THORN", (long) Katie::Qt::Key::Key_THORN)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_ssharp", (long) Katie::Qt::Key::Key_ssharp)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_division", (long) Katie::Qt::Key::Key_division)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_ydiaeresis", (long) Katie::Qt::Key::Key_ydiaeresis)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_AltGr", (long) Katie::Qt::Key::Key_AltGr)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Multi_key", (long) Katie::Qt::Key::Key_Multi_key)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Codeinput", (long) Katie::Qt::Key::Key_Codeinput)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_SingleCandidate", (long) Katie::Qt::Key::Key_SingleCandidate)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_MultipleCandidate", (long) Katie::Qt::Key::Key_MultipleCandidate)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_PreviousCandidate", (long) Katie::Qt::Key::Key_PreviousCandidate)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Mode_switch", (long) Katie::Qt::Key::Key_Mode_switch)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Kanji", (long) Katie::Qt::Key::Key_Kanji)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Muhenkan", (long) Katie::Qt::Key::Key_Muhenkan)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Henkan", (long) Katie::Qt::Key::Key_Henkan)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Romaji", (long) Katie::Qt::Key::Key_Romaji)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Hiragana", (long) Katie::Qt::Key::Key_Hiragana)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Katakana", (long) Katie::Qt::Key::Key_Katakana)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Hiragana_Katakana", (long) Katie::Qt::Key::Key_Hiragana_Katakana)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Zenkaku", (long) Katie::Qt::Key::Key_Zenkaku)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Hankaku", (long) Katie::Qt::Key::Key_Hankaku)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Zenkaku_Hankaku", (long) Katie::Qt::Key::Key_Zenkaku_Hankaku)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Touroku", (long) Katie::Qt::Key::Key_Touroku)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Massyo", (long) Katie::Qt::Key::Key_Massyo)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Kana_Lock", (long) Katie::Qt::Key::Key_Kana_Lock)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Kana_Shift", (long) Katie::Qt::Key::Key_Kana_Shift)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Eisu_Shift", (long) Katie::Qt::Key::Key_Eisu_Shift)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Eisu_toggle", (long) Katie::Qt::Key::Key_Eisu_toggle)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Hangul", (long) Katie::Qt::Key::Key_Hangul)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Hangul_Start", (long) Katie::Qt::Key::Key_Hangul_Start)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Hangul_End", (long) Katie::Qt::Key::Key_Hangul_End)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Hangul_Hanja", (long) Katie::Qt::Key::Key_Hangul_Hanja)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Hangul_Jamo", (long) Katie::Qt::Key::Key_Hangul_Jamo)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Hangul_Romaja", (long) Katie::Qt::Key::Key_Hangul_Romaja)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Hangul_Jeonja", (long) Katie::Qt::Key::Key_Hangul_Jeonja)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Hangul_Banja", (long) Katie::Qt::Key::Key_Hangul_Banja)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Hangul_PreHanja", (long) Katie::Qt::Key::Key_Hangul_PreHanja)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Hangul_PostHanja", (long) Katie::Qt::Key::Key_Hangul_PostHanja)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Hangul_Special", (long) Katie::Qt::Key::Key_Hangul_Special)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Dead_Grave", (long) Katie::Qt::Key::Key_Dead_Grave)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Dead_Acute", (long) Katie::Qt::Key::Key_Dead_Acute)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Dead_Circumflex", (long) Katie::Qt::Key::Key_Dead_Circumflex)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Dead_Tilde", (long) Katie::Qt::Key::Key_Dead_Tilde)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Dead_Macron", (long) Katie::Qt::Key::Key_Dead_Macron)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Dead_Breve", (long) Katie::Qt::Key::Key_Dead_Breve)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Dead_Abovedot", (long) Katie::Qt::Key::Key_Dead_Abovedot)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Dead_Diaeresis", (long) Katie::Qt::Key::Key_Dead_Diaeresis)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Dead_Abovering", (long) Katie::Qt::Key::Key_Dead_Abovering)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Dead_Doubleacute", (long) Katie::Qt::Key::Key_Dead_Doubleacute)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Dead_Caron", (long) Katie::Qt::Key::Key_Dead_Caron)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Dead_Cedilla", (long) Katie::Qt::Key::Key_Dead_Cedilla)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Dead_Ogonek", (long) Katie::Qt::Key::Key_Dead_Ogonek)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Dead_Iota", (long) Katie::Qt::Key::Key_Dead_Iota)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Dead_Voiced_Sound", (long) Katie::Qt::Key::Key_Dead_Voiced_Sound)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Dead_Semivoiced_Sound", (long) Katie::Qt::Key::Key_Dead_Semivoiced_Sound)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Dead_Belowdot", (long) Katie::Qt::Key::Key_Dead_Belowdot)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Dead_Hook", (long) Katie::Qt::Key::Key_Dead_Hook)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Dead_Horn", (long) Katie::Qt::Key::Key_Dead_Horn)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Back", (long) Katie::Qt::Key::Key_Back)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Forward", (long) Katie::Qt::Key::Key_Forward)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Stop", (long) Katie::Qt::Key::Key_Stop)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Refresh", (long) Katie::Qt::Key::Key_Refresh)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_VolumeDown", (long) Katie::Qt::Key::Key_VolumeDown)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_VolumeMute", (long) Katie::Qt::Key::Key_VolumeMute)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_VolumeUp", (long) Katie::Qt::Key::Key_VolumeUp)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_BassBoost", (long) Katie::Qt::Key::Key_BassBoost)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_BassUp", (long) Katie::Qt::Key::Key_BassUp)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_BassDown", (long) Katie::Qt::Key::Key_BassDown)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_TrebleUp", (long) Katie::Qt::Key::Key_TrebleUp)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_TrebleDown", (long) Katie::Qt::Key::Key_TrebleDown)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_MediaPlay", (long) Katie::Qt::Key::Key_MediaPlay)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_MediaStop", (long) Katie::Qt::Key::Key_MediaStop)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_MediaPrevious", (long) Katie::Qt::Key::Key_MediaPrevious)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_MediaNext", (long) Katie::Qt::Key::Key_MediaNext)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_MediaRecord", (long) Katie::Qt::Key::Key_MediaRecord)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_MediaPause", (long) Katie::Qt::Key::Key_MediaPause)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_MediaTogglePlayPause", (long) Katie::Qt::Key::Key_MediaTogglePlayPause)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_HomePage", (long) Katie::Qt::Key::Key_HomePage)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Favorites", (long) Katie::Qt::Key::Key_Favorites)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Search", (long) Katie::Qt::Key::Key_Search)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Standby", (long) Katie::Qt::Key::Key_Standby)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_OpenUrl", (long) Katie::Qt::Key::Key_OpenUrl)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_LaunchMail", (long) Katie::Qt::Key::Key_LaunchMail)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_LaunchMedia", (long) Katie::Qt::Key::Key_LaunchMedia)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Launch0", (long) Katie::Qt::Key::Key_Launch0)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Launch1", (long) Katie::Qt::Key::Key_Launch1)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Launch2", (long) Katie::Qt::Key::Key_Launch2)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Launch3", (long) Katie::Qt::Key::Key_Launch3)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Launch4", (long) Katie::Qt::Key::Key_Launch4)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Launch5", (long) Katie::Qt::Key::Key_Launch5)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Launch6", (long) Katie::Qt::Key::Key_Launch6)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Launch7", (long) Katie::Qt::Key::Key_Launch7)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Launch8", (long) Katie::Qt::Key::Key_Launch8)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Launch9", (long) Katie::Qt::Key::Key_Launch9)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_LaunchA", (long) Katie::Qt::Key::Key_LaunchA)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_LaunchB", (long) Katie::Qt::Key::Key_LaunchB)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_LaunchC", (long) Katie::Qt::Key::Key_LaunchC)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_LaunchD", (long) Katie::Qt::Key::Key_LaunchD)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_LaunchE", (long) Katie::Qt::Key::Key_LaunchE)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_LaunchF", (long) Katie::Qt::Key::Key_LaunchF)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_MonBrightnessUp", (long) Katie::Qt::Key::Key_MonBrightnessUp)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_MonBrightnessDown", (long) Katie::Qt::Key::Key_MonBrightnessDown)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_KeyboardLightOnOff", (long) Katie::Qt::Key::Key_KeyboardLightOnOff)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_KeyboardBrightnessUp", (long) Katie::Qt::Key::Key_KeyboardBrightnessUp)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_KeyboardBrightnessDown", (long) Katie::Qt::Key::Key_KeyboardBrightnessDown)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_PowerOff", (long) Katie::Qt::Key::Key_PowerOff)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_WakeUp", (long) Katie::Qt::Key::Key_WakeUp)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Eject", (long) Katie::Qt::Key::Key_Eject)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_ScreenSaver", (long) Katie::Qt::Key::Key_ScreenSaver)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_WWW", (long) Katie::Qt::Key::Key_WWW)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Memo", (long) Katie::Qt::Key::Key_Memo)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_LightBulb", (long) Katie::Qt::Key::Key_LightBulb)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Shop", (long) Katie::Qt::Key::Key_Shop)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_History", (long) Katie::Qt::Key::Key_History)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_AddFavorite", (long) Katie::Qt::Key::Key_AddFavorite)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_HotLinks", (long) Katie::Qt::Key::Key_HotLinks)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_BrightnessAdjust", (long) Katie::Qt::Key::Key_BrightnessAdjust)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Finance", (long) Katie::Qt::Key::Key_Finance)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Community", (long) Katie::Qt::Key::Key_Community)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_AudioRewind", (long) Katie::Qt::Key::Key_AudioRewind)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_BackForward", (long) Katie::Qt::Key::Key_BackForward)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_ApplicationLeft", (long) Katie::Qt::Key::Key_ApplicationLeft)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_ApplicationRight", (long) Katie::Qt::Key::Key_ApplicationRight)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Book", (long) Katie::Qt::Key::Key_Book)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_CD", (long) Katie::Qt::Key::Key_CD)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Calculator", (long) Katie::Qt::Key::Key_Calculator)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_ToDoList", (long) Katie::Qt::Key::Key_ToDoList)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_ClearGrab", (long) Katie::Qt::Key::Key_ClearGrab)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Close", (long) Katie::Qt::Key::Key_Close)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Copy", (long) Katie::Qt::Key::Key_Copy)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Cut", (long) Katie::Qt::Key::Key_Cut)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Display", (long) Katie::Qt::Key::Key_Display)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_DOS", (long) Katie::Qt::Key::Key_DOS)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Documents", (long) Katie::Qt::Key::Key_Documents)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Excel", (long) Katie::Qt::Key::Key_Excel)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Explorer", (long) Katie::Qt::Key::Key_Explorer)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Game", (long) Katie::Qt::Key::Key_Game)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Go", (long) Katie::Qt::Key::Key_Go)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_iTouch", (long) Katie::Qt::Key::Key_iTouch)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_LogOff", (long) Katie::Qt::Key::Key_LogOff)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Market", (long) Katie::Qt::Key::Key_Market)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Meeting", (long) Katie::Qt::Key::Key_Meeting)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_MenuKB", (long) Katie::Qt::Key::Key_MenuKB)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_MenuPB", (long) Katie::Qt::Key::Key_MenuPB)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_MySites", (long) Katie::Qt::Key::Key_MySites)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_News", (long) Katie::Qt::Key::Key_News)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_OfficeHome", (long) Katie::Qt::Key::Key_OfficeHome)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Option", (long) Katie::Qt::Key::Key_Option)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Paste", (long) Katie::Qt::Key::Key_Paste)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Phone", (long) Katie::Qt::Key::Key_Phone)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Calendar", (long) Katie::Qt::Key::Key_Calendar)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Reply", (long) Katie::Qt::Key::Key_Reply)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Reload", (long) Katie::Qt::Key::Key_Reload)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_RotateWindows", (long) Katie::Qt::Key::Key_RotateWindows)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_RotationPB", (long) Katie::Qt::Key::Key_RotationPB)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_RotationKB", (long) Katie::Qt::Key::Key_RotationKB)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Save", (long) Katie::Qt::Key::Key_Save)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Send", (long) Katie::Qt::Key::Key_Send)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Spell", (long) Katie::Qt::Key::Key_Spell)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_SplitScreen", (long) Katie::Qt::Key::Key_SplitScreen)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Support", (long) Katie::Qt::Key::Key_Support)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_TaskPane", (long) Katie::Qt::Key::Key_TaskPane)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Terminal", (long) Katie::Qt::Key::Key_Terminal)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Tools", (long) Katie::Qt::Key::Key_Tools)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Travel", (long) Katie::Qt::Key::Key_Travel)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Video", (long) Katie::Qt::Key::Key_Video)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Word", (long) Katie::Qt::Key::Key_Word)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Xfer", (long) Katie::Qt::Key::Key_Xfer)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_ZoomIn", (long) Katie::Qt::Key::Key_ZoomIn)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_ZoomOut", (long) Katie::Qt::Key::Key_ZoomOut)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Away", (long) Katie::Qt::Key::Key_Away)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Messenger", (long) Katie::Qt::Key::Key_Messenger)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_WebCam", (long) Katie::Qt::Key::Key_WebCam)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_MailForward", (long) Katie::Qt::Key::Key_MailForward)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Pictures", (long) Katie::Qt::Key::Key_Pictures)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Music", (long) Katie::Qt::Key::Key_Music)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Battery", (long) Katie::Qt::Key::Key_Battery)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Bluetooth", (long) Katie::Qt::Key::Key_Bluetooth)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_WLAN", (long) Katie::Qt::Key::Key_WLAN)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_UWB", (long) Katie::Qt::Key::Key_UWB)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_AudioForward", (long) Katie::Qt::Key::Key_AudioForward)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_AudioRepeat", (long) Katie::Qt::Key::Key_AudioRepeat)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_AudioRandomPlay", (long) Katie::Qt::Key::Key_AudioRandomPlay)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Subtitle", (long) Katie::Qt::Key::Key_Subtitle)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_AudioCycleTrack", (long) Katie::Qt::Key::Key_AudioCycleTrack)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Time", (long) Katie::Qt::Key::Key_Time)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Hibernate", (long) Katie::Qt::Key::Key_Hibernate)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_View", (long) Katie::Qt::Key::Key_View)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_TopMenu", (long) Katie::Qt::Key::Key_TopMenu)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_PowerDown", (long) Katie::Qt::Key::Key_PowerDown)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Suspend", (long) Katie::Qt::Key::Key_Suspend)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_ContrastAdjust", (long) Katie::Qt::Key::Key_ContrastAdjust)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_LaunchG", (long) Katie::Qt::Key::Key_LaunchG)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_LaunchH", (long) Katie::Qt::Key::Key_LaunchH)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_MediaLast", (long) Katie::Qt::Key::Key_MediaLast)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Select", (long) Katie::Qt::Key::Key_Select)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Yes", (long) Katie::Qt::Key::Key_Yes)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_No", (long) Katie::Qt::Key::Key_No)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Cancel", (long) Katie::Qt::Key::Key_Cancel)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Printer", (long) Katie::Qt::Key::Key_Printer)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Execute", (long) Katie::Qt::Key::Key_Execute)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Sleep", (long) Katie::Qt::Key::Key_Sleep)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Play", (long) Katie::Qt::Key::Key_Play)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Zoom", (long) Katie::Qt::Key::Key_Zoom)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Context1", (long) Katie::Qt::Key::Key_Context1)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Context2", (long) Katie::Qt::Key::Key_Context2)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Context3", (long) Katie::Qt::Key::Key_Context3)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Context4", (long) Katie::Qt::Key::Key_Context4)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Call", (long) Katie::Qt::Key::Key_Call)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Hangup", (long) Katie::Qt::Key::Key_Hangup)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Flip", (long) Katie::Qt::Key::Key_Flip)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_ToggleCallHangup", (long) Katie::Qt::Key::Key_ToggleCallHangup)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_VoiceDial", (long) Katie::Qt::Key::Key_VoiceDial)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_LastNumberRedial", (long) Katie::Qt::Key::Key_LastNumberRedial)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_Camera", (long) Katie::Qt::Key::Key_Camera)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_CameraFocus", (long) Katie::Qt::Key::Key_CameraFocus)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + module, "Key_unknown", (long) Katie::Qt::Key::Key_unknown)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::Key'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], + Katie_Qt_Key_CppToPython_Katie_Qt_Key); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_Key_PythonToCpp_Katie_Qt_Key, + is_Katie_Qt_Key_PythonToCpp_Katie_Qt_Key_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::Key"); + Shiboken::Conversions::registerConverterName(converter, "Qt::Key"); + Shiboken::Conversions::registerConverterName(converter, "Key"); + } + // End of 'Key' enum. + + // Initialization of enum 'ArrowType'. + SbkKtCoreTypes[SBK_KATIE_QT_ARROWTYPE_IDX] = Shiboken::Enum::createGlobalEnum(module, + "ArrowType", + "KtCore.Katie.Qt.ArrowType", + "Katie::Qt::ArrowType"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_ARROWTYPE_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ARROWTYPE_IDX], + module, "NoArrow", (long) Katie::Qt::ArrowType::NoArrow)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ARROWTYPE_IDX], + module, "UpArrow", (long) Katie::Qt::ArrowType::UpArrow)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ARROWTYPE_IDX], + module, "DownArrow", (long) Katie::Qt::ArrowType::DownArrow)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ARROWTYPE_IDX], + module, "LeftArrow", (long) Katie::Qt::ArrowType::LeftArrow)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ARROWTYPE_IDX], + module, "RightArrow", (long) Katie::Qt::ArrowType::RightArrow)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::ArrowType'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_ARROWTYPE_IDX], + Katie_Qt_ArrowType_CppToPython_Katie_Qt_ArrowType); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_ArrowType_PythonToCpp_Katie_Qt_ArrowType, + is_Katie_Qt_ArrowType_PythonToCpp_Katie_Qt_ArrowType_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_ARROWTYPE_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::ArrowType"); + Shiboken::Conversions::registerConverterName(converter, "Qt::ArrowType"); + Shiboken::Conversions::registerConverterName(converter, "ArrowType"); + } + // End of 'ArrowType' enum. + + // Initialization of enum 'PenStyle'. + SbkKtCoreTypes[SBK_KATIE_QT_PENSTYLE_IDX] = Shiboken::Enum::createGlobalEnum(module, + "PenStyle", + "KtCore.Katie.Qt.PenStyle", + "Katie::Qt::PenStyle"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_PENSTYLE_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_PENSTYLE_IDX], + module, "NoPen", (long) Katie::Qt::PenStyle::NoPen)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_PENSTYLE_IDX], + module, "SolidLine", (long) Katie::Qt::PenStyle::SolidLine)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_PENSTYLE_IDX], + module, "DashLine", (long) Katie::Qt::PenStyle::DashLine)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_PENSTYLE_IDX], + module, "DotLine", (long) Katie::Qt::PenStyle::DotLine)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_PENSTYLE_IDX], + module, "DashDotLine", (long) Katie::Qt::PenStyle::DashDotLine)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_PENSTYLE_IDX], + module, "DashDotDotLine", (long) Katie::Qt::PenStyle::DashDotDotLine)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_PENSTYLE_IDX], + module, "CustomDashLine", (long) Katie::Qt::PenStyle::CustomDashLine)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_PENSTYLE_IDX], + module, "MPenStyle", (long) Katie::Qt::PenStyle::MPenStyle)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::PenStyle'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_PENSTYLE_IDX], + Katie_Qt_PenStyle_CppToPython_Katie_Qt_PenStyle); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_PenStyle_PythonToCpp_Katie_Qt_PenStyle, + is_Katie_Qt_PenStyle_PythonToCpp_Katie_Qt_PenStyle_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_PENSTYLE_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::PenStyle"); + Shiboken::Conversions::registerConverterName(converter, "Qt::PenStyle"); + Shiboken::Conversions::registerConverterName(converter, "PenStyle"); + } + // End of 'PenStyle' enum. + + // Initialization of enum 'PenCapStyle'. + SbkKtCoreTypes[SBK_KATIE_QT_PENCAPSTYLE_IDX] = Shiboken::Enum::createGlobalEnum(module, + "PenCapStyle", + "KtCore.Katie.Qt.PenCapStyle", + "Katie::Qt::PenCapStyle"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_PENCAPSTYLE_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_PENCAPSTYLE_IDX], + module, "FlatCap", (long) Katie::Qt::PenCapStyle::FlatCap)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_PENCAPSTYLE_IDX], + module, "SquareCap", (long) Katie::Qt::PenCapStyle::SquareCap)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_PENCAPSTYLE_IDX], + module, "RoundCap", (long) Katie::Qt::PenCapStyle::RoundCap)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_PENCAPSTYLE_IDX], + module, "MPenCapStyle", (long) Katie::Qt::PenCapStyle::MPenCapStyle)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::PenCapStyle'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_PENCAPSTYLE_IDX], + Katie_Qt_PenCapStyle_CppToPython_Katie_Qt_PenCapStyle); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_PenCapStyle_PythonToCpp_Katie_Qt_PenCapStyle, + is_Katie_Qt_PenCapStyle_PythonToCpp_Katie_Qt_PenCapStyle_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_PENCAPSTYLE_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::PenCapStyle"); + Shiboken::Conversions::registerConverterName(converter, "Qt::PenCapStyle"); + Shiboken::Conversions::registerConverterName(converter, "PenCapStyle"); + } + // End of 'PenCapStyle' enum. + + // Initialization of enum 'PenJoinStyle'. + SbkKtCoreTypes[SBK_KATIE_QT_PENJOINSTYLE_IDX] = Shiboken::Enum::createGlobalEnum(module, + "PenJoinStyle", + "KtCore.Katie.Qt.PenJoinStyle", + "Katie::Qt::PenJoinStyle"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_PENJOINSTYLE_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_PENJOINSTYLE_IDX], + module, "MiterJoin", (long) Katie::Qt::PenJoinStyle::MiterJoin)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_PENJOINSTYLE_IDX], + module, "BevelJoin", (long) Katie::Qt::PenJoinStyle::BevelJoin)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_PENJOINSTYLE_IDX], + module, "RoundJoin", (long) Katie::Qt::PenJoinStyle::RoundJoin)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_PENJOINSTYLE_IDX], + module, "SvgMiterJoin", (long) Katie::Qt::PenJoinStyle::SvgMiterJoin)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_PENJOINSTYLE_IDX], + module, "MPenJoinStyle", (long) Katie::Qt::PenJoinStyle::MPenJoinStyle)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::PenJoinStyle'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_PENJOINSTYLE_IDX], + Katie_Qt_PenJoinStyle_CppToPython_Katie_Qt_PenJoinStyle); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_PenJoinStyle_PythonToCpp_Katie_Qt_PenJoinStyle, + is_Katie_Qt_PenJoinStyle_PythonToCpp_Katie_Qt_PenJoinStyle_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_PENJOINSTYLE_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::PenJoinStyle"); + Shiboken::Conversions::registerConverterName(converter, "Qt::PenJoinStyle"); + Shiboken::Conversions::registerConverterName(converter, "PenJoinStyle"); + } + // End of 'PenJoinStyle' enum. + + // Initialization of enum 'BrushStyle'. + SbkKtCoreTypes[SBK_KATIE_QT_BRUSHSTYLE_IDX] = Shiboken::Enum::createGlobalEnum(module, + "BrushStyle", + "KtCore.Katie.Qt.BrushStyle", + "Katie::Qt::BrushStyle"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_BRUSHSTYLE_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_BRUSHSTYLE_IDX], + module, "NoBrush", (long) Katie::Qt::BrushStyle::NoBrush)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_BRUSHSTYLE_IDX], + module, "SolidPattern", (long) Katie::Qt::BrushStyle::SolidPattern)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_BRUSHSTYLE_IDX], + module, "Dense1Pattern", (long) Katie::Qt::BrushStyle::Dense1Pattern)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_BRUSHSTYLE_IDX], + module, "Dense2Pattern", (long) Katie::Qt::BrushStyle::Dense2Pattern)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_BRUSHSTYLE_IDX], + module, "Dense3Pattern", (long) Katie::Qt::BrushStyle::Dense3Pattern)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_BRUSHSTYLE_IDX], + module, "Dense4Pattern", (long) Katie::Qt::BrushStyle::Dense4Pattern)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_BRUSHSTYLE_IDX], + module, "Dense5Pattern", (long) Katie::Qt::BrushStyle::Dense5Pattern)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_BRUSHSTYLE_IDX], + module, "Dense6Pattern", (long) Katie::Qt::BrushStyle::Dense6Pattern)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_BRUSHSTYLE_IDX], + module, "Dense7Pattern", (long) Katie::Qt::BrushStyle::Dense7Pattern)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_BRUSHSTYLE_IDX], + module, "HorPattern", (long) Katie::Qt::BrushStyle::HorPattern)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_BRUSHSTYLE_IDX], + module, "VerPattern", (long) Katie::Qt::BrushStyle::VerPattern)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_BRUSHSTYLE_IDX], + module, "CrossPattern", (long) Katie::Qt::BrushStyle::CrossPattern)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_BRUSHSTYLE_IDX], + module, "BDiagPattern", (long) Katie::Qt::BrushStyle::BDiagPattern)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_BRUSHSTYLE_IDX], + module, "FDiagPattern", (long) Katie::Qt::BrushStyle::FDiagPattern)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_BRUSHSTYLE_IDX], + module, "DiagCrossPattern", (long) Katie::Qt::BrushStyle::DiagCrossPattern)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_BRUSHSTYLE_IDX], + module, "LinearGradientPattern", (long) Katie::Qt::BrushStyle::LinearGradientPattern)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_BRUSHSTYLE_IDX], + module, "RadialGradientPattern", (long) Katie::Qt::BrushStyle::RadialGradientPattern)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_BRUSHSTYLE_IDX], + module, "ConicalGradientPattern", (long) Katie::Qt::BrushStyle::ConicalGradientPattern)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_BRUSHSTYLE_IDX], + module, "TexturePattern", (long) Katie::Qt::BrushStyle::TexturePattern)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::BrushStyle'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_BRUSHSTYLE_IDX], + Katie_Qt_BrushStyle_CppToPython_Katie_Qt_BrushStyle); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_BrushStyle_PythonToCpp_Katie_Qt_BrushStyle, + is_Katie_Qt_BrushStyle_PythonToCpp_Katie_Qt_BrushStyle_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_BRUSHSTYLE_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::BrushStyle"); + Shiboken::Conversions::registerConverterName(converter, "Qt::BrushStyle"); + Shiboken::Conversions::registerConverterName(converter, "BrushStyle"); + } + // End of 'BrushStyle' enum. + + // Initialization of enum 'SizeMode'. + SbkKtCoreTypes[SBK_KATIE_QT_SIZEMODE_IDX] = Shiboken::Enum::createGlobalEnum(module, + "SizeMode", + "KtCore.Katie.Qt.SizeMode", + "Katie::Qt::SizeMode"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_SIZEMODE_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_SIZEMODE_IDX], + module, "AbsoluteSize", (long) Katie::Qt::SizeMode::AbsoluteSize)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_SIZEMODE_IDX], + module, "RelativeSize", (long) Katie::Qt::SizeMode::RelativeSize)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::SizeMode'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_SIZEMODE_IDX], + Katie_Qt_SizeMode_CppToPython_Katie_Qt_SizeMode); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_SizeMode_PythonToCpp_Katie_Qt_SizeMode, + is_Katie_Qt_SizeMode_PythonToCpp_Katie_Qt_SizeMode_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_SIZEMODE_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::SizeMode"); + Shiboken::Conversions::registerConverterName(converter, "Qt::SizeMode"); + Shiboken::Conversions::registerConverterName(converter, "SizeMode"); + } + // End of 'SizeMode' enum. + + // Initialization of enum 'UIEffect'. + SbkKtCoreTypes[SBK_KATIE_QT_UIEFFECT_IDX] = Shiboken::Enum::createGlobalEnum(module, + "UIEffect", + "KtCore.Katie.Qt.UIEffect", + "Katie::Qt::UIEffect"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_UIEFFECT_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_UIEFFECT_IDX], + module, "UI_General", (long) Katie::Qt::UIEffect::UI_General)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_UIEFFECT_IDX], + module, "UI_AnimateMenu", (long) Katie::Qt::UIEffect::UI_AnimateMenu)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_UIEFFECT_IDX], + module, "UI_FadeMenu", (long) Katie::Qt::UIEffect::UI_FadeMenu)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_UIEFFECT_IDX], + module, "UI_AnimateCombo", (long) Katie::Qt::UIEffect::UI_AnimateCombo)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_UIEFFECT_IDX], + module, "UI_AnimateTooltip", (long) Katie::Qt::UIEffect::UI_AnimateTooltip)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_UIEFFECT_IDX], + module, "UI_FadeTooltip", (long) Katie::Qt::UIEffect::UI_FadeTooltip)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_UIEFFECT_IDX], + module, "UI_AnimateToolBox", (long) Katie::Qt::UIEffect::UI_AnimateToolBox)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::UIEffect'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_UIEFFECT_IDX], + Katie_Qt_UIEffect_CppToPython_Katie_Qt_UIEffect); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_UIEffect_PythonToCpp_Katie_Qt_UIEffect, + is_Katie_Qt_UIEffect_PythonToCpp_Katie_Qt_UIEffect_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_UIEFFECT_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::UIEffect"); + Shiboken::Conversions::registerConverterName(converter, "Qt::UIEffect"); + Shiboken::Conversions::registerConverterName(converter, "UIEffect"); + } + // End of 'UIEffect' enum. + + // Initialization of enum 'CursorShape'. + SbkKtCoreTypes[SBK_KATIE_QT_CURSORSHAPE_IDX] = Shiboken::Enum::createGlobalEnum(module, + "CursorShape", + "KtCore.Katie.Qt.CursorShape", + "Katie::Qt::CursorShape"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_CURSORSHAPE_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CURSORSHAPE_IDX], + module, "ArrowCursor", (long) Katie::Qt::CursorShape::ArrowCursor)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CURSORSHAPE_IDX], + module, "UpArrowCursor", (long) Katie::Qt::CursorShape::UpArrowCursor)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CURSORSHAPE_IDX], + module, "CrossCursor", (long) Katie::Qt::CursorShape::CrossCursor)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CURSORSHAPE_IDX], + module, "WaitCursor", (long) Katie::Qt::CursorShape::WaitCursor)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CURSORSHAPE_IDX], + module, "IBeamCursor", (long) Katie::Qt::CursorShape::IBeamCursor)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CURSORSHAPE_IDX], + module, "SizeVerCursor", (long) Katie::Qt::CursorShape::SizeVerCursor)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CURSORSHAPE_IDX], + module, "SizeHorCursor", (long) Katie::Qt::CursorShape::SizeHorCursor)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CURSORSHAPE_IDX], + module, "SizeBDiagCursor", (long) Katie::Qt::CursorShape::SizeBDiagCursor)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CURSORSHAPE_IDX], + module, "SizeFDiagCursor", (long) Katie::Qt::CursorShape::SizeFDiagCursor)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CURSORSHAPE_IDX], + module, "SizeAllCursor", (long) Katie::Qt::CursorShape::SizeAllCursor)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CURSORSHAPE_IDX], + module, "BlankCursor", (long) Katie::Qt::CursorShape::BlankCursor)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CURSORSHAPE_IDX], + module, "SplitVCursor", (long) Katie::Qt::CursorShape::SplitVCursor)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CURSORSHAPE_IDX], + module, "SplitHCursor", (long) Katie::Qt::CursorShape::SplitHCursor)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CURSORSHAPE_IDX], + module, "PointingHandCursor", (long) Katie::Qt::CursorShape::PointingHandCursor)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CURSORSHAPE_IDX], + module, "ForbiddenCursor", (long) Katie::Qt::CursorShape::ForbiddenCursor)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CURSORSHAPE_IDX], + module, "WhatsThisCursor", (long) Katie::Qt::CursorShape::WhatsThisCursor)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CURSORSHAPE_IDX], + module, "BusyCursor", (long) Katie::Qt::CursorShape::BusyCursor)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CURSORSHAPE_IDX], + module, "OpenHandCursor", (long) Katie::Qt::CursorShape::OpenHandCursor)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CURSORSHAPE_IDX], + module, "ClosedHandCursor", (long) Katie::Qt::CursorShape::ClosedHandCursor)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CURSORSHAPE_IDX], + module, "DragCopyCursor", (long) Katie::Qt::CursorShape::DragCopyCursor)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CURSORSHAPE_IDX], + module, "DragMoveCursor", (long) Katie::Qt::CursorShape::DragMoveCursor)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CURSORSHAPE_IDX], + module, "DragLinkCursor", (long) Katie::Qt::CursorShape::DragLinkCursor)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CURSORSHAPE_IDX], + module, "LastCursor", (long) Katie::Qt::CursorShape::LastCursor)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CURSORSHAPE_IDX], + module, "BitmapCursor", (long) Katie::Qt::CursorShape::BitmapCursor)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CURSORSHAPE_IDX], + module, "CustomCursor", (long) Katie::Qt::CursorShape::CustomCursor)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::CursorShape'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_CURSORSHAPE_IDX], + Katie_Qt_CursorShape_CppToPython_Katie_Qt_CursorShape); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_CursorShape_PythonToCpp_Katie_Qt_CursorShape, + is_Katie_Qt_CursorShape_PythonToCpp_Katie_Qt_CursorShape_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_CURSORSHAPE_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::CursorShape"); + Shiboken::Conversions::registerConverterName(converter, "Qt::CursorShape"); + Shiboken::Conversions::registerConverterName(converter, "CursorShape"); + } + // End of 'CursorShape' enum. + + // Initialization of enum 'TextFormat'. + SbkKtCoreTypes[SBK_KATIE_QT_TEXTFORMAT_IDX] = Shiboken::Enum::createGlobalEnum(module, + "TextFormat", + "KtCore.Katie.Qt.TextFormat", + "Katie::Qt::TextFormat"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_TEXTFORMAT_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TEXTFORMAT_IDX], + module, "PlainText", (long) Katie::Qt::TextFormat::PlainText)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TEXTFORMAT_IDX], + module, "RichText", (long) Katie::Qt::TextFormat::RichText)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TEXTFORMAT_IDX], + module, "AutoText", (long) Katie::Qt::TextFormat::AutoText)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TEXTFORMAT_IDX], + module, "LogText", (long) Katie::Qt::TextFormat::LogText)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::TextFormat'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_TEXTFORMAT_IDX], + Katie_Qt_TextFormat_CppToPython_Katie_Qt_TextFormat); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_TextFormat_PythonToCpp_Katie_Qt_TextFormat, + is_Katie_Qt_TextFormat_PythonToCpp_Katie_Qt_TextFormat_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_TEXTFORMAT_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::TextFormat"); + Shiboken::Conversions::registerConverterName(converter, "Qt::TextFormat"); + Shiboken::Conversions::registerConverterName(converter, "TextFormat"); + } + // End of 'TextFormat' enum. + + // Initialization of enum 'AspectRatioMode'. + SbkKtCoreTypes[SBK_KATIE_QT_ASPECTRATIOMODE_IDX] = Shiboken::Enum::createGlobalEnum(module, + "AspectRatioMode", + "KtCore.Katie.Qt.AspectRatioMode", + "Katie::Qt::AspectRatioMode"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_ASPECTRATIOMODE_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ASPECTRATIOMODE_IDX], + module, "IgnoreAspectRatio", (long) Katie::Qt::AspectRatioMode::IgnoreAspectRatio)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ASPECTRATIOMODE_IDX], + module, "KeepAspectRatio", (long) Katie::Qt::AspectRatioMode::KeepAspectRatio)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ASPECTRATIOMODE_IDX], + module, "KeepAspectRatioByExpanding", (long) Katie::Qt::AspectRatioMode::KeepAspectRatioByExpanding)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::AspectRatioMode'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_ASPECTRATIOMODE_IDX], + Katie_Qt_AspectRatioMode_CppToPython_Katie_Qt_AspectRatioMode); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_AspectRatioMode_PythonToCpp_Katie_Qt_AspectRatioMode, + is_Katie_Qt_AspectRatioMode_PythonToCpp_Katie_Qt_AspectRatioMode_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_ASPECTRATIOMODE_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::AspectRatioMode"); + Shiboken::Conversions::registerConverterName(converter, "Qt::AspectRatioMode"); + Shiboken::Conversions::registerConverterName(converter, "AspectRatioMode"); + } + // End of 'AspectRatioMode' enum. + + // Initialization of enum 'AnchorAttribute'. + SbkKtCoreTypes[SBK_KATIE_QT_ANCHORATTRIBUTE_IDX] = Shiboken::Enum::createGlobalEnum(module, + "AnchorAttribute", + "KtCore.Katie.Qt.AnchorAttribute", + "Katie::Qt::AnchorAttribute"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_ANCHORATTRIBUTE_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ANCHORATTRIBUTE_IDX], + module, "AnchorName", (long) Katie::Qt::AnchorAttribute::AnchorName)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ANCHORATTRIBUTE_IDX], + module, "AnchorHref", (long) Katie::Qt::AnchorAttribute::AnchorHref)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::AnchorAttribute'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_ANCHORATTRIBUTE_IDX], + Katie_Qt_AnchorAttribute_CppToPython_Katie_Qt_AnchorAttribute); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_AnchorAttribute_PythonToCpp_Katie_Qt_AnchorAttribute, + is_Katie_Qt_AnchorAttribute_PythonToCpp_Katie_Qt_AnchorAttribute_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_ANCHORATTRIBUTE_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::AnchorAttribute"); + Shiboken::Conversions::registerConverterName(converter, "Qt::AnchorAttribute"); + Shiboken::Conversions::registerConverterName(converter, "AnchorAttribute"); + } + // End of 'AnchorAttribute' enum. + + // Initialization of enum 'DockWidgetArea'. + SbkKtCoreTypes[SBK_KATIE_QT_DOCKWIDGETAREA_IDX] = Shiboken::Enum::createGlobalEnum(module, + "DockWidgetArea", + "KtCore.Katie.Qt.DockWidgetArea", + "Katie::Qt::DockWidgetArea"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_DOCKWIDGETAREA_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_DOCKWIDGETAREA_IDX], + module, "LeftDockWidgetArea", (long) Katie::Qt::DockWidgetArea::LeftDockWidgetArea)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_DOCKWIDGETAREA_IDX], + module, "RightDockWidgetArea", (long) Katie::Qt::DockWidgetArea::RightDockWidgetArea)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_DOCKWIDGETAREA_IDX], + module, "TopDockWidgetArea", (long) Katie::Qt::DockWidgetArea::TopDockWidgetArea)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_DOCKWIDGETAREA_IDX], + module, "BottomDockWidgetArea", (long) Katie::Qt::DockWidgetArea::BottomDockWidgetArea)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_DOCKWIDGETAREA_IDX], + module, "DockWidgetArea_Mask", (long) Katie::Qt::DockWidgetArea::DockWidgetArea_Mask)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_DOCKWIDGETAREA_IDX], + module, "AllDockWidgetAreas", (long) Katie::Qt::DockWidgetArea::AllDockWidgetAreas)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_DOCKWIDGETAREA_IDX], + module, "NoDockWidgetArea", (long) Katie::Qt::DockWidgetArea::NoDockWidgetArea)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::DockWidgetArea'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_DOCKWIDGETAREA_IDX], + Katie_Qt_DockWidgetArea_CppToPython_Katie_Qt_DockWidgetArea); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_DockWidgetArea_PythonToCpp_Katie_Qt_DockWidgetArea, + is_Katie_Qt_DockWidgetArea_PythonToCpp_Katie_Qt_DockWidgetArea_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_DOCKWIDGETAREA_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::DockWidgetArea"); + Shiboken::Conversions::registerConverterName(converter, "Qt::DockWidgetArea"); + Shiboken::Conversions::registerConverterName(converter, "DockWidgetArea"); + } + // End of 'DockWidgetArea' enum. + + // Initialization of enum 'DockWidgetAreaSizes'. + SbkKtCoreTypes[SBK_KATIE_QT_DOCKWIDGETAREASIZES_IDX] = Shiboken::Enum::createGlobalEnum(module, + "DockWidgetAreaSizes", + "KtCore.Katie.Qt.DockWidgetAreaSizes", + "Katie::Qt::DockWidgetAreaSizes"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_DOCKWIDGETAREASIZES_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_DOCKWIDGETAREASIZES_IDX], + module, "NDockWidgetAreas", (long) Katie::Qt::DockWidgetAreaSizes::NDockWidgetAreas)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::DockWidgetAreaSizes'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_DOCKWIDGETAREASIZES_IDX], + Katie_Qt_DockWidgetAreaSizes_CppToPython_Katie_Qt_DockWidgetAreaSizes); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_DockWidgetAreaSizes_PythonToCpp_Katie_Qt_DockWidgetAreaSizes, + is_Katie_Qt_DockWidgetAreaSizes_PythonToCpp_Katie_Qt_DockWidgetAreaSizes_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_DOCKWIDGETAREASIZES_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::DockWidgetAreaSizes"); + Shiboken::Conversions::registerConverterName(converter, "Qt::DockWidgetAreaSizes"); + Shiboken::Conversions::registerConverterName(converter, "DockWidgetAreaSizes"); + } + // End of 'DockWidgetAreaSizes' enum. + + // Initialization of enum 'ToolBarArea'. + SbkKtCoreTypes[SBK_KATIE_QT_TOOLBARAREA_IDX] = Shiboken::Enum::createGlobalEnum(module, + "ToolBarArea", + "KtCore.Katie.Qt.ToolBarArea", + "Katie::Qt::ToolBarArea"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_TOOLBARAREA_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TOOLBARAREA_IDX], + module, "LeftToolBarArea", (long) Katie::Qt::ToolBarArea::LeftToolBarArea)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TOOLBARAREA_IDX], + module, "RightToolBarArea", (long) Katie::Qt::ToolBarArea::RightToolBarArea)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TOOLBARAREA_IDX], + module, "TopToolBarArea", (long) Katie::Qt::ToolBarArea::TopToolBarArea)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TOOLBARAREA_IDX], + module, "BottomToolBarArea", (long) Katie::Qt::ToolBarArea::BottomToolBarArea)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TOOLBARAREA_IDX], + module, "ToolBarArea_Mask", (long) Katie::Qt::ToolBarArea::ToolBarArea_Mask)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TOOLBARAREA_IDX], + module, "AllToolBarAreas", (long) Katie::Qt::ToolBarArea::AllToolBarAreas)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TOOLBARAREA_IDX], + module, "NoToolBarArea", (long) Katie::Qt::ToolBarArea::NoToolBarArea)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::ToolBarArea'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_TOOLBARAREA_IDX], + Katie_Qt_ToolBarArea_CppToPython_Katie_Qt_ToolBarArea); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_ToolBarArea_PythonToCpp_Katie_Qt_ToolBarArea, + is_Katie_Qt_ToolBarArea_PythonToCpp_Katie_Qt_ToolBarArea_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_TOOLBARAREA_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::ToolBarArea"); + Shiboken::Conversions::registerConverterName(converter, "Qt::ToolBarArea"); + Shiboken::Conversions::registerConverterName(converter, "ToolBarArea"); + } + // End of 'ToolBarArea' enum. + + // Initialization of enum 'ToolBarAreaSizes'. + SbkKtCoreTypes[SBK_KATIE_QT_TOOLBARAREASIZES_IDX] = Shiboken::Enum::createGlobalEnum(module, + "ToolBarAreaSizes", + "KtCore.Katie.Qt.ToolBarAreaSizes", + "Katie::Qt::ToolBarAreaSizes"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_TOOLBARAREASIZES_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TOOLBARAREASIZES_IDX], + module, "NToolBarAreas", (long) Katie::Qt::ToolBarAreaSizes::NToolBarAreas)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::ToolBarAreaSizes'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_TOOLBARAREASIZES_IDX], + Katie_Qt_ToolBarAreaSizes_CppToPython_Katie_Qt_ToolBarAreaSizes); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_ToolBarAreaSizes_PythonToCpp_Katie_Qt_ToolBarAreaSizes, + is_Katie_Qt_ToolBarAreaSizes_PythonToCpp_Katie_Qt_ToolBarAreaSizes_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_TOOLBARAREASIZES_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::ToolBarAreaSizes"); + Shiboken::Conversions::registerConverterName(converter, "Qt::ToolBarAreaSizes"); + Shiboken::Conversions::registerConverterName(converter, "ToolBarAreaSizes"); + } + // End of 'ToolBarAreaSizes' enum. + + // Initialization of enum 'DateFormat'. + SbkKtCoreTypes[SBK_KATIE_QT_DATEFORMAT_IDX] = Shiboken::Enum::createGlobalEnum(module, + "DateFormat", + "KtCore.Katie.Qt.DateFormat", + "Katie::Qt::DateFormat"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_DATEFORMAT_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_DATEFORMAT_IDX], + module, "TextDate", (long) Katie::Qt::DateFormat::TextDate)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_DATEFORMAT_IDX], + module, "ISODate", (long) Katie::Qt::DateFormat::ISODate)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_DATEFORMAT_IDX], + module, "SystemLocaleDate", (long) Katie::Qt::DateFormat::SystemLocaleDate)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_DATEFORMAT_IDX], + module, "LocalDate", (long) Katie::Qt::DateFormat::LocalDate)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_DATEFORMAT_IDX], + module, "LocaleDate", (long) Katie::Qt::DateFormat::LocaleDate)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_DATEFORMAT_IDX], + module, "SystemLocaleShortDate", (long) Katie::Qt::DateFormat::SystemLocaleShortDate)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_DATEFORMAT_IDX], + module, "SystemLocaleLongDate", (long) Katie::Qt::DateFormat::SystemLocaleLongDate)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_DATEFORMAT_IDX], + module, "DefaultLocaleShortDate", (long) Katie::Qt::DateFormat::DefaultLocaleShortDate)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_DATEFORMAT_IDX], + module, "DefaultLocaleLongDate", (long) Katie::Qt::DateFormat::DefaultLocaleLongDate)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::DateFormat'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_DATEFORMAT_IDX], + Katie_Qt_DateFormat_CppToPython_Katie_Qt_DateFormat); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_DateFormat_PythonToCpp_Katie_Qt_DateFormat, + is_Katie_Qt_DateFormat_PythonToCpp_Katie_Qt_DateFormat_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_DATEFORMAT_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::DateFormat"); + Shiboken::Conversions::registerConverterName(converter, "Qt::DateFormat"); + Shiboken::Conversions::registerConverterName(converter, "DateFormat"); + } + // End of 'DateFormat' enum. + + // Initialization of enum 'TimeSpec'. + SbkKtCoreTypes[SBK_KATIE_QT_TIMESPEC_IDX] = Shiboken::Enum::createGlobalEnum(module, + "TimeSpec", + "KtCore.Katie.Qt.TimeSpec", + "Katie::Qt::TimeSpec"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_TIMESPEC_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TIMESPEC_IDX], + module, "LocalTime", (long) Katie::Qt::TimeSpec::LocalTime)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TIMESPEC_IDX], + module, "UTC", (long) Katie::Qt::TimeSpec::UTC)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TIMESPEC_IDX], + module, "OffsetFromUTC", (long) Katie::Qt::TimeSpec::OffsetFromUTC)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::TimeSpec'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_TIMESPEC_IDX], + Katie_Qt_TimeSpec_CppToPython_Katie_Qt_TimeSpec); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_TimeSpec_PythonToCpp_Katie_Qt_TimeSpec, + is_Katie_Qt_TimeSpec_PythonToCpp_Katie_Qt_TimeSpec_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_TIMESPEC_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::TimeSpec"); + Shiboken::Conversions::registerConverterName(converter, "Qt::TimeSpec"); + Shiboken::Conversions::registerConverterName(converter, "TimeSpec"); + } + // End of 'TimeSpec' enum. + + // Initialization of enum 'DayOfWeek'. + SbkKtCoreTypes[SBK_KATIE_QT_DAYOFWEEK_IDX] = Shiboken::Enum::createGlobalEnum(module, + "DayOfWeek", + "KtCore.Katie.Qt.DayOfWeek", + "Katie::Qt::DayOfWeek"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_DAYOFWEEK_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_DAYOFWEEK_IDX], + module, "Monday", (long) Katie::Qt::DayOfWeek::Monday)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_DAYOFWEEK_IDX], + module, "Tuesday", (long) Katie::Qt::DayOfWeek::Tuesday)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_DAYOFWEEK_IDX], + module, "Wednesday", (long) Katie::Qt::DayOfWeek::Wednesday)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_DAYOFWEEK_IDX], + module, "Thursday", (long) Katie::Qt::DayOfWeek::Thursday)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_DAYOFWEEK_IDX], + module, "Friday", (long) Katie::Qt::DayOfWeek::Friday)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_DAYOFWEEK_IDX], + module, "Saturday", (long) Katie::Qt::DayOfWeek::Saturday)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_DAYOFWEEK_IDX], + module, "Sunday", (long) Katie::Qt::DayOfWeek::Sunday)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::DayOfWeek'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_DAYOFWEEK_IDX], + Katie_Qt_DayOfWeek_CppToPython_Katie_Qt_DayOfWeek); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_DayOfWeek_PythonToCpp_Katie_Qt_DayOfWeek, + is_Katie_Qt_DayOfWeek_PythonToCpp_Katie_Qt_DayOfWeek_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_DAYOFWEEK_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::DayOfWeek"); + Shiboken::Conversions::registerConverterName(converter, "Qt::DayOfWeek"); + Shiboken::Conversions::registerConverterName(converter, "DayOfWeek"); + } + // End of 'DayOfWeek' enum. + + // Initialization of enum 'ScrollBarPolicy'. + SbkKtCoreTypes[SBK_KATIE_QT_SCROLLBARPOLICY_IDX] = Shiboken::Enum::createGlobalEnum(module, + "ScrollBarPolicy", + "KtCore.Katie.Qt.ScrollBarPolicy", + "Katie::Qt::ScrollBarPolicy"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_SCROLLBARPOLICY_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_SCROLLBARPOLICY_IDX], + module, "ScrollBarAsNeeded", (long) Katie::Qt::ScrollBarPolicy::ScrollBarAsNeeded)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_SCROLLBARPOLICY_IDX], + module, "ScrollBarAlwaysOff", (long) Katie::Qt::ScrollBarPolicy::ScrollBarAlwaysOff)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_SCROLLBARPOLICY_IDX], + module, "ScrollBarAlwaysOn", (long) Katie::Qt::ScrollBarPolicy::ScrollBarAlwaysOn)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::ScrollBarPolicy'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_SCROLLBARPOLICY_IDX], + Katie_Qt_ScrollBarPolicy_CppToPython_Katie_Qt_ScrollBarPolicy); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_ScrollBarPolicy_PythonToCpp_Katie_Qt_ScrollBarPolicy, + is_Katie_Qt_ScrollBarPolicy_PythonToCpp_Katie_Qt_ScrollBarPolicy_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_SCROLLBARPOLICY_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::ScrollBarPolicy"); + Shiboken::Conversions::registerConverterName(converter, "Qt::ScrollBarPolicy"); + Shiboken::Conversions::registerConverterName(converter, "ScrollBarPolicy"); + } + // End of 'ScrollBarPolicy' enum. + + // Initialization of enum 'CaseSensitivity'. + SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX] = Shiboken::Enum::createGlobalEnum(module, + "CaseSensitivity", + "KtCore.Katie.Qt.CaseSensitivity", + "Katie::Qt::CaseSensitivity"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX], + module, "CaseInsensitive", (long) Katie::Qt::CaseSensitivity::CaseInsensitive)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX], + module, "CaseSensitive", (long) Katie::Qt::CaseSensitivity::CaseSensitive)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::CaseSensitivity'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX], + Katie_Qt_CaseSensitivity_CppToPython_Katie_Qt_CaseSensitivity); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_CaseSensitivity_PythonToCpp_Katie_Qt_CaseSensitivity, + is_Katie_Qt_CaseSensitivity_PythonToCpp_Katie_Qt_CaseSensitivity_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::CaseSensitivity"); + Shiboken::Conversions::registerConverterName(converter, "Qt::CaseSensitivity"); + Shiboken::Conversions::registerConverterName(converter, "CaseSensitivity"); + } + // End of 'CaseSensitivity' enum. + + // Initialization of enum 'Corner'. + SbkKtCoreTypes[SBK_KATIE_QT_CORNER_IDX] = Shiboken::Enum::createGlobalEnum(module, + "Corner", + "KtCore.Katie.Qt.Corner", + "Katie::Qt::Corner"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_CORNER_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CORNER_IDX], + module, "TopLeftCorner", (long) Katie::Qt::Corner::TopLeftCorner)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CORNER_IDX], + module, "TopRightCorner", (long) Katie::Qt::Corner::TopRightCorner)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CORNER_IDX], + module, "BottomLeftCorner", (long) Katie::Qt::Corner::BottomLeftCorner)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CORNER_IDX], + module, "BottomRightCorner", (long) Katie::Qt::Corner::BottomRightCorner)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::Corner'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_CORNER_IDX], + Katie_Qt_Corner_CppToPython_Katie_Qt_Corner); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_Corner_PythonToCpp_Katie_Qt_Corner, + is_Katie_Qt_Corner_PythonToCpp_Katie_Qt_Corner_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_CORNER_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::Corner"); + Shiboken::Conversions::registerConverterName(converter, "Qt::Corner"); + Shiboken::Conversions::registerConverterName(converter, "Corner"); + } + // End of 'Corner' enum. + + // Initialization of enum 'ConnectionType'. + SbkKtCoreTypes[SBK_KATIE_QT_CONNECTIONTYPE_IDX] = Shiboken::Enum::createGlobalEnum(module, + "ConnectionType", + "KtCore.Katie.Qt.ConnectionType", + "Katie::Qt::ConnectionType"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_CONNECTIONTYPE_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CONNECTIONTYPE_IDX], + module, "AutoConnection", (long) Katie::Qt::ConnectionType::AutoConnection)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CONNECTIONTYPE_IDX], + module, "DirectConnection", (long) Katie::Qt::ConnectionType::DirectConnection)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CONNECTIONTYPE_IDX], + module, "QueuedConnection", (long) Katie::Qt::ConnectionType::QueuedConnection)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CONNECTIONTYPE_IDX], + module, "BlockingQueuedConnection", (long) Katie::Qt::ConnectionType::BlockingQueuedConnection)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CONNECTIONTYPE_IDX], + module, "UniqueConnection", (long) Katie::Qt::ConnectionType::UniqueConnection)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::ConnectionType'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_CONNECTIONTYPE_IDX], + Katie_Qt_ConnectionType_CppToPython_Katie_Qt_ConnectionType); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_ConnectionType_PythonToCpp_Katie_Qt_ConnectionType, + is_Katie_Qt_ConnectionType_PythonToCpp_Katie_Qt_ConnectionType_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_CONNECTIONTYPE_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::ConnectionType"); + Shiboken::Conversions::registerConverterName(converter, "Qt::ConnectionType"); + Shiboken::Conversions::registerConverterName(converter, "ConnectionType"); + } + // End of 'ConnectionType' enum. + + // Initialization of enum 'ShortcutContext'. + SbkKtCoreTypes[SBK_KATIE_QT_SHORTCUTCONTEXT_IDX] = Shiboken::Enum::createGlobalEnum(module, + "ShortcutContext", + "KtCore.Katie.Qt.ShortcutContext", + "Katie::Qt::ShortcutContext"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_SHORTCUTCONTEXT_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_SHORTCUTCONTEXT_IDX], + module, "WidgetShortcut", (long) Katie::Qt::ShortcutContext::WidgetShortcut)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_SHORTCUTCONTEXT_IDX], + module, "WindowShortcut", (long) Katie::Qt::ShortcutContext::WindowShortcut)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_SHORTCUTCONTEXT_IDX], + module, "ApplicationShortcut", (long) Katie::Qt::ShortcutContext::ApplicationShortcut)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_SHORTCUTCONTEXT_IDX], + module, "WidgetWithChildrenShortcut", (long) Katie::Qt::ShortcutContext::WidgetWithChildrenShortcut)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::ShortcutContext'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_SHORTCUTCONTEXT_IDX], + Katie_Qt_ShortcutContext_CppToPython_Katie_Qt_ShortcutContext); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_ShortcutContext_PythonToCpp_Katie_Qt_ShortcutContext, + is_Katie_Qt_ShortcutContext_PythonToCpp_Katie_Qt_ShortcutContext_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_SHORTCUTCONTEXT_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::ShortcutContext"); + Shiboken::Conversions::registerConverterName(converter, "Qt::ShortcutContext"); + Shiboken::Conversions::registerConverterName(converter, "ShortcutContext"); + } + // End of 'ShortcutContext' enum. + + // Initialization of enum 'FillRule'. + SbkKtCoreTypes[SBK_KATIE_QT_FILLRULE_IDX] = Shiboken::Enum::createGlobalEnum(module, + "FillRule", + "KtCore.Katie.Qt.FillRule", + "Katie::Qt::FillRule"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_FILLRULE_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_FILLRULE_IDX], + module, "OddEvenFill", (long) Katie::Qt::FillRule::OddEvenFill)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_FILLRULE_IDX], + module, "WindingFill", (long) Katie::Qt::FillRule::WindingFill)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::FillRule'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_FILLRULE_IDX], + Katie_Qt_FillRule_CppToPython_Katie_Qt_FillRule); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_FillRule_PythonToCpp_Katie_Qt_FillRule, + is_Katie_Qt_FillRule_PythonToCpp_Katie_Qt_FillRule_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_FILLRULE_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::FillRule"); + Shiboken::Conversions::registerConverterName(converter, "Qt::FillRule"); + Shiboken::Conversions::registerConverterName(converter, "FillRule"); + } + // End of 'FillRule' enum. + + // Initialization of enum 'MaskMode'. + SbkKtCoreTypes[SBK_KATIE_QT_MASKMODE_IDX] = Shiboken::Enum::createGlobalEnum(module, + "MaskMode", + "KtCore.Katie.Qt.MaskMode", + "Katie::Qt::MaskMode"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_MASKMODE_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_MASKMODE_IDX], + module, "MaskInColor", (long) Katie::Qt::MaskMode::MaskInColor)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_MASKMODE_IDX], + module, "MaskOutColor", (long) Katie::Qt::MaskMode::MaskOutColor)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::MaskMode'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_MASKMODE_IDX], + Katie_Qt_MaskMode_CppToPython_Katie_Qt_MaskMode); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_MaskMode_PythonToCpp_Katie_Qt_MaskMode, + is_Katie_Qt_MaskMode_PythonToCpp_Katie_Qt_MaskMode_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_MASKMODE_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::MaskMode"); + Shiboken::Conversions::registerConverterName(converter, "Qt::MaskMode"); + Shiboken::Conversions::registerConverterName(converter, "MaskMode"); + } + // End of 'MaskMode' enum. + + // Initialization of enum 'ClipOperation'. + SbkKtCoreTypes[SBK_KATIE_QT_CLIPOPERATION_IDX] = Shiboken::Enum::createGlobalEnum(module, + "ClipOperation", + "KtCore.Katie.Qt.ClipOperation", + "Katie::Qt::ClipOperation"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_CLIPOPERATION_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CLIPOPERATION_IDX], + module, "NoClip", (long) Katie::Qt::ClipOperation::NoClip)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CLIPOPERATION_IDX], + module, "ReplaceClip", (long) Katie::Qt::ClipOperation::ReplaceClip)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CLIPOPERATION_IDX], + module, "IntersectClip", (long) Katie::Qt::ClipOperation::IntersectClip)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CLIPOPERATION_IDX], + module, "UniteClip", (long) Katie::Qt::ClipOperation::UniteClip)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::ClipOperation'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_CLIPOPERATION_IDX], + Katie_Qt_ClipOperation_CppToPython_Katie_Qt_ClipOperation); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_ClipOperation_PythonToCpp_Katie_Qt_ClipOperation, + is_Katie_Qt_ClipOperation_PythonToCpp_Katie_Qt_ClipOperation_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_CLIPOPERATION_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::ClipOperation"); + Shiboken::Conversions::registerConverterName(converter, "Qt::ClipOperation"); + Shiboken::Conversions::registerConverterName(converter, "ClipOperation"); + } + // End of 'ClipOperation' enum. + + // Initialization of enum 'ItemSelectionMode'. + SbkKtCoreTypes[SBK_KATIE_QT_ITEMSELECTIONMODE_IDX] = Shiboken::Enum::createGlobalEnum(module, + "ItemSelectionMode", + "KtCore.Katie.Qt.ItemSelectionMode", + "Katie::Qt::ItemSelectionMode"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_ITEMSELECTIONMODE_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ITEMSELECTIONMODE_IDX], + module, "ContainsItemShape", (long) Katie::Qt::ItemSelectionMode::ContainsItemShape)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ITEMSELECTIONMODE_IDX], + module, "IntersectsItemShape", (long) Katie::Qt::ItemSelectionMode::IntersectsItemShape)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ITEMSELECTIONMODE_IDX], + module, "ContainsItemBoundingRect", (long) Katie::Qt::ItemSelectionMode::ContainsItemBoundingRect)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ITEMSELECTIONMODE_IDX], + module, "IntersectsItemBoundingRect", (long) Katie::Qt::ItemSelectionMode::IntersectsItemBoundingRect)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::ItemSelectionMode'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_ITEMSELECTIONMODE_IDX], + Katie_Qt_ItemSelectionMode_CppToPython_Katie_Qt_ItemSelectionMode); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_ItemSelectionMode_PythonToCpp_Katie_Qt_ItemSelectionMode, + is_Katie_Qt_ItemSelectionMode_PythonToCpp_Katie_Qt_ItemSelectionMode_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_ITEMSELECTIONMODE_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::ItemSelectionMode"); + Shiboken::Conversions::registerConverterName(converter, "Qt::ItemSelectionMode"); + Shiboken::Conversions::registerConverterName(converter, "ItemSelectionMode"); + } + // End of 'ItemSelectionMode' enum. + + // Initialization of enum 'TransformationMode'. + SbkKtCoreTypes[SBK_KATIE_QT_TRANSFORMATIONMODE_IDX] = Shiboken::Enum::createGlobalEnum(module, + "TransformationMode", + "KtCore.Katie.Qt.TransformationMode", + "Katie::Qt::TransformationMode"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_TRANSFORMATIONMODE_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TRANSFORMATIONMODE_IDX], + module, "FastTransformation", (long) Katie::Qt::TransformationMode::FastTransformation)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TRANSFORMATIONMODE_IDX], + module, "SmoothTransformation", (long) Katie::Qt::TransformationMode::SmoothTransformation)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::TransformationMode'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_TRANSFORMATIONMODE_IDX], + Katie_Qt_TransformationMode_CppToPython_Katie_Qt_TransformationMode); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_TransformationMode_PythonToCpp_Katie_Qt_TransformationMode, + is_Katie_Qt_TransformationMode_PythonToCpp_Katie_Qt_TransformationMode_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_TRANSFORMATIONMODE_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::TransformationMode"); + Shiboken::Conversions::registerConverterName(converter, "Qt::TransformationMode"); + Shiboken::Conversions::registerConverterName(converter, "TransformationMode"); + } + // End of 'TransformationMode' enum. + + // Initialization of enum 'Axis'. + SbkKtCoreTypes[SBK_KATIE_QT_AXIS_IDX] = Shiboken::Enum::createGlobalEnum(module, + "Axis", + "KtCore.Katie.Qt.Axis", + "Katie::Qt::Axis"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_AXIS_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_AXIS_IDX], + module, "XAxis", (long) Katie::Qt::Axis::XAxis)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_AXIS_IDX], + module, "YAxis", (long) Katie::Qt::Axis::YAxis)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_AXIS_IDX], + module, "ZAxis", (long) Katie::Qt::Axis::ZAxis)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::Axis'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_AXIS_IDX], + Katie_Qt_Axis_CppToPython_Katie_Qt_Axis); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_Axis_PythonToCpp_Katie_Qt_Axis, + is_Katie_Qt_Axis_PythonToCpp_Katie_Qt_Axis_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_AXIS_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::Axis"); + Shiboken::Conversions::registerConverterName(converter, "Qt::Axis"); + Shiboken::Conversions::registerConverterName(converter, "Axis"); + } + // End of 'Axis' enum. + + // Initialization of enum 'FocusReason'. + SbkKtCoreTypes[SBK_KATIE_QT_FOCUSREASON_IDX] = Shiboken::Enum::createGlobalEnum(module, + "FocusReason", + "KtCore.Katie.Qt.FocusReason", + "Katie::Qt::FocusReason"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_FOCUSREASON_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_FOCUSREASON_IDX], + module, "MouseFocusReason", (long) Katie::Qt::FocusReason::MouseFocusReason)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_FOCUSREASON_IDX], + module, "TabFocusReason", (long) Katie::Qt::FocusReason::TabFocusReason)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_FOCUSREASON_IDX], + module, "BacktabFocusReason", (long) Katie::Qt::FocusReason::BacktabFocusReason)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_FOCUSREASON_IDX], + module, "ActiveWindowFocusReason", (long) Katie::Qt::FocusReason::ActiveWindowFocusReason)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_FOCUSREASON_IDX], + module, "PopupFocusReason", (long) Katie::Qt::FocusReason::PopupFocusReason)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_FOCUSREASON_IDX], + module, "ShortcutFocusReason", (long) Katie::Qt::FocusReason::ShortcutFocusReason)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_FOCUSREASON_IDX], + module, "MenuBarFocusReason", (long) Katie::Qt::FocusReason::MenuBarFocusReason)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_FOCUSREASON_IDX], + module, "OtherFocusReason", (long) Katie::Qt::FocusReason::OtherFocusReason)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_FOCUSREASON_IDX], + module, "NoFocusReason", (long) Katie::Qt::FocusReason::NoFocusReason)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::FocusReason'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_FOCUSREASON_IDX], + Katie_Qt_FocusReason_CppToPython_Katie_Qt_FocusReason); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_FocusReason_PythonToCpp_Katie_Qt_FocusReason, + is_Katie_Qt_FocusReason_PythonToCpp_Katie_Qt_FocusReason_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_FOCUSREASON_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::FocusReason"); + Shiboken::Conversions::registerConverterName(converter, "Qt::FocusReason"); + Shiboken::Conversions::registerConverterName(converter, "FocusReason"); + } + // End of 'FocusReason' enum. + + // Initialization of enum 'ContextMenuPolicy'. + SbkKtCoreTypes[SBK_KATIE_QT_CONTEXTMENUPOLICY_IDX] = Shiboken::Enum::createGlobalEnum(module, + "ContextMenuPolicy", + "KtCore.Katie.Qt.ContextMenuPolicy", + "Katie::Qt::ContextMenuPolicy"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_CONTEXTMENUPOLICY_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CONTEXTMENUPOLICY_IDX], + module, "NoContextMenu", (long) Katie::Qt::ContextMenuPolicy::NoContextMenu)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CONTEXTMENUPOLICY_IDX], + module, "DefaultContextMenu", (long) Katie::Qt::ContextMenuPolicy::DefaultContextMenu)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CONTEXTMENUPOLICY_IDX], + module, "ActionsContextMenu", (long) Katie::Qt::ContextMenuPolicy::ActionsContextMenu)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CONTEXTMENUPOLICY_IDX], + module, "CustomContextMenu", (long) Katie::Qt::ContextMenuPolicy::CustomContextMenu)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CONTEXTMENUPOLICY_IDX], + module, "PreventContextMenu", (long) Katie::Qt::ContextMenuPolicy::PreventContextMenu)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::ContextMenuPolicy'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_CONTEXTMENUPOLICY_IDX], + Katie_Qt_ContextMenuPolicy_CppToPython_Katie_Qt_ContextMenuPolicy); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_ContextMenuPolicy_PythonToCpp_Katie_Qt_ContextMenuPolicy, + is_Katie_Qt_ContextMenuPolicy_PythonToCpp_Katie_Qt_ContextMenuPolicy_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_CONTEXTMENUPOLICY_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::ContextMenuPolicy"); + Shiboken::Conversions::registerConverterName(converter, "Qt::ContextMenuPolicy"); + Shiboken::Conversions::registerConverterName(converter, "ContextMenuPolicy"); + } + // End of 'ContextMenuPolicy' enum. + + // Initialization of enum 'ToolButtonStyle'. + SbkKtCoreTypes[SBK_KATIE_QT_TOOLBUTTONSTYLE_IDX] = Shiboken::Enum::createGlobalEnum(module, + "ToolButtonStyle", + "KtCore.Katie.Qt.ToolButtonStyle", + "Katie::Qt::ToolButtonStyle"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_TOOLBUTTONSTYLE_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TOOLBUTTONSTYLE_IDX], + module, "ToolButtonIconOnly", (long) Katie::Qt::ToolButtonStyle::ToolButtonIconOnly)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TOOLBUTTONSTYLE_IDX], + module, "ToolButtonTextOnly", (long) Katie::Qt::ToolButtonStyle::ToolButtonTextOnly)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TOOLBUTTONSTYLE_IDX], + module, "ToolButtonTextBesideIcon", (long) Katie::Qt::ToolButtonStyle::ToolButtonTextBesideIcon)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TOOLBUTTONSTYLE_IDX], + module, "ToolButtonTextUnderIcon", (long) Katie::Qt::ToolButtonStyle::ToolButtonTextUnderIcon)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TOOLBUTTONSTYLE_IDX], + module, "ToolButtonFollowStyle", (long) Katie::Qt::ToolButtonStyle::ToolButtonFollowStyle)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::ToolButtonStyle'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_TOOLBUTTONSTYLE_IDX], + Katie_Qt_ToolButtonStyle_CppToPython_Katie_Qt_ToolButtonStyle); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_ToolButtonStyle_PythonToCpp_Katie_Qt_ToolButtonStyle, + is_Katie_Qt_ToolButtonStyle_PythonToCpp_Katie_Qt_ToolButtonStyle_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_TOOLBUTTONSTYLE_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::ToolButtonStyle"); + Shiboken::Conversions::registerConverterName(converter, "Qt::ToolButtonStyle"); + Shiboken::Conversions::registerConverterName(converter, "ToolButtonStyle"); + } + // End of 'ToolButtonStyle' enum. + + // Initialization of enum 'LayoutDirection'. + SbkKtCoreTypes[SBK_KATIE_QT_LAYOUTDIRECTION_IDX] = Shiboken::Enum::createGlobalEnum(module, + "LayoutDirection", + "KtCore.Katie.Qt.LayoutDirection", + "Katie::Qt::LayoutDirection"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_LAYOUTDIRECTION_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_LAYOUTDIRECTION_IDX], + module, "LeftToRight", (long) Katie::Qt::LayoutDirection::LeftToRight)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_LAYOUTDIRECTION_IDX], + module, "RightToLeft", (long) Katie::Qt::LayoutDirection::RightToLeft)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_LAYOUTDIRECTION_IDX], + module, "LayoutDirectionAuto", (long) Katie::Qt::LayoutDirection::LayoutDirectionAuto)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::LayoutDirection'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_LAYOUTDIRECTION_IDX], + Katie_Qt_LayoutDirection_CppToPython_Katie_Qt_LayoutDirection); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_LayoutDirection_PythonToCpp_Katie_Qt_LayoutDirection, + is_Katie_Qt_LayoutDirection_PythonToCpp_Katie_Qt_LayoutDirection_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_LAYOUTDIRECTION_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::LayoutDirection"); + Shiboken::Conversions::registerConverterName(converter, "Qt::LayoutDirection"); + Shiboken::Conversions::registerConverterName(converter, "LayoutDirection"); + } + // End of 'LayoutDirection' enum. + + // Initialization of enum 'AnchorPoint'. + SbkKtCoreTypes[SBK_KATIE_QT_ANCHORPOINT_IDX] = Shiboken::Enum::createGlobalEnum(module, + "AnchorPoint", + "KtCore.Katie.Qt.AnchorPoint", + "Katie::Qt::AnchorPoint"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_ANCHORPOINT_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ANCHORPOINT_IDX], + module, "AnchorLeft", (long) Katie::Qt::AnchorPoint::AnchorLeft)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ANCHORPOINT_IDX], + module, "AnchorHorizontalCenter", (long) Katie::Qt::AnchorPoint::AnchorHorizontalCenter)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ANCHORPOINT_IDX], + module, "AnchorRight", (long) Katie::Qt::AnchorPoint::AnchorRight)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ANCHORPOINT_IDX], + module, "AnchorTop", (long) Katie::Qt::AnchorPoint::AnchorTop)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ANCHORPOINT_IDX], + module, "AnchorVerticalCenter", (long) Katie::Qt::AnchorPoint::AnchorVerticalCenter)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ANCHORPOINT_IDX], + module, "AnchorBottom", (long) Katie::Qt::AnchorPoint::AnchorBottom)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::AnchorPoint'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_ANCHORPOINT_IDX], + Katie_Qt_AnchorPoint_CppToPython_Katie_Qt_AnchorPoint); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_AnchorPoint_PythonToCpp_Katie_Qt_AnchorPoint, + is_Katie_Qt_AnchorPoint_PythonToCpp_Katie_Qt_AnchorPoint_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_ANCHORPOINT_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::AnchorPoint"); + Shiboken::Conversions::registerConverterName(converter, "Qt::AnchorPoint"); + Shiboken::Conversions::registerConverterName(converter, "AnchorPoint"); + } + // End of 'AnchorPoint' enum. + + // Initialization of enum 'DropAction'. + SbkKtCoreTypes[SBK_KATIE_QT_DROPACTION_IDX] = Shiboken::Enum::createGlobalEnum(module, + "DropAction", + "KtCore.Katie.Qt.DropAction", + "Katie::Qt::DropAction"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_DROPACTION_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_DROPACTION_IDX], + module, "CopyAction", (long) Katie::Qt::DropAction::CopyAction)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_DROPACTION_IDX], + module, "MoveAction", (long) Katie::Qt::DropAction::MoveAction)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_DROPACTION_IDX], + module, "LinkAction", (long) Katie::Qt::DropAction::LinkAction)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_DROPACTION_IDX], + module, "ActionMask", (long) Katie::Qt::DropAction::ActionMask)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_DROPACTION_IDX], + module, "TargetMoveAction", (long) Katie::Qt::DropAction::TargetMoveAction)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_DROPACTION_IDX], + module, "IgnoreAction", (long) Katie::Qt::DropAction::IgnoreAction)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::DropAction'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_DROPACTION_IDX], + Katie_Qt_DropAction_CppToPython_Katie_Qt_DropAction); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_DropAction_PythonToCpp_Katie_Qt_DropAction, + is_Katie_Qt_DropAction_PythonToCpp_Katie_Qt_DropAction_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_DROPACTION_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::DropAction"); + Shiboken::Conversions::registerConverterName(converter, "Qt::DropAction"); + Shiboken::Conversions::registerConverterName(converter, "DropAction"); + } + // End of 'DropAction' enum. + + // Initialization of enum 'CheckState'. + SbkKtCoreTypes[SBK_KATIE_QT_CHECKSTATE_IDX] = Shiboken::Enum::createGlobalEnum(module, + "CheckState", + "KtCore.Katie.Qt.CheckState", + "Katie::Qt::CheckState"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_CHECKSTATE_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CHECKSTATE_IDX], + module, "Unchecked", (long) Katie::Qt::CheckState::Unchecked)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CHECKSTATE_IDX], + module, "PartiallyChecked", (long) Katie::Qt::CheckState::PartiallyChecked)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CHECKSTATE_IDX], + module, "Checked", (long) Katie::Qt::CheckState::Checked)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::CheckState'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_CHECKSTATE_IDX], + Katie_Qt_CheckState_CppToPython_Katie_Qt_CheckState); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_CheckState_PythonToCpp_Katie_Qt_CheckState, + is_Katie_Qt_CheckState_PythonToCpp_Katie_Qt_CheckState_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_CHECKSTATE_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::CheckState"); + Shiboken::Conversions::registerConverterName(converter, "Qt::CheckState"); + Shiboken::Conversions::registerConverterName(converter, "CheckState"); + } + // End of 'CheckState' enum. + + // Initialization of enum 'ItemDataRole'. + SbkKtCoreTypes[SBK_KATIE_QT_ITEMDATAROLE_IDX] = Shiboken::Enum::createGlobalEnum(module, + "ItemDataRole", + "KtCore.Katie.Qt.ItemDataRole", + "Katie::Qt::ItemDataRole"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_ITEMDATAROLE_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ITEMDATAROLE_IDX], + module, "DisplayRole", (long) Katie::Qt::ItemDataRole::DisplayRole)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ITEMDATAROLE_IDX], + module, "DecorationRole", (long) Katie::Qt::ItemDataRole::DecorationRole)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ITEMDATAROLE_IDX], + module, "EditRole", (long) Katie::Qt::ItemDataRole::EditRole)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ITEMDATAROLE_IDX], + module, "ToolTipRole", (long) Katie::Qt::ItemDataRole::ToolTipRole)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ITEMDATAROLE_IDX], + module, "StatusTipRole", (long) Katie::Qt::ItemDataRole::StatusTipRole)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ITEMDATAROLE_IDX], + module, "WhatsThisRole", (long) Katie::Qt::ItemDataRole::WhatsThisRole)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ITEMDATAROLE_IDX], + module, "FontRole", (long) Katie::Qt::ItemDataRole::FontRole)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ITEMDATAROLE_IDX], + module, "TextAlignmentRole", (long) Katie::Qt::ItemDataRole::TextAlignmentRole)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ITEMDATAROLE_IDX], + module, "BackgroundRole", (long) Katie::Qt::ItemDataRole::BackgroundRole)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ITEMDATAROLE_IDX], + module, "ForegroundRole", (long) Katie::Qt::ItemDataRole::ForegroundRole)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ITEMDATAROLE_IDX], + module, "CheckStateRole", (long) Katie::Qt::ItemDataRole::CheckStateRole)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ITEMDATAROLE_IDX], + module, "AccessibleTextRole", (long) Katie::Qt::ItemDataRole::AccessibleTextRole)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ITEMDATAROLE_IDX], + module, "AccessibleDescriptionRole", (long) Katie::Qt::ItemDataRole::AccessibleDescriptionRole)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ITEMDATAROLE_IDX], + module, "SizeHintRole", (long) Katie::Qt::ItemDataRole::SizeHintRole)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ITEMDATAROLE_IDX], + module, "InitialSortOrderRole", (long) Katie::Qt::ItemDataRole::InitialSortOrderRole)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ITEMDATAROLE_IDX], + module, "DisplayPropertyRole", (long) Katie::Qt::ItemDataRole::DisplayPropertyRole)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ITEMDATAROLE_IDX], + module, "DecorationPropertyRole", (long) Katie::Qt::ItemDataRole::DecorationPropertyRole)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ITEMDATAROLE_IDX], + module, "ToolTipPropertyRole", (long) Katie::Qt::ItemDataRole::ToolTipPropertyRole)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ITEMDATAROLE_IDX], + module, "StatusTipPropertyRole", (long) Katie::Qt::ItemDataRole::StatusTipPropertyRole)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ITEMDATAROLE_IDX], + module, "WhatsThisPropertyRole", (long) Katie::Qt::ItemDataRole::WhatsThisPropertyRole)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ITEMDATAROLE_IDX], + module, "UserRole", (long) Katie::Qt::ItemDataRole::UserRole)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::ItemDataRole'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_ITEMDATAROLE_IDX], + Katie_Qt_ItemDataRole_CppToPython_Katie_Qt_ItemDataRole); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_ItemDataRole_PythonToCpp_Katie_Qt_ItemDataRole, + is_Katie_Qt_ItemDataRole_PythonToCpp_Katie_Qt_ItemDataRole_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_ITEMDATAROLE_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::ItemDataRole"); + Shiboken::Conversions::registerConverterName(converter, "Qt::ItemDataRole"); + Shiboken::Conversions::registerConverterName(converter, "ItemDataRole"); + } + // End of 'ItemDataRole' enum. + + // Initialization of enum 'ItemFlag'. + SbkKtCoreTypes[SBK_KATIE_QT_ITEMFLAG_IDX] = Shiboken::Enum::createGlobalEnum(module, + "ItemFlag", + "KtCore.Katie.Qt.ItemFlag", + "Katie::Qt::ItemFlag"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_ITEMFLAG_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ITEMFLAG_IDX], + module, "NoItemFlags", (long) Katie::Qt::ItemFlag::NoItemFlags)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ITEMFLAG_IDX], + module, "ItemIsSelectable", (long) Katie::Qt::ItemFlag::ItemIsSelectable)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ITEMFLAG_IDX], + module, "ItemIsEditable", (long) Katie::Qt::ItemFlag::ItemIsEditable)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ITEMFLAG_IDX], + module, "ItemIsDragEnabled", (long) Katie::Qt::ItemFlag::ItemIsDragEnabled)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ITEMFLAG_IDX], + module, "ItemIsDropEnabled", (long) Katie::Qt::ItemFlag::ItemIsDropEnabled)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ITEMFLAG_IDX], + module, "ItemIsUserCheckable", (long) Katie::Qt::ItemFlag::ItemIsUserCheckable)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ITEMFLAG_IDX], + module, "ItemIsEnabled", (long) Katie::Qt::ItemFlag::ItemIsEnabled)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_ITEMFLAG_IDX], + module, "ItemIsTristate", (long) Katie::Qt::ItemFlag::ItemIsTristate)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::ItemFlag'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_ITEMFLAG_IDX], + Katie_Qt_ItemFlag_CppToPython_Katie_Qt_ItemFlag); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_ItemFlag_PythonToCpp_Katie_Qt_ItemFlag, + is_Katie_Qt_ItemFlag_PythonToCpp_Katie_Qt_ItemFlag_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_ITEMFLAG_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::ItemFlag"); + Shiboken::Conversions::registerConverterName(converter, "Qt::ItemFlag"); + Shiboken::Conversions::registerConverterName(converter, "ItemFlag"); + } + // End of 'ItemFlag' enum. + + // Initialization of enum 'MatchFlag'. + SbkKtCoreTypes[SBK_KATIE_QT_MATCHFLAG_IDX] = Shiboken::Enum::createGlobalEnum(module, + "MatchFlag", + "KtCore.Katie.Qt.MatchFlag", + "Katie::Qt::MatchFlag"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_MATCHFLAG_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_MATCHFLAG_IDX], + module, "MatchExactly", (long) Katie::Qt::MatchFlag::MatchExactly)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_MATCHFLAG_IDX], + module, "MatchContains", (long) Katie::Qt::MatchFlag::MatchContains)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_MATCHFLAG_IDX], + module, "MatchStartsWith", (long) Katie::Qt::MatchFlag::MatchStartsWith)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_MATCHFLAG_IDX], + module, "MatchEndsWith", (long) Katie::Qt::MatchFlag::MatchEndsWith)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_MATCHFLAG_IDX], + module, "MatchRegExp", (long) Katie::Qt::MatchFlag::MatchRegExp)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_MATCHFLAG_IDX], + module, "MatchWildcard", (long) Katie::Qt::MatchFlag::MatchWildcard)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_MATCHFLAG_IDX], + module, "MatchFixedString", (long) Katie::Qt::MatchFlag::MatchFixedString)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_MATCHFLAG_IDX], + module, "MatchCaseSensitive", (long) Katie::Qt::MatchFlag::MatchCaseSensitive)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_MATCHFLAG_IDX], + module, "MatchWrap", (long) Katie::Qt::MatchFlag::MatchWrap)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_MATCHFLAG_IDX], + module, "MatchRecursive", (long) Katie::Qt::MatchFlag::MatchRecursive)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::MatchFlag'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_MATCHFLAG_IDX], + Katie_Qt_MatchFlag_CppToPython_Katie_Qt_MatchFlag); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_MatchFlag_PythonToCpp_Katie_Qt_MatchFlag, + is_Katie_Qt_MatchFlag_PythonToCpp_Katie_Qt_MatchFlag_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_MATCHFLAG_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::MatchFlag"); + Shiboken::Conversions::registerConverterName(converter, "Qt::MatchFlag"); + Shiboken::Conversions::registerConverterName(converter, "MatchFlag"); + } + // End of 'MatchFlag' enum. + + // Initialization of enum 'WindowModality'. + SbkKtCoreTypes[SBK_KATIE_QT_WINDOWMODALITY_IDX] = Shiboken::Enum::createGlobalEnum(module, + "WindowModality", + "KtCore.Katie.Qt.WindowModality", + "Katie::Qt::WindowModality"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_WINDOWMODALITY_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWMODALITY_IDX], + module, "NonModal", (long) Katie::Qt::WindowModality::NonModal)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWMODALITY_IDX], + module, "WindowModal", (long) Katie::Qt::WindowModality::WindowModal)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWMODALITY_IDX], + module, "ApplicationModal", (long) Katie::Qt::WindowModality::ApplicationModal)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::WindowModality'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWMODALITY_IDX], + Katie_Qt_WindowModality_CppToPython_Katie_Qt_WindowModality); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_WindowModality_PythonToCpp_Katie_Qt_WindowModality, + is_Katie_Qt_WindowModality_PythonToCpp_Katie_Qt_WindowModality_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWMODALITY_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::WindowModality"); + Shiboken::Conversions::registerConverterName(converter, "Qt::WindowModality"); + Shiboken::Conversions::registerConverterName(converter, "WindowModality"); + } + // End of 'WindowModality' enum. + + // Initialization of enum 'TextInteractionFlag'. + SbkKtCoreTypes[SBK_KATIE_QT_TEXTINTERACTIONFLAG_IDX] = Shiboken::Enum::createGlobalEnum(module, + "TextInteractionFlag", + "KtCore.Katie.Qt.TextInteractionFlag", + "Katie::Qt::TextInteractionFlag"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_TEXTINTERACTIONFLAG_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TEXTINTERACTIONFLAG_IDX], + module, "NoTextInteraction", (long) Katie::Qt::TextInteractionFlag::NoTextInteraction)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TEXTINTERACTIONFLAG_IDX], + module, "TextSelectableByMouse", (long) Katie::Qt::TextInteractionFlag::TextSelectableByMouse)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TEXTINTERACTIONFLAG_IDX], + module, "TextSelectableByKeyboard", (long) Katie::Qt::TextInteractionFlag::TextSelectableByKeyboard)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TEXTINTERACTIONFLAG_IDX], + module, "LinksAccessibleByMouse", (long) Katie::Qt::TextInteractionFlag::LinksAccessibleByMouse)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TEXTINTERACTIONFLAG_IDX], + module, "LinksAccessibleByKeyboard", (long) Katie::Qt::TextInteractionFlag::LinksAccessibleByKeyboard)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TEXTINTERACTIONFLAG_IDX], + module, "TextEditable", (long) Katie::Qt::TextInteractionFlag::TextEditable)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TEXTINTERACTIONFLAG_IDX], + module, "TextEditorInteraction", (long) Katie::Qt::TextInteractionFlag::TextEditorInteraction)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TEXTINTERACTIONFLAG_IDX], + module, "TextBrowserInteraction", (long) Katie::Qt::TextInteractionFlag::TextBrowserInteraction)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::TextInteractionFlag'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_TEXTINTERACTIONFLAG_IDX], + Katie_Qt_TextInteractionFlag_CppToPython_Katie_Qt_TextInteractionFlag); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_TextInteractionFlag_PythonToCpp_Katie_Qt_TextInteractionFlag, + is_Katie_Qt_TextInteractionFlag_PythonToCpp_Katie_Qt_TextInteractionFlag_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_TEXTINTERACTIONFLAG_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::TextInteractionFlag"); + Shiboken::Conversions::registerConverterName(converter, "Qt::TextInteractionFlag"); + Shiboken::Conversions::registerConverterName(converter, "TextInteractionFlag"); + } + // End of 'TextInteractionFlag' enum. + + // Initialization of enum 'EventPriority'. + SbkKtCoreTypes[SBK_KATIE_QT_EVENTPRIORITY_IDX] = Shiboken::Enum::createGlobalEnum(module, + "EventPriority", + "KtCore.Katie.Qt.EventPriority", + "Katie::Qt::EventPriority"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_EVENTPRIORITY_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_EVENTPRIORITY_IDX], + module, "HighEventPriority", (long) Katie::Qt::EventPriority::HighEventPriority)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_EVENTPRIORITY_IDX], + module, "NormalEventPriority", (long) Katie::Qt::EventPriority::NormalEventPriority)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_EVENTPRIORITY_IDX], + module, "LowEventPriority", (long) Katie::Qt::EventPriority::LowEventPriority)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::EventPriority'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_EVENTPRIORITY_IDX], + Katie_Qt_EventPriority_CppToPython_Katie_Qt_EventPriority); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_EventPriority_PythonToCpp_Katie_Qt_EventPriority, + is_Katie_Qt_EventPriority_PythonToCpp_Katie_Qt_EventPriority_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_EVENTPRIORITY_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::EventPriority"); + Shiboken::Conversions::registerConverterName(converter, "Qt::EventPriority"); + Shiboken::Conversions::registerConverterName(converter, "EventPriority"); + } + // End of 'EventPriority' enum. + + // Initialization of enum 'SizeHint'. + SbkKtCoreTypes[SBK_KATIE_QT_SIZEHINT_IDX] = Shiboken::Enum::createGlobalEnum(module, + "SizeHint", + "KtCore.Katie.Qt.SizeHint", + "Katie::Qt::SizeHint"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_SIZEHINT_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_SIZEHINT_IDX], + module, "MinimumSize", (long) Katie::Qt::SizeHint::MinimumSize)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_SIZEHINT_IDX], + module, "PreferredSize", (long) Katie::Qt::SizeHint::PreferredSize)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_SIZEHINT_IDX], + module, "MaximumSize", (long) Katie::Qt::SizeHint::MaximumSize)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_SIZEHINT_IDX], + module, "MinimumDescent", (long) Katie::Qt::SizeHint::MinimumDescent)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_SIZEHINT_IDX], + module, "NSizeHints", (long) Katie::Qt::SizeHint::NSizeHints)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::SizeHint'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_SIZEHINT_IDX], + Katie_Qt_SizeHint_CppToPython_Katie_Qt_SizeHint); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_SizeHint_PythonToCpp_Katie_Qt_SizeHint, + is_Katie_Qt_SizeHint_PythonToCpp_Katie_Qt_SizeHint_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_SIZEHINT_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::SizeHint"); + Shiboken::Conversions::registerConverterName(converter, "Qt::SizeHint"); + Shiboken::Conversions::registerConverterName(converter, "SizeHint"); + } + // End of 'SizeHint' enum. + + // Initialization of enum 'WindowFrameSection'. + SbkKtCoreTypes[SBK_KATIE_QT_WINDOWFRAMESECTION_IDX] = Shiboken::Enum::createGlobalEnum(module, + "WindowFrameSection", + "KtCore.Katie.Qt.WindowFrameSection", + "Katie::Qt::WindowFrameSection"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_WINDOWFRAMESECTION_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWFRAMESECTION_IDX], + module, "NoSection", (long) Katie::Qt::WindowFrameSection::NoSection)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWFRAMESECTION_IDX], + module, "LeftSection", (long) Katie::Qt::WindowFrameSection::LeftSection)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWFRAMESECTION_IDX], + module, "TopLeftSection", (long) Katie::Qt::WindowFrameSection::TopLeftSection)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWFRAMESECTION_IDX], + module, "TopSection", (long) Katie::Qt::WindowFrameSection::TopSection)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWFRAMESECTION_IDX], + module, "TopRightSection", (long) Katie::Qt::WindowFrameSection::TopRightSection)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWFRAMESECTION_IDX], + module, "RightSection", (long) Katie::Qt::WindowFrameSection::RightSection)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWFRAMESECTION_IDX], + module, "BottomRightSection", (long) Katie::Qt::WindowFrameSection::BottomRightSection)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWFRAMESECTION_IDX], + module, "BottomSection", (long) Katie::Qt::WindowFrameSection::BottomSection)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWFRAMESECTION_IDX], + module, "BottomLeftSection", (long) Katie::Qt::WindowFrameSection::BottomLeftSection)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWFRAMESECTION_IDX], + module, "TitleBarArea", (long) Katie::Qt::WindowFrameSection::TitleBarArea)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::WindowFrameSection'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWFRAMESECTION_IDX], + Katie_Qt_WindowFrameSection_CppToPython_Katie_Qt_WindowFrameSection); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_WindowFrameSection_PythonToCpp_Katie_Qt_WindowFrameSection, + is_Katie_Qt_WindowFrameSection_PythonToCpp_Katie_Qt_WindowFrameSection_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_WINDOWFRAMESECTION_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::WindowFrameSection"); + Shiboken::Conversions::registerConverterName(converter, "Qt::WindowFrameSection"); + Shiboken::Conversions::registerConverterName(converter, "WindowFrameSection"); + } + // End of 'WindowFrameSection' enum. + + // Initialization of enum 'Initialization'. + SbkKtCoreTypes[SBK_KATIE_QT_INITIALIZATION_IDX] = Shiboken::Enum::createGlobalEnum(module, + "Initialization", + "KtCore.Katie.Qt.Initialization", + "Katie::Qt::Initialization"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_INITIALIZATION_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_INITIALIZATION_IDX], + module, "Uninitialized", (long) Katie::Qt::Initialization::Uninitialized)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::Initialization'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_INITIALIZATION_IDX], + Katie_Qt_Initialization_CppToPython_Katie_Qt_Initialization); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_Initialization_PythonToCpp_Katie_Qt_Initialization, + is_Katie_Qt_Initialization_PythonToCpp_Katie_Qt_Initialization_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_INITIALIZATION_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::Initialization"); + Shiboken::Conversions::registerConverterName(converter, "Qt::Initialization"); + Shiboken::Conversions::registerConverterName(converter, "Initialization"); + } + // End of 'Initialization' enum. + + // Initialization of enum 'CoordinateSystem'. + SbkKtCoreTypes[SBK_KATIE_QT_COORDINATESYSTEM_IDX] = Shiboken::Enum::createGlobalEnum(module, + "CoordinateSystem", + "KtCore.Katie.Qt.CoordinateSystem", + "Katie::Qt::CoordinateSystem"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_COORDINATESYSTEM_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_COORDINATESYSTEM_IDX], + module, "DeviceCoordinates", (long) Katie::Qt::CoordinateSystem::DeviceCoordinates)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_COORDINATESYSTEM_IDX], + module, "LogicalCoordinates", (long) Katie::Qt::CoordinateSystem::LogicalCoordinates)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::CoordinateSystem'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_COORDINATESYSTEM_IDX], + Katie_Qt_CoordinateSystem_CppToPython_Katie_Qt_CoordinateSystem); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_CoordinateSystem_PythonToCpp_Katie_Qt_CoordinateSystem, + is_Katie_Qt_CoordinateSystem_PythonToCpp_Katie_Qt_CoordinateSystem_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_COORDINATESYSTEM_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::CoordinateSystem"); + Shiboken::Conversions::registerConverterName(converter, "Qt::CoordinateSystem"); + Shiboken::Conversions::registerConverterName(converter, "CoordinateSystem"); + } + // End of 'CoordinateSystem' enum. + + // Initialization of enum 'TouchPointState'. + SbkKtCoreTypes[SBK_KATIE_QT_TOUCHPOINTSTATE_IDX] = Shiboken::Enum::createGlobalEnum(module, + "TouchPointState", + "KtCore.Katie.Qt.TouchPointState", + "Katie::Qt::TouchPointState"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_TOUCHPOINTSTATE_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TOUCHPOINTSTATE_IDX], + module, "TouchPointPressed", (long) Katie::Qt::TouchPointState::TouchPointPressed)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TOUCHPOINTSTATE_IDX], + module, "TouchPointMoved", (long) Katie::Qt::TouchPointState::TouchPointMoved)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TOUCHPOINTSTATE_IDX], + module, "TouchPointStationary", (long) Katie::Qt::TouchPointState::TouchPointStationary)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TOUCHPOINTSTATE_IDX], + module, "TouchPointReleased", (long) Katie::Qt::TouchPointState::TouchPointReleased)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TOUCHPOINTSTATE_IDX], + module, "TouchPointStateMask", (long) Katie::Qt::TouchPointState::TouchPointStateMask)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_TOUCHPOINTSTATE_IDX], + module, "TouchPointPrimary", (long) Katie::Qt::TouchPointState::TouchPointPrimary)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::TouchPointState'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_TOUCHPOINTSTATE_IDX], + Katie_Qt_TouchPointState_CppToPython_Katie_Qt_TouchPointState); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_TouchPointState_PythonToCpp_Katie_Qt_TouchPointState, + is_Katie_Qt_TouchPointState_PythonToCpp_Katie_Qt_TouchPointState_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_TOUCHPOINTSTATE_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::TouchPointState"); + Shiboken::Conversions::registerConverterName(converter, "Qt::TouchPointState"); + Shiboken::Conversions::registerConverterName(converter, "TouchPointState"); + } + // End of 'TouchPointState' enum. + + // Initialization of enum 'GestureState'. + SbkKtCoreTypes[SBK_KATIE_QT_GESTURESTATE_IDX] = Shiboken::Enum::createGlobalEnum(module, + "GestureState", + "KtCore.Katie.Qt.GestureState", + "Katie::Qt::GestureState"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_GESTURESTATE_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_GESTURESTATE_IDX], + module, "NoGesture", (long) Katie::Qt::GestureState::NoGesture)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_GESTURESTATE_IDX], + module, "GestureStarted", (long) Katie::Qt::GestureState::GestureStarted)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_GESTURESTATE_IDX], + module, "GestureUpdated", (long) Katie::Qt::GestureState::GestureUpdated)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_GESTURESTATE_IDX], + module, "GestureFinished", (long) Katie::Qt::GestureState::GestureFinished)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_GESTURESTATE_IDX], + module, "GestureCanceled", (long) Katie::Qt::GestureState::GestureCanceled)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::GestureState'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_GESTURESTATE_IDX], + Katie_Qt_GestureState_CppToPython_Katie_Qt_GestureState); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_GestureState_PythonToCpp_Katie_Qt_GestureState, + is_Katie_Qt_GestureState_PythonToCpp_Katie_Qt_GestureState_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_GESTURESTATE_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::GestureState"); + Shiboken::Conversions::registerConverterName(converter, "Qt::GestureState"); + Shiboken::Conversions::registerConverterName(converter, "GestureState"); + } + // End of 'GestureState' enum. + + // Initialization of enum 'GestureType'. + SbkKtCoreTypes[SBK_KATIE_QT_GESTURETYPE_IDX] = Shiboken::Enum::createGlobalEnum(module, + "GestureType", + "KtCore.Katie.Qt.GestureType", + "Katie::Qt::GestureType"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_GESTURETYPE_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_GESTURETYPE_IDX], + module, "TapGesture", (long) Katie::Qt::GestureType::TapGesture)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_GESTURETYPE_IDX], + module, "TapAndHoldGesture", (long) Katie::Qt::GestureType::TapAndHoldGesture)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_GESTURETYPE_IDX], + module, "PanGesture", (long) Katie::Qt::GestureType::PanGesture)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_GESTURETYPE_IDX], + module, "PinchGesture", (long) Katie::Qt::GestureType::PinchGesture)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_GESTURETYPE_IDX], + module, "SwipeGesture", (long) Katie::Qt::GestureType::SwipeGesture)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_GESTURETYPE_IDX], + module, "CustomGesture", (long) Katie::Qt::GestureType::CustomGesture)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_GESTURETYPE_IDX], + module, "LastGestureType", (long) Katie::Qt::GestureType::LastGestureType)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::GestureType'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_GESTURETYPE_IDX], + Katie_Qt_GestureType_CppToPython_Katie_Qt_GestureType); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_GestureType_PythonToCpp_Katie_Qt_GestureType, + is_Katie_Qt_GestureType_PythonToCpp_Katie_Qt_GestureType_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_GESTURETYPE_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::GestureType"); + Shiboken::Conversions::registerConverterName(converter, "Qt::GestureType"); + Shiboken::Conversions::registerConverterName(converter, "GestureType"); + } + // End of 'GestureType' enum. + + // Initialization of enum 'GestureFlag'. + SbkKtCoreTypes[SBK_KATIE_QT_GESTUREFLAG_IDX] = Shiboken::Enum::createGlobalEnum(module, + "GestureFlag", + "KtCore.Katie.Qt.GestureFlag", + "Katie::Qt::GestureFlag"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_GESTUREFLAG_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_GESTUREFLAG_IDX], + module, "DontStartGestureOnChildren", (long) Katie::Qt::GestureFlag::DontStartGestureOnChildren)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_GESTUREFLAG_IDX], + module, "ReceivePartialGestures", (long) Katie::Qt::GestureFlag::ReceivePartialGestures)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_GESTUREFLAG_IDX], + module, "IgnoredGesturesPropagateToParent", (long) Katie::Qt::GestureFlag::IgnoredGesturesPropagateToParent)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::GestureFlag'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_GESTUREFLAG_IDX], + Katie_Qt_GestureFlag_CppToPython_Katie_Qt_GestureFlag); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_GestureFlag_PythonToCpp_Katie_Qt_GestureFlag, + is_Katie_Qt_GestureFlag_PythonToCpp_Katie_Qt_GestureFlag_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_GESTUREFLAG_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::GestureFlag"); + Shiboken::Conversions::registerConverterName(converter, "Qt::GestureFlag"); + Shiboken::Conversions::registerConverterName(converter, "GestureFlag"); + } + // End of 'GestureFlag' enum. + + // Initialization of enum 'NavigationMode'. + SbkKtCoreTypes[SBK_KATIE_QT_NAVIGATIONMODE_IDX] = Shiboken::Enum::createGlobalEnum(module, + "NavigationMode", + "KtCore.Katie.Qt.NavigationMode", + "Katie::Qt::NavigationMode"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_NAVIGATIONMODE_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_NAVIGATIONMODE_IDX], + module, "NavigationModeNone", (long) Katie::Qt::NavigationMode::NavigationModeNone)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_NAVIGATIONMODE_IDX], + module, "NavigationModeKeypadTabOrder", (long) Katie::Qt::NavigationMode::NavigationModeKeypadTabOrder)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_NAVIGATIONMODE_IDX], + module, "NavigationModeKeypadDirectional", (long) Katie::Qt::NavigationMode::NavigationModeKeypadDirectional)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_NAVIGATIONMODE_IDX], + module, "NavigationModeCursorAuto", (long) Katie::Qt::NavigationMode::NavigationModeCursorAuto)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_NAVIGATIONMODE_IDX], + module, "NavigationModeCursorForceVisible", (long) Katie::Qt::NavigationMode::NavigationModeCursorForceVisible)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::NavigationMode'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_NAVIGATIONMODE_IDX], + Katie_Qt_NavigationMode_CppToPython_Katie_Qt_NavigationMode); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_NavigationMode_PythonToCpp_Katie_Qt_NavigationMode, + is_Katie_Qt_NavigationMode_PythonToCpp_Katie_Qt_NavigationMode_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_NAVIGATIONMODE_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::NavigationMode"); + Shiboken::Conversions::registerConverterName(converter, "Qt::NavigationMode"); + Shiboken::Conversions::registerConverterName(converter, "NavigationMode"); + } + // End of 'NavigationMode' enum. + + // Initialization of enum 'CursorMoveStyle'. + SbkKtCoreTypes[SBK_KATIE_QT_CURSORMOVESTYLE_IDX] = Shiboken::Enum::createGlobalEnum(module, + "CursorMoveStyle", + "KtCore.Katie.Qt.CursorMoveStyle", + "Katie::Qt::CursorMoveStyle"); + if (!SbkKtCoreTypes[SBK_KATIE_QT_CURSORMOVESTYLE_IDX]) + return SBK_MODULE_INIT_ERROR; + + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CURSORMOVESTYLE_IDX], + module, "LogicalMoveStyle", (long) Katie::Qt::CursorMoveStyle::LogicalMoveStyle)) + return SBK_MODULE_INIT_ERROR; + if (!Shiboken::Enum::createGlobalEnumItem(SbkKtCoreTypes[SBK_KATIE_QT_CURSORMOVESTYLE_IDX], + module, "VisualMoveStyle", (long) Katie::Qt::CursorMoveStyle::VisualMoveStyle)) + return SBK_MODULE_INIT_ERROR; + // Register converter for enum 'Katie::Qt::CursorMoveStyle'. + { + SbkConverter* converter = Shiboken::Conversions::createConverter(SbkKtCoreTypes[SBK_KATIE_QT_CURSORMOVESTYLE_IDX], + Katie_Qt_CursorMoveStyle_CppToPython_Katie_Qt_CursorMoveStyle); + Shiboken::Conversions::addPythonToCppValueConversion(converter, + Katie_Qt_CursorMoveStyle_PythonToCpp_Katie_Qt_CursorMoveStyle, + is_Katie_Qt_CursorMoveStyle_PythonToCpp_Katie_Qt_CursorMoveStyle_Convertible); + Shiboken::Enum::setTypeConverter(SbkKtCoreTypes[SBK_KATIE_QT_CURSORMOVESTYLE_IDX], converter); + Shiboken::Conversions::registerConverterName(converter, "Katie::Qt::CursorMoveStyle"); + Shiboken::Conversions::registerConverterName(converter, "Qt::CursorMoveStyle"); + Shiboken::Conversions::registerConverterName(converter, "CursorMoveStyle"); + } + // End of 'CursorMoveStyle' enum. + + // Register primitive types converters. + Shiboken::Conversions::registerConverterName(Shiboken::Conversions::PrimitiveTypeConverter(), "qint64"); + Shiboken::Conversions::registerConverterName(Shiboken::Conversions::PrimitiveTypeConverter(), "uchar"); + Shiboken::Conversions::registerConverterName(Shiboken::Conversions::PrimitiveTypeConverter(), "uint"); + + Shiboken::Module::registerTypes(module, SbkKtCoreTypes); + Shiboken::Module::registerTypeConverters(module, SbkKtCoreTypeConverters); + + if (PyErr_Occurred()) { + PyErr_Print(); + Py_FatalError("can't initialize module KtCore"); + } + FinishSignatureInitialization(module, KtCore_SignatureStrings); + +SBK_MODULE_INIT_FUNCTION_END diff --git a/bindings/KtCore/ktcore_python.h b/bindings/KtCore/ktcore_python.h new file mode 100644 index 000000000..0ab757a1d --- /dev/null +++ b/bindings/KtCore/ktcore_python.h @@ -0,0 +1,267 @@ +/**************************************************************************** +** +** Copyright (C) 2015 The Qt Company Ltd. +** Contact: http://www.qt.io/licensing/ +** +** This file is part of the FOO module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of The Qt Company Ltd nor the names of its +** contributors may be used to endorse or promote products derived +** from this software without specific prior written permission. +** +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + + +#ifndef SBK_KTCORE_PYTHON_H +#define SBK_KTCORE_PYTHON_H + +#include +#include +// Binded library includes +#include +#include +#include +#include +#include +#include +#include +// Conversion Includes - Primitive Types + +// Conversion Includes - Container Types +#include +#include +#include +#include + +// Type indices +enum : int { + SBK_KATIE_QBYTEARRAY_IDX = 0, + SBK_KATIE_QCHAR_IDX = 1, + SBK_KATIE_QCHAR_SPECIALCHARACTER_IDX = 7, + SBK_KATIE_QCHAR_CATEGORY_IDX = 2, + SBK_KATIE_QCHAR_DIRECTION_IDX = 5, + SBK_KATIE_QCHAR_DECOMPOSITION_IDX = 4, + SBK_KATIE_QCHAR_JOINING_IDX = 6, + SBK_KATIE_QCHAR_COMBININGCLASS_IDX = 3, + SBK_KATIE_QCHAR_UNICODEVERSION_IDX = 8, + SBK_KATIE_QCOREAPPLICATION_IDX = 9, + SBK_KATIE_QLATIN1CHAR_IDX = 10, + SBK_KATIE_QLATIN1STRING_IDX = 11, + SBK_KATIE_QOBJECT_IDX = 12, + SBK_KATIE_QSTRING_IDX = 13, + SBK_KATIE_QSTRING_SECTIONFLAG_IDX = 15, + SBK_KATIE_QSTRING_SPLITBEHAVIOR_IDX = 16, + SBK_KATIE_QSTRING_NORMALIZATIONFORM_IDX = 14, + SBK_KATIE_QTMSGTYPE_IDX = 87, + SBK_KATIE_QT_GLOBALCOLOR_IDX = 47, + SBK_KATIE_QT_KEYBOARDMODIFIER_IDX = 54, + SBK_KATIE_QT_MODIFIER_IDX = 58, + SBK_KATIE_QT_MOUSEBUTTON_IDX = 59, + SBK_KATIE_QT_ORIENTATION_IDX = 61, + SBK_KATIE_QT_FOCUSPOLICY_IDX = 42, + SBK_KATIE_QT_SORTORDER_IDX = 69, + SBK_KATIE_QT_TILERULE_IDX = 74, + SBK_KATIE_QT_ALIGNMENTFLAG_IDX = 17, + SBK_KATIE_QT_TEXTFLAG_IDX = 71, + SBK_KATIE_QT_TEXTELIDEMODE_IDX = 70, + SBK_KATIE_QT_WINDOWTYPE_IDX = 86, + SBK_KATIE_QT_WINDOWSTATE_IDX = 85, + SBK_KATIE_QT_WIDGETATTRIBUTE_IDX = 82, + SBK_KATIE_QT_APPLICATIONATTRIBUTE_IDX = 20, + SBK_KATIE_QT_IMAGECONVERSIONFLAG_IDX = 48, + SBK_KATIE_QT_BGMODE_IDX = 24, + SBK_KATIE_QT_KEY_IDX = 53, + SBK_KATIE_QT_ARROWTYPE_IDX = 21, + SBK_KATIE_QT_PENSTYLE_IDX = 64, + SBK_KATIE_QT_PENCAPSTYLE_IDX = 62, + SBK_KATIE_QT_PENJOINSTYLE_IDX = 63, + SBK_KATIE_QT_BRUSHSTYLE_IDX = 25, + SBK_KATIE_QT_SIZEMODE_IDX = 68, + SBK_KATIE_QT_UIEFFECT_IDX = 81, + SBK_KATIE_QT_CURSORSHAPE_IDX = 34, + SBK_KATIE_QT_TEXTFORMAT_IDX = 72, + SBK_KATIE_QT_ASPECTRATIOMODE_IDX = 22, + SBK_KATIE_QT_ANCHORATTRIBUTE_IDX = 18, + SBK_KATIE_QT_DOCKWIDGETAREA_IDX = 37, + SBK_KATIE_QT_DOCKWIDGETAREASIZES_IDX = 38, + SBK_KATIE_QT_TOOLBARAREA_IDX = 76, + SBK_KATIE_QT_TOOLBARAREASIZES_IDX = 77, + SBK_KATIE_QT_DATEFORMAT_IDX = 35, + SBK_KATIE_QT_TIMESPEC_IDX = 75, + SBK_KATIE_QT_DAYOFWEEK_IDX = 36, + SBK_KATIE_QT_SCROLLBARPOLICY_IDX = 65, + SBK_KATIE_QT_CASESENSITIVITY_IDX = 26, + SBK_KATIE_QT_CORNER_IDX = 32, + SBK_KATIE_QT_CONNECTIONTYPE_IDX = 29, + SBK_KATIE_QT_SHORTCUTCONTEXT_IDX = 66, + SBK_KATIE_QT_FILLRULE_IDX = 41, + SBK_KATIE_QT_MASKMODE_IDX = 56, + SBK_KATIE_QT_CLIPOPERATION_IDX = 28, + SBK_KATIE_QT_ITEMSELECTIONMODE_IDX = 52, + SBK_KATIE_QT_TRANSFORMATIONMODE_IDX = 80, + SBK_KATIE_QT_AXIS_IDX = 23, + SBK_KATIE_QT_FOCUSREASON_IDX = 43, + SBK_KATIE_QT_CONTEXTMENUPOLICY_IDX = 30, + SBK_KATIE_QT_TOOLBUTTONSTYLE_IDX = 78, + SBK_KATIE_QT_LAYOUTDIRECTION_IDX = 55, + SBK_KATIE_QT_ANCHORPOINT_IDX = 19, + SBK_KATIE_QT_DROPACTION_IDX = 39, + SBK_KATIE_QT_CHECKSTATE_IDX = 27, + SBK_KATIE_QT_ITEMDATAROLE_IDX = 50, + SBK_KATIE_QT_ITEMFLAG_IDX = 51, + SBK_KATIE_QT_MATCHFLAG_IDX = 57, + SBK_KATIE_QT_WINDOWMODALITY_IDX = 84, + SBK_KATIE_QT_TEXTINTERACTIONFLAG_IDX = 73, + SBK_KATIE_QT_EVENTPRIORITY_IDX = 40, + SBK_KATIE_QT_SIZEHINT_IDX = 67, + SBK_KATIE_QT_WINDOWFRAMESECTION_IDX = 83, + SBK_KATIE_QT_INITIALIZATION_IDX = 49, + SBK_KATIE_QT_COORDINATESYSTEM_IDX = 31, + SBK_KATIE_QT_TOUCHPOINTSTATE_IDX = 79, + SBK_KATIE_QT_GESTURESTATE_IDX = 45, + SBK_KATIE_QT_GESTURETYPE_IDX = 46, + SBK_KATIE_QT_GESTUREFLAG_IDX = 44, + SBK_KATIE_QT_NAVIGATIONMODE_IDX = 60, + SBK_KATIE_QT_CURSORMOVESTYLE_IDX = 33, + SBK_KtCore_IDX_COUNT = 88 +}; +// This variable stores all Python types exported by this module. +extern PyTypeObject** SbkKtCoreTypes; + +// This variable stores the Python module object exported by this module. +extern PyObject* SbkKtCoreModuleObject; + +// This variable stores all type converters exported by this module. +extern SbkConverter** SbkKtCoreTypeConverters; + +// Converter indices +enum : int { + SBK_KtCore_CONVERTERS_IDX_COUNT = 1 +}; +// Macros for type check + +namespace Shiboken +{ + +// PyType functions, to get the PyObjectType for a type T +template<> inline PyTypeObject* SbkType< ::Katie::QtMsgType >() { return SbkKtCoreTypes[SBK_KATIE_QTMSGTYPE_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::GlobalColor >() { return SbkKtCoreTypes[SBK_KATIE_QT_GLOBALCOLOR_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::KeyboardModifier >() { return SbkKtCoreTypes[SBK_KATIE_QT_KEYBOARDMODIFIER_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::Modifier >() { return SbkKtCoreTypes[SBK_KATIE_QT_MODIFIER_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::MouseButton >() { return SbkKtCoreTypes[SBK_KATIE_QT_MOUSEBUTTON_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::Orientation >() { return SbkKtCoreTypes[SBK_KATIE_QT_ORIENTATION_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::FocusPolicy >() { return SbkKtCoreTypes[SBK_KATIE_QT_FOCUSPOLICY_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::SortOrder >() { return SbkKtCoreTypes[SBK_KATIE_QT_SORTORDER_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::TileRule >() { return SbkKtCoreTypes[SBK_KATIE_QT_TILERULE_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::AlignmentFlag >() { return SbkKtCoreTypes[SBK_KATIE_QT_ALIGNMENTFLAG_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::TextFlag >() { return SbkKtCoreTypes[SBK_KATIE_QT_TEXTFLAG_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::TextElideMode >() { return SbkKtCoreTypes[SBK_KATIE_QT_TEXTELIDEMODE_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::WindowType >() { return SbkKtCoreTypes[SBK_KATIE_QT_WINDOWTYPE_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::WindowState >() { return SbkKtCoreTypes[SBK_KATIE_QT_WINDOWSTATE_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::WidgetAttribute >() { return SbkKtCoreTypes[SBK_KATIE_QT_WIDGETATTRIBUTE_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::ApplicationAttribute >() { return SbkKtCoreTypes[SBK_KATIE_QT_APPLICATIONATTRIBUTE_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::ImageConversionFlag >() { return SbkKtCoreTypes[SBK_KATIE_QT_IMAGECONVERSIONFLAG_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::BGMode >() { return SbkKtCoreTypes[SBK_KATIE_QT_BGMODE_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::Key >() { return SbkKtCoreTypes[SBK_KATIE_QT_KEY_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::ArrowType >() { return SbkKtCoreTypes[SBK_KATIE_QT_ARROWTYPE_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::PenStyle >() { return SbkKtCoreTypes[SBK_KATIE_QT_PENSTYLE_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::PenCapStyle >() { return SbkKtCoreTypes[SBK_KATIE_QT_PENCAPSTYLE_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::PenJoinStyle >() { return SbkKtCoreTypes[SBK_KATIE_QT_PENJOINSTYLE_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::BrushStyle >() { return SbkKtCoreTypes[SBK_KATIE_QT_BRUSHSTYLE_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::SizeMode >() { return SbkKtCoreTypes[SBK_KATIE_QT_SIZEMODE_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::UIEffect >() { return SbkKtCoreTypes[SBK_KATIE_QT_UIEFFECT_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::CursorShape >() { return SbkKtCoreTypes[SBK_KATIE_QT_CURSORSHAPE_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::TextFormat >() { return SbkKtCoreTypes[SBK_KATIE_QT_TEXTFORMAT_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::AspectRatioMode >() { return SbkKtCoreTypes[SBK_KATIE_QT_ASPECTRATIOMODE_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::AnchorAttribute >() { return SbkKtCoreTypes[SBK_KATIE_QT_ANCHORATTRIBUTE_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::DockWidgetArea >() { return SbkKtCoreTypes[SBK_KATIE_QT_DOCKWIDGETAREA_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::DockWidgetAreaSizes >() { return SbkKtCoreTypes[SBK_KATIE_QT_DOCKWIDGETAREASIZES_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::ToolBarArea >() { return SbkKtCoreTypes[SBK_KATIE_QT_TOOLBARAREA_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::ToolBarAreaSizes >() { return SbkKtCoreTypes[SBK_KATIE_QT_TOOLBARAREASIZES_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::DateFormat >() { return SbkKtCoreTypes[SBK_KATIE_QT_DATEFORMAT_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::TimeSpec >() { return SbkKtCoreTypes[SBK_KATIE_QT_TIMESPEC_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::DayOfWeek >() { return SbkKtCoreTypes[SBK_KATIE_QT_DAYOFWEEK_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::ScrollBarPolicy >() { return SbkKtCoreTypes[SBK_KATIE_QT_SCROLLBARPOLICY_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::CaseSensitivity >() { return SbkKtCoreTypes[SBK_KATIE_QT_CASESENSITIVITY_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::Corner >() { return SbkKtCoreTypes[SBK_KATIE_QT_CORNER_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::ConnectionType >() { return SbkKtCoreTypes[SBK_KATIE_QT_CONNECTIONTYPE_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::ShortcutContext >() { return SbkKtCoreTypes[SBK_KATIE_QT_SHORTCUTCONTEXT_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::FillRule >() { return SbkKtCoreTypes[SBK_KATIE_QT_FILLRULE_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::MaskMode >() { return SbkKtCoreTypes[SBK_KATIE_QT_MASKMODE_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::ClipOperation >() { return SbkKtCoreTypes[SBK_KATIE_QT_CLIPOPERATION_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::ItemSelectionMode >() { return SbkKtCoreTypes[SBK_KATIE_QT_ITEMSELECTIONMODE_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::TransformationMode >() { return SbkKtCoreTypes[SBK_KATIE_QT_TRANSFORMATIONMODE_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::Axis >() { return SbkKtCoreTypes[SBK_KATIE_QT_AXIS_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::FocusReason >() { return SbkKtCoreTypes[SBK_KATIE_QT_FOCUSREASON_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::ContextMenuPolicy >() { return SbkKtCoreTypes[SBK_KATIE_QT_CONTEXTMENUPOLICY_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::ToolButtonStyle >() { return SbkKtCoreTypes[SBK_KATIE_QT_TOOLBUTTONSTYLE_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::LayoutDirection >() { return SbkKtCoreTypes[SBK_KATIE_QT_LAYOUTDIRECTION_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::AnchorPoint >() { return SbkKtCoreTypes[SBK_KATIE_QT_ANCHORPOINT_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::DropAction >() { return SbkKtCoreTypes[SBK_KATIE_QT_DROPACTION_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::CheckState >() { return SbkKtCoreTypes[SBK_KATIE_QT_CHECKSTATE_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::ItemDataRole >() { return SbkKtCoreTypes[SBK_KATIE_QT_ITEMDATAROLE_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::ItemFlag >() { return SbkKtCoreTypes[SBK_KATIE_QT_ITEMFLAG_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::MatchFlag >() { return SbkKtCoreTypes[SBK_KATIE_QT_MATCHFLAG_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::WindowModality >() { return SbkKtCoreTypes[SBK_KATIE_QT_WINDOWMODALITY_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::TextInteractionFlag >() { return SbkKtCoreTypes[SBK_KATIE_QT_TEXTINTERACTIONFLAG_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::EventPriority >() { return SbkKtCoreTypes[SBK_KATIE_QT_EVENTPRIORITY_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::SizeHint >() { return SbkKtCoreTypes[SBK_KATIE_QT_SIZEHINT_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::WindowFrameSection >() { return SbkKtCoreTypes[SBK_KATIE_QT_WINDOWFRAMESECTION_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::Initialization >() { return SbkKtCoreTypes[SBK_KATIE_QT_INITIALIZATION_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::CoordinateSystem >() { return SbkKtCoreTypes[SBK_KATIE_QT_COORDINATESYSTEM_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::TouchPointState >() { return SbkKtCoreTypes[SBK_KATIE_QT_TOUCHPOINTSTATE_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::GestureState >() { return SbkKtCoreTypes[SBK_KATIE_QT_GESTURESTATE_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::GestureType >() { return SbkKtCoreTypes[SBK_KATIE_QT_GESTURETYPE_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::GestureFlag >() { return SbkKtCoreTypes[SBK_KATIE_QT_GESTUREFLAG_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::NavigationMode >() { return SbkKtCoreTypes[SBK_KATIE_QT_NAVIGATIONMODE_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::Qt::CursorMoveStyle >() { return SbkKtCoreTypes[SBK_KATIE_QT_CURSORMOVESTYLE_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::QByteArray >() { return reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QBYTEARRAY_IDX]); } +template<> inline PyTypeObject* SbkType< ::Katie::QChar::SpecialCharacter >() { return SbkKtCoreTypes[SBK_KATIE_QCHAR_SPECIALCHARACTER_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::QChar::Category >() { return SbkKtCoreTypes[SBK_KATIE_QCHAR_CATEGORY_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::QChar::Direction >() { return SbkKtCoreTypes[SBK_KATIE_QCHAR_DIRECTION_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::QChar::Decomposition >() { return SbkKtCoreTypes[SBK_KATIE_QCHAR_DECOMPOSITION_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::QChar::Joining >() { return SbkKtCoreTypes[SBK_KATIE_QCHAR_JOINING_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::QChar::CombiningClass >() { return SbkKtCoreTypes[SBK_KATIE_QCHAR_COMBININGCLASS_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::QChar::UnicodeVersion >() { return SbkKtCoreTypes[SBK_KATIE_QCHAR_UNICODEVERSION_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::QChar >() { return reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCHAR_IDX]); } +template<> inline PyTypeObject* SbkType< ::Katie::QCoreApplication >() { return reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QCOREAPPLICATION_IDX]); } +template<> inline PyTypeObject* SbkType< ::Katie::QLatin1Char >() { return reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QLATIN1CHAR_IDX]); } +template<> inline PyTypeObject* SbkType< ::Katie::QLatin1String >() { return reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QLATIN1STRING_IDX]); } +template<> inline PyTypeObject* SbkType< ::Katie::QObject >() { return reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QOBJECT_IDX]); } +template<> inline PyTypeObject* SbkType< ::Katie::QString::SectionFlag >() { return SbkKtCoreTypes[SBK_KATIE_QSTRING_SECTIONFLAG_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::QString::SplitBehavior >() { return SbkKtCoreTypes[SBK_KATIE_QSTRING_SPLITBEHAVIOR_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::QString::NormalizationForm >() { return SbkKtCoreTypes[SBK_KATIE_QSTRING_NORMALIZATIONFORM_IDX]; } +template<> inline PyTypeObject* SbkType< ::Katie::QString >() { return reinterpret_cast(SbkKtCoreTypes[SBK_KATIE_QSTRING_IDX]); } + +} // namespace Shiboken + +#endif // SBK_KTCORE_PYTHON_H + diff --git a/bindings/KtCore_global.hpp b/bindings/KtCore_global.hpp new file mode 100644 index 000000000..d2dd02de9 --- /dev/null +++ b/bindings/KtCore_global.hpp @@ -0,0 +1,8 @@ +#ifndef PYKTCORE_GLOBAL_H +#define PYKTCORE_GLOBAL_H + +#include + +#include + +#endif // PYKTCORE_GLOBAL_H diff --git a/bindings/KtGui.i b/bindings/KtGui.i deleted file mode 100644 index b82edcabd..000000000 --- a/bindings/KtGui.i +++ /dev/null @@ -1,68 +0,0 @@ -%module KtGui - -%include "tricks.i" -// for reference to Core base classes -%include "KtCore.i" - -%include "gui/qfontinfo.i" -%include "gui/qfontmetrics.i" -%include "gui/qwidget.i" - -%{ -#include "QtGui/QApplication" -#include "QtGui/QPaintDevice" -#include "QtGui/QMainWindow" -#include "QtGui/QMatrix" -#include "QtGui/QTransform" -#include "QtGui/QTextFormat" -#include "QtGui/QTextLength" - -QT_USE_NAMESPACE -%} - -// temporary implementations for testing purposes -class QApplication : public QCoreApplication { -public: - QApplication(int argc, char *argv[]); - ~QApplication(); - - static int exec(); -}; - -class QPaintDevice { -public: - virtual ~QPaintDevice(); -protected: - QPaintDevice(); -}; - -class QMainWindow : public QWidget { -public: - QMainWindow(QWidget *parent = Q_NULLPTR, Qt::WindowFlags flags = 0); - ~QMainWindow(); -}; - -// stub implementations for QVariant testing -class QMatrix { -public: - QMatrix(); - ~QMatrix(); -}; - -class QTransform { -public: - QTransform(); - ~QTransform(); -}; - -class QTextFormat { -public: - QTextFormat(); - ~QTextFormat(); -}; - -class QTextLength { -public: - QTextLength(); - ~QTextLength(); -}; diff --git a/bindings/NOTE b/bindings/NOTE deleted file mode 100644 index 1eacec705..000000000 --- a/bindings/NOTE +++ /dev/null @@ -1,2 +0,0 @@ - - container iterators not implemented - - reference classes not implemented (e.g. QStringRef) diff --git a/bindings/TODO b/bindings/TODO deleted file mode 100644 index ad009dc01..000000000 --- a/bindings/TODO +++ /dev/null @@ -1,5 +0,0 @@ - - QObject is probably not working as intended - - QVariant is almost not working because it's template and function magic - - QList, QSet and QVector template for types that are not implemented yet - - properties, slots, signals, etc. - - QCoreApplication/QApplication with argc/argv crash? \ No newline at end of file diff --git a/bindings/core/qbytearray.i b/bindings/core/qbytearray.i deleted file mode 100644 index 9da8dc38c..000000000 --- a/bindings/core/qbytearray.i +++ /dev/null @@ -1,232 +0,0 @@ -%{ -#include "QtCore/qbytearray.h" -QT_USE_NAMESPACE -%} - -char *qstrdup(const char *); - -uint qstrlen(const char *str); -uint qstrnlen(const char *str, uint maxlen); - -char *qstrcpy(char *dst, const char *src); -char *qstrncpy(char *dst, const char *src, uint len); - -int qstrcmp(const char *str1, const char *str2); -int qstrcmp(const QByteArray &str1, const QByteArray &str2); -int qstrcmp(const QByteArray &str1, const char *str2); -static int qstrcmp(const char *str1, const QByteArray &str2); -int qstrncmp(const char *str1, const char *str2, uint len); -int qstricmp(const char *, const char *); -int qstrnicmp(const char *, const char *, uint len); - -// implemented in qvsnprintf.cpp -int qvsnprintf(char *str, size_t n, const char *fmt, va_list ap); -int qsnprintf(char *str, size_t n, const char *fmt, ...); - - -// qChecksum: Internet checksum -quint16 qChecksum(const char *s, uint len); - -class QByteArray -{ -public: - QByteArray(); - QByteArray(const char *); - QByteArray(const char *, int size); - QByteArray(int size, char c); - QByteArray(int size, Qt::Initialization); - QByteArray(const QByteArray &); - ~QByteArray(); - - QByteArray &operator=(const QByteArray &); - QByteArray &operator=(const char *str); -#ifdef Q_COMPILER_RVALUE_REFS - QByteArray &operator=(QByteArray &&other); -#endif - - void swap(QByteArray &other); - - int size() const; - bool isEmpty() const; - void resize(int size); - - QByteArray &fill(char c, int size = -1); - - int capacity() const; - void reserve(int size); - void squeeze(); - -#ifndef QT_NO_CAST_FROM_BYTEARRAY - operator const char *() const; -#endif - char *data(); - const char *data() const; - const char *constData() const; - void detach(); - bool isDetached() const; - bool isSharedWith(const QByteArray &other) const; - void clear(); - - char at(int i) const; - char operator[](int i) const; - char operator[](uint i) const; - QByteRef operator[](int i); - QByteRef operator[](uint i); - - int indexOf(char c, int from = 0) const; - int indexOf(const char *c, const int from = 0) const; - int indexOf(const QByteArray &a, const int from = 0) const; - int lastIndexOf(char c, const int from = -1) const; - int lastIndexOf(const char *c, const int from = -1) const; - int lastIndexOf(const QByteArray &a, const int from = -1) const; - - bool contains(char c) const; - bool contains(const char *a) const; - bool contains(const QByteArray &a) const; - int count(char c) const; - int count(const char *a) const; - int count(const QByteArray &a) const; - - QByteArray left(int len) const; - QByteArray right(int len) const; - QByteArray mid(int index, int len = -1) const; - - bool startsWith(const QByteArray &a) const; - bool startsWith(char c) const; - bool startsWith(const char *c) const; - - bool endsWith(const QByteArray &a) const; - bool endsWith(char c) const; - bool endsWith(const char *c) const; - - void truncate(int pos); - void chop(int n); - - QByteArray toLower() const; - QByteArray toUpper() const; - - QByteArray trimmed() const; - QByteArray simplified() const; - QByteArray leftJustified(int width, char fill = ' ', bool truncate = false) const; - QByteArray rightJustified(int width, char fill = ' ', bool truncate = false) const; - - - QByteArray &prepend(char c); - QByteArray &prepend(const char *s); - QByteArray &prepend(const char *s, int len); - QByteArray &prepend(const QByteArray &a); - QByteArray &append(char c); - QByteArray &append(const char *s); - QByteArray &append(const char *s, int len); - QByteArray &append(const QByteArray &a); - QByteArray &insert(int i, char c); - QByteArray &insert(int i, const char *s); - QByteArray &insert(int i, const char *s, int len); - QByteArray &insert(int i, const QByteArray &a); - QByteArray &remove(int index, int len); - QByteArray &replace(int index, int len, const char *s); - QByteArray &replace(int index, int len, const char *s, int alen); - QByteArray &replace(int index, int len, const QByteArray &s); - QByteArray &replace(char before, const char *after); - QByteArray &replace(char before, const QByteArray &after); - QByteArray &replace(const char *before, const char *after); - QByteArray &replace(const char *before, int bsize, const char *after, int asize); - QByteArray &replace(const QByteArray &before, const QByteArray &after); - QByteArray &replace(const QByteArray &before, const char *after); - QByteArray &replace(const char *before, const QByteArray &after); - QByteArray &replace(char before, char after); - QByteArray &operator+=(char c); - QByteArray &operator+=(const char *s); - QByteArray &operator+=(const QByteArray &a); - - QList split(char sep) const; - - QByteArray repeated(const int times) const; - -#ifndef QT_NO_CAST_TO_ASCII - QByteArray &append(const QString &s); - QByteArray &insert(const int i, const QString &s); - QByteArray &replace(const QString &before, const char *after); - QByteArray &replace(char c, const QString &after); - QByteArray &replace(const QString &before, const QByteArray &after); - - QByteArray &operator+=(const QString &s); - int indexOf(const QString &s, const int from = 0) const; - int lastIndexOf(const QString &s, int const from = -1) const; -#endif -#ifndef QT_NO_CAST_FROM_ASCII - bool operator==(const QString &s2) const; - bool operator!=(const QString &s2) const; - bool operator<(const QString &s2) const; - bool operator>(const QString &s2) const; - bool operator<=(const QString &s2) const; - bool operator>=(const QString &s2) const; -#endif - - short toShort(bool *ok = Q_NULLPTR, int base = 10) const; - ushort toUShort(bool *ok = Q_NULLPTR, int base = 10) const; - int toInt(bool *ok = Q_NULLPTR, int base = 10) const; - uint toUInt(bool *ok = Q_NULLPTR, int base = 10) const; - long toLong(bool *ok = Q_NULLPTR, int base = 10) const; - ulong toULong(bool *ok = Q_NULLPTR, int base = 10) const; - qlonglong toLongLong(bool *ok = Q_NULLPTR, int base = 10) const; - qulonglong toULongLong(bool *ok = Q_NULLPTR, int base = 10) const; - float toFloat(bool *ok = Q_NULLPTR) const; - double toDouble(bool *ok = Q_NULLPTR) const; - QByteArray toBase64() const; - QByteArray toHex() const; - QByteArray toPercentEncoding(const QByteArray &exclude = QByteArray(), - const QByteArray &include = QByteArray(), - char percent = '%') const; - - QByteArray &setNum(short, int base = 10); - QByteArray &setNum(ushort, int base = 10); - QByteArray &setNum(int, int base = 10); - QByteArray &setNum(uint, int base = 10); - QByteArray &setNum(qlonglong, int base = 10); - QByteArray &setNum(qulonglong, int base = 10); - QByteArray &setNum(float, char f = 'g', int prec = 6); - QByteArray &setNum(double, char f = 'g', int prec = 6); - QByteArray &setRawData(const char *a, uint n); // ### Qt 5: use an int - - static QByteArray number(int, int base = 10); - static QByteArray number(uint, int base = 10); - static QByteArray number(qlonglong, int base = 10); - static QByteArray number(qulonglong, int base = 10); - static QByteArray number(double, char f = 'g', int prec = 6); - static QByteArray fromRawData(const char *, int size); - static QByteArray fromBase64(const QByteArray &base64); - static QByteArray fromHex(const QByteArray &hexEncoded); - static QByteArray fromPercentEncoding(const QByteArray &pctEncoded, char percent = '%'); - - // stl compatibility - void push_back(char c); - void push_back(const char *c); - void push_back(const QByteArray &a); - void push_front(char c); - void push_front(const char *c); - void push_front(const QByteArray &a); - - static QByteArray fromStdString(const std::string &s); - std::string toStdString() const; - - int count() const; - int length() const; - bool isNull() const; - -public: - typedef Data * DataPtr; - DataPtr &data_ptr(); -}; - -#if !defined(QT_NO_DATASTREAM) -QDataStream &operator<<(QDataStream &, const QByteArray &); -QDataStream &operator>>(QDataStream &, QByteArray &); -#endif - -#ifndef QT_NO_COMPRESS -QByteArray qCompress(const uchar* data, int nbytes, int compressionLevel = -1); -QByteArray qUncompress(const uchar* data, int nbytes); -QByteArray qCompress(const QByteArray& data, int compressionLevel = -1); -QByteArray qUncompress(const QByteArray& data); -#endif diff --git a/bindings/core/qchar.i b/bindings/core/qchar.i deleted file mode 100644 index 0aa095bcd..000000000 --- a/bindings/core/qchar.i +++ /dev/null @@ -1,255 +0,0 @@ -%{ -#include "QtCore/qchar.h" -QT_USE_NAMESPACE -%} - -class QLatin1Char -{ -public: - QLatin1Char(const char c); - char toLatin1() const; - ushort unicode() const; -}; - - -class QChar { -public: - QChar(); -#ifndef QT_NO_CAST_FROM_ASCII - QChar(const char c); - QChar(const uchar c); -#endif - QChar(const QLatin1Char ch); - QChar(const uchar c, uchar r); - QChar(const ushort rc); - QChar(const short rc); - QChar(const uint rc); - QChar(const int rc); - enum SpecialCharacter { - Null = 0x0000, - Nbsp = 0x00a0, - ReplacementCharacter = 0xfffd, - ObjectReplacementCharacter = 0xfffc, - ByteOrderMark = 0xfeff, - ByteOrderSwapped = 0xfffe, - ParagraphSeparator = 0x2029, - LineSeparator = 0x2028 - }; - QChar(const SpecialCharacter sc); - - // Unicode information - - enum Category - { - NoCategory, // ### Qt 5: replace with Other_NotAssigned - - Mark_NonSpacing, // Mn - Mark_SpacingCombining, // Mc - Mark_Enclosing, // Me - - Number_DecimalDigit, // Nd - Number_Letter, // Nl - Number_Other, // No - - Separator_Space, // Zs - Separator_Line, // Zl - Separator_Paragraph, // Zp - - Other_Control, // Cc - Other_Format, // Cf - Other_Surrogate, // Cs - Other_PrivateUse, // Co - Other_NotAssigned, // Cn - - Letter_Uppercase, // Lu - Letter_Lowercase, // Ll - Letter_Titlecase, // Lt - Letter_Modifier, // Lm - Letter_Other, // Lo - - Punctuation_Connector, // Pc - Punctuation_Dash, // Pd - Punctuation_Open, // Ps - Punctuation_Close, // Pe - Punctuation_InitialQuote, // Pi - Punctuation_FinalQuote, // Pf - Punctuation_Other, // Po - - Symbol_Math, // Sm - Symbol_Currency, // Sc - Symbol_Modifier, // Sk - Symbol_Other // So - }; - - enum Direction - { - DirL, DirR, DirEN, DirES, DirET, DirAN, DirCS, DirB, DirS, DirWS, DirON, - DirLRE, DirLRO, DirAL, DirRLE, DirRLO, DirPDF, DirNSM, DirBN - }; - - enum Decomposition - { - NoDecomposition, - Canonical, - Font, - NoBreak, - Initial, - Medial, - Final, - Isolated, - Circle, - Super, - Sub, - Vertical, - Wide, - Narrow, - Small, - Square, - Compat, - Fraction - - }; - - enum Joining - { - OtherJoining, Dual, Right, Center - }; - - enum CombiningClass - { - Combining_BelowLeftAttached = 200, - Combining_BelowAttached = 202, - Combining_BelowRightAttached = 204, - Combining_LeftAttached = 208, - Combining_RightAttached = 210, - Combining_AboveLeftAttached = 212, - Combining_AboveAttached = 214, - Combining_AboveRightAttached = 216, - - Combining_BelowLeft = 218, - Combining_Below = 220, - Combining_BelowRight = 222, - Combining_Left = 224, - Combining_Right = 226, - Combining_AboveLeft = 228, - Combining_Above = 230, - Combining_AboveRight = 232, - - Combining_DoubleBelow = 233, - Combining_DoubleAbove = 234, - Combining_IotaSubscript = 240 - }; - - enum UnicodeVersion { - Unicode_Unassigned, // ### Qt 5: assign with some constantly big value - Unicode_1_1, - Unicode_2_0, - Unicode_2_1_2, - Unicode_3_0, - Unicode_3_1, - Unicode_3_2, - Unicode_4_0, - Unicode_4_1, - Unicode_5_0 - }; - // ****** WHEN ADDING FUNCTIONS, CONSIDER ADDING TO QCharRef TOO - - Category category() const; - Direction direction() const; - Joining joining() const; - bool hasMirrored() const; - unsigned char combiningClass() const; - - QChar mirroredChar() const; - QString decomposition() const; - Decomposition decompositionTag() const; - - int digitValue() const; - QChar toLower() const; - QChar toUpper() const; - QChar toTitleCase() const; - QChar toCaseFolded() const; - - UnicodeVersion unicodeVersion() const; - - char toAscii() const; - char toLatin1() const; - ushort unicode() const; - ushort &unicode(); - - static QChar fromAscii(const char c); - static QChar fromLatin1(const char c); - - bool isNull() const; - bool isPrint() const; - bool isPunct() const; - bool isSpace() const; - bool isMark() const; - bool isLetter() const; - bool isNumber() const; - bool isLetterOrNumber() const; - bool isDigit() const; - bool isSymbol() const; - bool isLower() const; - bool isUpper() const; - bool isTitleCase() const; - - bool isHighSurrogate() const; - bool isLowSurrogate() const; - - uchar cell() const; - uchar row() const; - void setCell(uchar cell); - void setRow(uchar row); - - static bool isHighSurrogate(uint ucs4); - static bool isLowSurrogate(uint ucs4); - static bool requiresSurrogates(uint ucs4); - static uint surrogateToUcs4(ushort high, ushort low); - static uint surrogateToUcs4(QChar high, QChar low); - static ushort highSurrogate(uint ucs4); - static ushort lowSurrogate(uint ucs4); - - static Category QT_FASTCALL category(const uint ucs4); - static Category QT_FASTCALL category(const ushort ucs2); - static Direction QT_FASTCALL direction(const uint ucs4); - static Direction QT_FASTCALL direction(const ushort ucs2); - static Joining QT_FASTCALL joining(const uint ucs4); - static Joining QT_FASTCALL joining(const ushort ucs2); - static unsigned char QT_FASTCALL combiningClass(const uint ucs4); - static unsigned char QT_FASTCALL combiningClass(const ushort ucs2); - - static uint QT_FASTCALL mirroredChar(const uint ucs4); - static ushort QT_FASTCALL mirroredChar(const ushort ucs2); - static Decomposition QT_FASTCALL decompositionTag(const uint ucs4); - - static int QT_FASTCALL digitValue(const uint ucs4); - static int QT_FASTCALL digitValue(const ushort ucs2); - static uint QT_FASTCALL toLower(const uint ucs4); - static ushort QT_FASTCALL toLower(const ushort ucs2); - static uint QT_FASTCALL toUpper(const uint ucs4); - static ushort QT_FASTCALL toUpper(const ushort ucs2); - static uint QT_FASTCALL toTitleCase(const uint ucs4); - static ushort QT_FASTCALL toTitleCase(const ushort ucs2); - static uint QT_FASTCALL toCaseFolded(const uint ucs4); - static ushort QT_FASTCALL toCaseFolded(const ushort ucs2); - - static UnicodeVersion QT_FASTCALL unicodeVersion(const uint ucs4); - static UnicodeVersion QT_FASTCALL unicodeVersion(const ushort ucs2); - - static UnicodeVersion QT_FASTCALL currentUnicodeVersion(); - - static QString QT_FASTCALL decomposition(uint ucs4); - - -private: -#ifdef QT_NO_CAST_FROM_ASCII - QChar(const char c); - QChar(const uchar c); -#endif -}; - -#ifndef QT_NO_DATASTREAM -QDataStream &operator<<(QDataStream &, const QChar &); -QDataStream &operator>>(QDataStream &, QChar &); -#endif diff --git a/bindings/core/qcoreapplication.i b/bindings/core/qcoreapplication.i deleted file mode 100644 index c64f4b2af..000000000 --- a/bindings/core/qcoreapplication.i +++ /dev/null @@ -1,110 +0,0 @@ -%{ -#include "QtCore/qcoreapplication.h" -QT_USE_NAMESPACE -%} - -class QCoreApplication : public QObject -{ - Q_OBJECT - Q_PROPERTY(QString applicationName READ applicationName WRITE setApplicationName) - Q_PROPERTY(QString applicationVersion READ applicationVersion WRITE setApplicationVersion) - Q_PROPERTY(QString organizationName READ organizationName WRITE setOrganizationName) - Q_PROPERTY(QString organizationDomain READ organizationDomain WRITE setOrganizationDomain) - -public: - QCoreApplication(int &argc, char **argv); - - ~QCoreApplication(); - - static QStringList arguments(); - - static void setAttribute(Qt::ApplicationAttribute attribute, bool on = true); - static bool testAttribute(Qt::ApplicationAttribute attribute); - - static void setOrganizationDomain(const QString &orgDomain); - static QString organizationDomain(); - static void setOrganizationName(const QString &orgName); - static QString organizationName(); - static void setApplicationName(const QString &application); - static QString applicationName(); - static void setApplicationVersion(const QString &version); - static QString applicationVersion(); - - static QCoreApplication *instance(); - - static int exec(); - static void processEvents(QEventLoop::ProcessEventsFlags flags = QEventLoop::AllEvents); - static void processEvents(QEventLoop::ProcessEventsFlags flags, int maxtime); - static void exit(int retcode=0); - - static bool sendEvent(QObject *receiver, QEvent *event); - static void postEvent(QObject *receiver, QEvent *event); - static void postEvent(QObject *receiver, QEvent *event, int priority); - static void sendPostedEvents(QObject *receiver, int event_type); - static void sendPostedEvents(); - static void removePostedEvents(QObject *receiver); - static void removePostedEvents(QObject *receiver, int eventType); - static bool hasPendingEvents(); - - virtual bool notify(QObject *, QEvent *); - - static bool startingUp(); - static bool closingDown(); - - static QString applicationDirPath(); - static QString applicationFilePath(); - static qint64 applicationPid(); - -#ifndef QT_NO_LIBRARY - static void setLibraryPaths(const QStringList &); - static QStringList libraryPaths(); - static void addLibraryPath(const QString &); - static void removeLibraryPath(const QString &); -#endif // QT_NO_LIBRARY - -#ifndef QT_NO_TRANSLATION - static void installTranslator(QTranslator * messageFile); - static void removeTranslator(QTranslator * messageFile); -#endif - enum Encoding { CodecForTr, UnicodeUTF8, DefaultCodec = CodecForTr }; - static QString translate(const char * context, - const char * sourceText, - const char * disambiguation = Q_NULLPTR, - Encoding encoding = CodecForTr, - int n = -1); - - static void flush(); - -#if defined(Q_OS_UNIX) - static void watchUnixSignal(int signal, bool watch); -#endif - - typedef bool (*EventFilter)(void *message, long *result); - EventFilter setEventFilter(EventFilter filter); - bool filterEvent(void *message, long *result); - -public Q_SLOTS: - static void quit(); - -Q_SIGNALS: - void aboutToQuit(); - void unixSignal(int); - -protected: - bool event(QEvent *); - - virtual bool compressEvent(QEvent *, QObject *receiver, QPostEventList *); - - QCoreApplication(QCoreApplicationPrivate &p); -}; - -#ifdef QT_NO_TRANSLATION -// Simple versions -QString QCoreApplication::translate(const char *, const char *sourceText, - const char *, Encoding encoding = CodecForTr, int = -1); -#endif - -typedef void (*QtCleanUpFunction)(); - -void qAddPostRoutine(QtCleanUpFunction); -void qRemovePostRoutine(QtCleanUpFunction); diff --git a/bindings/core/qeasingcurve.i b/bindings/core/qeasingcurve.i deleted file mode 100644 index bead6bd20..000000000 --- a/bindings/core/qeasingcurve.i +++ /dev/null @@ -1,60 +0,0 @@ -%{ -#include "QtCore/qeasingcurve.h" -QT_USE_NAMESPACE -%} - -class QEasingCurve -{ - Q_GADGET - Q_ENUMS(Type) -public: - enum Type { - Linear, - InQuad, OutQuad, InOutQuad, OutInQuad, - InCubic, OutCubic, InOutCubic, OutInCubic, - InQuart, OutQuart, InOutQuart, OutInQuart, - InQuint, OutQuint, InOutQuint, OutInQuint, - InSine, OutSine, InOutSine, OutInSine, - InExpo, OutExpo, InOutExpo, OutInExpo, - InCirc, OutCirc, InOutCirc, OutInCirc, - InElastic, OutElastic, InOutElastic, OutInElastic, - InBack, OutBack, InOutBack, OutInBack, - InBounce, OutBounce, InOutBounce, OutInBounce, - InCurve, OutCurve, SineCurve, CosineCurve, - Custom, NCurveTypes - }; - - QEasingCurve(Type type = Linear); - QEasingCurve(const QEasingCurve &other); - ~QEasingCurve(); - - QEasingCurve &operator=(const QEasingCurve &other); - bool operator==(const QEasingCurve &other) const; - bool operator!=(const QEasingCurve &other) const; - - qreal amplitude() const; - void setAmplitude(qreal amplitude); - - qreal period() const; - void setPeriod(qreal period); - - qreal overshoot() const; - void setOvershoot(qreal overshoot); - - Type type() const; - void setType(Type type); - typedef qreal (*EasingFunction)(qreal progress); - void setCustomType(EasingFunction func); - EasingFunction customType() const; - - qreal valueForProgress(qreal progress) const; -}; - -#ifndef QT_NO_DEBUG_STREAM -QDebug operator<<(QDebug debug, const QEasingCurve &item); -#endif - -#ifndef QT_NO_DATASTREAM -QDataStream &operator<<(QDataStream &, const QEasingCurve&); -QDataStream &operator>>(QDataStream &, QEasingCurve &); -#endif diff --git a/bindings/core/qjsonarray.i b/bindings/core/qjsonarray.i deleted file mode 100644 index 311b9c681..000000000 --- a/bindings/core/qjsonarray.i +++ /dev/null @@ -1,52 +0,0 @@ -%{ -#include "QtCore/qjsonarray.h" -QT_USE_NAMESPACE -%} - -class QJsonArray -{ - public: - QJsonArray(); - ~QJsonArray(); - - QJsonArray(const QJsonArray &other); - QJsonArray &operator =(const QJsonArray &other); - - static QJsonArray fromStringList(const QStringList &list); - static QJsonArray fromVariantList(const QVariantList &list); - QVariantList toVariantList() const; - - int size() const; - int count() const; - - bool isEmpty() const; - QJsonValue at(int i) const; - QJsonValue first() const; - QJsonValue last() const; - - void prepend(const QJsonValue &value); - void append(const QJsonValue &value); - void removeAt(int i); - QJsonValue takeAt(int i); - void removeFirst(); - void removeLast(); - - void insert(int i, const QJsonValue &value); - void replace(int i, const QJsonValue &value); - - bool contains(const QJsonValue &element) const; - QJsonValueRef operator[](int i); - QJsonValue operator[](int i) const; - - bool operator==(const QJsonArray &other) const; - bool operator!=(const QJsonArray &other) const; - - // stl compatibility - void push_back(const QJsonValue &t); - void push_front(const QJsonValue &t); - void pop_front(); - void pop_back(); - bool empty(); -}; - -QDebug operator<<(QDebug, const QJsonArray &); diff --git a/bindings/core/qjsondocument.i b/bindings/core/qjsondocument.i deleted file mode 100644 index 188cf74c0..000000000 --- a/bindings/core/qjsondocument.i +++ /dev/null @@ -1,81 +0,0 @@ -%{ -#include "QtCore/qjsondocument.h" -QT_USE_NAMESPACE -%} - -struct QJsonParseError { - enum ParseError { - NoError = 0, - UnterminatedObject, - MissingNameSeparator, - UnterminatedArray, - MissingValueSeparator, - IllegalValue, - TerminationByNumber, - IllegalNumber, - IllegalEscapeSequence, - IllegalUTF8String, - UnterminatedString, - MissingObject, - DeepNesting, - DocumentTooLarge - }; - - QString errorString() const; - - int offset; - ParseError error; -}; - -class QJsonDocument -{ - public: - - QJsonDocument(); - QJsonDocument(const QJsonObject &object); - QJsonDocument(const QJsonArray &array); - ~QJsonDocument(); - - QJsonDocument(const QJsonDocument &other); - QJsonDocument &operator =(const QJsonDocument &other); - - enum DataValidation { - Validate, - BypassValidation - }; - - static QJsonDocument fromRawData(const char *data, int size, DataValidation validation = Validate); - const char *rawData(int *size) const; - - static QJsonDocument fromBinaryData(const QByteArray &data, DataValidation validation = Validate); - QByteArray toBinaryData() const; - - static QJsonDocument fromVariant(const QVariant &variant); - QVariant toVariant() const; - - enum JsonFormat { - Indented, - Compact - }; - - static QJsonDocument fromJson(const QByteArray &json, QJsonParseError *error = 0); - - QByteArray toJson(JsonFormat format = Indented) const; - - bool isEmpty() const; - bool isArray() const; - bool isObject() const; - - QJsonObject object() const; - QJsonArray array() const; - - void setObject(const QJsonObject &object); - void setArray(const QJsonArray &array); - - bool operator==(const QJsonDocument &other) const; - bool operator!=(const QJsonDocument &other) const; - - bool isNull() const; -}; - -QDebug operator<<(QDebug, const QJsonDocument &); diff --git a/bindings/core/qjsonobject.i b/bindings/core/qjsonobject.i deleted file mode 100644 index 6c7eba3d6..000000000 --- a/bindings/core/qjsonobject.i +++ /dev/null @@ -1,41 +0,0 @@ -%{ -#include "QtCore/qjsonobject.h" -QT_USE_NAMESPACE -%} - -class QJsonObject -{ - public: - QJsonObject(); - ~QJsonObject(); - - QJsonObject(const QJsonObject &other); - QJsonObject &operator =(const QJsonObject &other); - - static QJsonObject fromVariantMap(const QVariantMap &map); - QVariantMap toVariantMap() const; - static QJsonObject fromVariantHash(const QVariantHash &map); - QVariantHash toVariantHash() const; - - QStringList keys() const; - int size() const; - int count() const; - int length() const; - bool isEmpty() const; - - QJsonValue value(const QString &key) const; - QJsonValue operator[] (const QString &key) const; - QJsonValueRef operator[] (const QString &key); - - void remove(const QString &key); - QJsonValue take(const QString &key); - bool contains(const QString &key) const; - - bool operator==(const QJsonObject &other) const; - bool operator!=(const QJsonObject &other) const; - - // STL compatibility - bool empty() const; -}; - -QDebug operator<<(QDebug, const QJsonObject &); diff --git a/bindings/core/qjsonvalue.i b/bindings/core/qjsonvalue.i deleted file mode 100644 index 3fafe4d64..000000000 --- a/bindings/core/qjsonvalue.i +++ /dev/null @@ -1,91 +0,0 @@ -%{ -#include "QtCore/qjsonvalue.h" -QT_USE_NAMESPACE -%} - -class QJsonValue -{ - public: - enum Type { - Null = 0x0, - Bool = 0x1, - Double = 0x2, - String = 0x3, - Array = 0x4, - Object = 0x5, - Undefined = 0x80 - }; - - QJsonValue(Type = Null); - QJsonValue(bool b); - QJsonValue(double n); - QJsonValue(int n); - QJsonValue(qint64 n); - QJsonValue(const QString &s); - QJsonValue(QLatin1String s); - QJsonValue(const QJsonArray &a); - QJsonValue(const QJsonObject &o); - - ~QJsonValue(); - - QJsonValue(const QJsonValue &other); - QJsonValue &operator =(const QJsonValue &other); - - static QJsonValue fromVariant(const QVariant &variant); - QVariant toVariant() const; - - Type type() const; - bool isNull() const; - bool isBool() const; - bool isDouble() const; - bool isString() const; - bool isArray() const; - bool isObject() const; - bool isUndefined() const; - - bool toBool(bool defaultValue = false) const; - int toInt(int defaultValue = 0) const; - double toDouble(double defaultValue = 0) const; - QString toString(const QString &defaultValue = QString()) const; - QJsonArray toArray() const; - QJsonArray toArray(const QJsonArray &defaultValue) const; - QJsonObject toObject() const; - QJsonObject toObject(const QJsonObject &defaultValue) const; - - bool operator==(const QJsonValue &other) const; - bool operator!=(const QJsonValue &other) const; -}; - -class QJsonValueRef -{ - public: - QJsonValueRef(QJsonArray *array, int idx); - QJsonValueRef(QJsonObject *object, int idx); - - operator QJsonValue() const; - QJsonValueRef &operator = (const QJsonValue &val); - QJsonValueRef &operator = (const QJsonValueRef &val); - - QJsonValue::Type type() const; - bool isNull() const; - bool isBool() const; - bool isDouble() const; - bool isString() const; - bool isArray() const; - bool isObject() const; - bool isUndefined() const; - - bool toBool() const; - int toInt() const; - double toDouble() const; - QString toString() const; - QJsonArray toArray() const; - QJsonObject toObject() const; - - bool operator==(const QJsonValue &other) const; - bool operator!=(const QJsonValue &other) const; -}; - -// QJsonValueRefPtr and QJsonValuePtr not implemented - -QDebug operator<<(QDebug, const QJsonValue &); diff --git a/bindings/core/qlist.i b/bindings/core/qlist.i deleted file mode 100644 index 00731f207..000000000 --- a/bindings/core/qlist.i +++ /dev/null @@ -1,104 +0,0 @@ -%{ -#include "QtCore/qlist.h" -QT_USE_NAMESPACE -%} - -template -class QList -{ -public: - QList(); - QList(const QList &l); - ~QList(); - QList &operator=(const QList &l); -#ifdef Q_COMPILER_RVALUE_REFS - QList &operator=(QList &&other); -#endif - void swap(QList &other); -#ifdef Q_COMPILER_INITIALIZER_LISTS - QList(std::initializer_list args); -#endif - bool operator==(const QList &l) const; - bool operator!=(const QList &l) const; - - int size() const; - - void detach(); - - void detachShared(); - - bool isDetached() const; - void setSharable(bool sharable); - bool isSharedWith(const QList &other) const; - - bool isEmpty() const; - - void clear(); - - const T &at(int i) const; - const T &operator[](int i) const; - T &operator[](int i); - - void reserve(int size); - void append(const T &t); - void append(const QList &t); - void prepend(const T &t); - void insert(int i, const T &t); - void replace(int i, const T &t); - void removeAt(int i); - int removeAll(const T &t); - bool removeOne(const T &t); - T takeAt(int i); - T takeFirst(); - T takeLast(); - void move(int from, int to); - void swap(int i, int j); - int indexOf(const T &t, int from = 0) const; - int lastIndexOf(const T &t, int from = -1) const; - bool contains(const T &t) const; - int count(const T &t) const; - - // more Qt - int count() const; - int length() const; - T& first(); - const T& first() const; - T& last(); - const T& last() const; - void removeFirst(); - void removeLast(); - bool startsWith(const T &t) const; - bool endsWith(const T &t) const; - QList mid(int pos, int length = -1) const; - - T value(int i) const; - T value(int i, const T &defaultValue) const; - - // stl compatibility - void push_back(const T &t); - void push_front(const T &t); - T& front(); - const T& front() const; - T& back(); - const T& back() const; - void pop_front(); - void pop_back(); - bool empty() const; - - - // comfort - QList &operator+=(const QList &l); - QList operator+(const QList &l) const; - QList &operator+=(const T &t); - QList &operator<< (const T &t); - QList &operator<<(const QList &l); - - QVector toVector() const; - QSet toSet() const; - - static QList fromVector(const QVector &vector); - static QList fromSet(const QSet &set); - - static QList fromStdList(const std::list &list); - std::list toStdList() const; -}; diff --git a/bindings/core/qobject.i b/bindings/core/qobject.i deleted file mode 100644 index 467df4ef1..000000000 --- a/bindings/core/qobject.i +++ /dev/null @@ -1,155 +0,0 @@ -%{ -#include "QtCore/qobject.h" -QT_USE_NAMESPACE -%} - -#ifndef QT_NO_QOBJECT - -class QObject -{ -/* - Q_OBJECT - Q_PROPERTY(QString objectName READ objectName WRITE setObjectName) -*/ -public: - Q_INVOKABLE explicit QObject(QObject *parent = Q_NULLPTR); - virtual ~QObject(); - - virtual bool event(QEvent *); - virtual bool eventFilter(QObject *, QEvent *); - -#ifdef QT_NO_TRANSLATION - static QString tr(const char *sourceText, const char * = Q_NULLPTR, int = -1); -#ifndef QT_NO_TEXTCODEC - static QString trUtf8(const char *sourceText, const char * = Q_NULLPTR, int = -1); -#endif -#endif //QT_NO_TRANSLATION - - QString objectName() const; - void setObjectName(const QString &name); - - bool isWidgetType() const; - - bool signalsBlocked() const; - bool blockSignals(bool b); - - QThread *thread() const; - void moveToThread(QThread *thread); - - int startTimer(int interval); - void killTimer(int id); - - template - findChild(const QString &aName = QString()) const; - - template - QList findChildren(const QString &aName = QString()) const; - -#ifndef QT_NO_REGEXP - template - QList findChildren(const QRegExp &re) const; -#endif - - const QObjectList &children() const; - - void setParent(QObject *); - void installEventFilter(QObject *); - void removeEventFilter(QObject *); - - - static bool connect(const QObject *sender, const char *signal, - const QObject *receiver, const char *member, - Qt::ConnectionType type = Qt::AutoConnection - ); - - static bool connect(const QObject *sender, const QMetaMethod &signal, - const QObject *receiver, const QMetaMethod &method, - Qt::ConnectionType type = Qt::AutoConnection - ); - - bool connect(const QObject *sender, const char *signal, - const char *member, - Qt::ConnectionType type = Qt::AutoConnection - ) const; - - - static bool disconnect(const QObject *sender, const char *signal, - const QObject *receiver, const char *member); - static bool disconnect(const QObject *sender, const QMetaMethod &signal, - const QObject *receiver, const QMetaMethod &member); - bool disconnect(const char *signal = Q_NULLPTR, - const QObject *receiver = Q_NULLPTR, const char *member = Q_NULLPTR); - bool disconnect(const QObject *receiver, const char *member = Q_NULLPTR); - - void dumpObjectTree(); - void dumpObjectInfo(); - -#ifndef QT_NO_PROPERTIES - bool setProperty(const char *name, const QVariant &value); - QVariant property(const char *name) const; - QList dynamicPropertyNames() const; -#endif // QT_NO_PROPERTIES - -Q_SIGNALS: - void destroyed(QObject * = Q_NULLPTR); - -public: - QObject *parent() const; - - bool inherits(const char *classname) const; - -public Q_SLOTS: - void deleteLater(); - -protected: - QObject *sender() const; - int senderSignalIndex() const; - int receivers(const char* signal) const; - - virtual void timerEvent(QTimerEvent *); - virtual void childEvent(QChildEvent *); - virtual void customEvent(QEvent *); - - virtual void connectNotify(const char *signal); - virtual void disconnectNotify(const char *signal); - - QObject(QObjectPrivate &dd, QObject *parent = Q_NULLPTR); - - QObjectData* d_ptr; - - static const QMetaObject staticQtMetaObject; -}; - -/* TODO -template -T qobject_cast(QObject *object); - -template -T qobject_cast(const QObject *object); - -template const char * qobject_interface_iid() -{ return Q_NULLPTR; } - -#ifndef Q_MOC_RUN -# define Q_DECLARE_INTERFACE(IFace, IId) \ - QT_BEGIN_NAMESPACE \ - template <> const char *qobject_interface_iid() \ - { return IId; } \ - template <> IFace *qobject_cast(QObject *object) \ - { return reinterpret_cast((object ? object->qt_metacast(IId) : Q_NULLPTR)); } \ - template <> IFace *qobject_cast(const QObject *object) \ - { return reinterpret_cast((object ? const_cast(object)->qt_metacast(IId) : Q_NULLPTR)); } \ - QT_END_NAMESPACE -#endif // Q_MOC_RUN -*/ - -#ifndef QT_NO_DEBUG_STREAM -QDebug operator<<(QDebug, const QObject *); -#endif - -#endif // QT_NO_QOBJECT - - -void qt_qFindChildren_helper(const QObject *parent, const QString &name, const QRegExp *re, - const QMetaObject &mo, QList *list); -QObject *qt_qFindChild_helper(const QObject *parent, const QString &name, const QMetaObject &mo); diff --git a/bindings/core/qregexp.i b/bindings/core/qregexp.i deleted file mode 100644 index cd407ca98..000000000 --- a/bindings/core/qregexp.i +++ /dev/null @@ -1,66 +0,0 @@ -%{ -#include "QtCore/qregexp.h" -QT_USE_NAMESPACE -%} - -#ifndef QT_NO_REGEXP - -class QRegExp -{ -public: - enum PatternSyntax { - RegExp, - Wildcard, - FixedString, - RegExp2, - WildcardUnix }; - enum CaretMode { CaretAtZero, CaretAtOffset, CaretWontMatch }; - - QRegExp(); - QRegExp(const QString &pattern, Qt::CaseSensitivity cs = Qt::CaseSensitive, - PatternSyntax syntax = RegExp); - QRegExp(const QRegExp &rx); - ~QRegExp(); - QRegExp &operator=(const QRegExp &rx); -#ifdef Q_COMPILER_RVALUE_REFS - QRegExp &operator=(QRegExp &&other); -#endif - void swap(QRegExp &other); - - bool operator==(const QRegExp &rx) const; - bool operator!=(const QRegExp &rx) const; - - bool isEmpty() const; - bool isValid() const; - QString pattern() const; - void setPattern(const QString &pattern); - Qt::CaseSensitivity caseSensitivity() const; - void setCaseSensitivity(Qt::CaseSensitivity cs); - PatternSyntax patternSyntax() const; - void setPatternSyntax(PatternSyntax syntax); - - bool isMinimal() const; - void setMinimal(bool minimal); - - bool exactMatch(const QString &str) const; - - int indexIn(const QString &str, int offset = 0, CaretMode caretMode = CaretAtZero) const; - int lastIndexIn(const QString &str, int offset = -1, CaretMode caretMode = CaretAtZero) const; - int matchedLength() const; -#ifndef QT_NO_REGEXP_CAPTURE - int captureCount() const; - QStringList capturedTexts() const; - QString cap(int nth = 0) const; - int pos(int nth = 0) const; - QString errorString() const; -#endif - - static QString escape(const QString &str); -}; - -#ifndef QT_NO_DATASTREAM -QDataStream &operator<<(QDataStream &out, const QRegExp ®Exp); -QDataStream &operator>>(QDataStream &in, QRegExp ®Exp); -#endif - -#endif // QT_NO_REGEXP diff --git a/bindings/core/qset.i b/bindings/core/qset.i deleted file mode 100644 index c022afbfa..000000000 --- a/bindings/core/qset.i +++ /dev/null @@ -1,68 +0,0 @@ -%{ -#include "QtCore/qset.h" -QT_USE_NAMESPACE -%} - -template -class QSet -{ -public: - QSet(); - QSet(const QSet &other); - - QSet &operator=(const QSet &other); -#ifdef Q_COMPILER_RVALUE_REFS - QSet &operator=(QSet &&other); -#endif - void swap(QSet &other); - - bool operator==(const QSet &other) const; - bool operator!=(const QSet &other) const; - - int size() const; - - bool isEmpty() const; - - int capacity() const; - void reserve(int size); - void squeeze(); - - void detach(); - bool isDetached() const; - void setSharable(bool sharable); - - void clear(); - - bool remove(const T &value); - - bool contains(const T &value) const; - - bool contains(const QSet &set) const; - - // more Qt - int count() const; - QSet &unite(const QSet &other); - QSet &intersect(const QSet &other); - QSet &subtract(const QSet &other); - - bool empty() const; - // comfort - QSet &operator<<(const T &value); - QSet &operator|=(const QSet &other); - QSet &operator|=(const T &value); - QSet &operator&=(const QSet &other); - QSet &operator&=(const T &value); - QSet &operator+=(const QSet &other); - QSet &operator+=(const T &value); - QSet &operator-=(const QSet &other); - QSet &operator-=(const T &value); - QSet operator|(const QSet &other) const; - QSet operator&(const QSet &other) const; - QSet operator+(const QSet &other) const; - QSet operator-(const QSet &other) const; - - QList toList() const; - QList values() const; - - static QSet fromList(const QList &list); -}; diff --git a/bindings/core/qstring.i b/bindings/core/qstring.i deleted file mode 100644 index 451e1418a..000000000 --- a/bindings/core/qstring.i +++ /dev/null @@ -1,568 +0,0 @@ -%{ -#include "QtCore/qstring.h" -QT_USE_NAMESPACE -%} - -class QString -{ -public: - QString(); - QString(const QChar *unicode, int size = -1); - QString(const QChar c); - QString(const int size, const QChar c); - QString(const QLatin1String &latin1); - QString(const QString &); - ~QString(); - QString &operator=(QChar c); - QString &operator=(const QString &); - QString &operator=(const QLatin1String &); -#ifdef Q_COMPILER_RVALUE_REFS - QString &operator=(QString &&other); -#endif - void swap(QString &other); - int size() const; - int count() const; - int length() const; - bool isEmpty() const; - bool isNull() const; - void resize(int size); - - QString &fill(QChar c, int size = -1); - void truncate(int pos); - void chop(int n); - - int capacity() const; - void reserve(int size); - void squeeze(); - - const QChar *unicode() const; - QChar *data(); - const QChar *data() const; - const QChar *constData() const; - - void detach(); - bool isDetached() const; - bool isSharedWith(const QString &other) const; - void clear(); - - const QChar at(int i) const; - const QChar operator[](int i) const; - QCharRef operator[](int i); - const QChar operator[](uint i) const; - QCharRef operator[](uint i); - - QString arg(qlonglong a, int fieldwidth=0, int base=10, - const QChar &fillChar = QLatin1Char(' ')) const Q_REQUIRED_RESULT; - QString arg(qulonglong a, int fieldwidth=0, int base=10, - const QChar &fillChar = QLatin1Char(' ')) const Q_REQUIRED_RESULT; - QString arg(long a, int fieldwidth=0, int base=10, - const QChar &fillChar = QLatin1Char(' ')) const Q_REQUIRED_RESULT; - QString arg(ulong a, int fieldwidth=0, int base=10, - const QChar &fillChar = QLatin1Char(' ')) const Q_REQUIRED_RESULT; - QString arg(int a, int fieldWidth = 0, int base = 10, - const QChar &fillChar = QLatin1Char(' ')) const Q_REQUIRED_RESULT; - QString arg(uint a, int fieldWidth = 0, int base = 10, - const QChar &fillChar = QLatin1Char(' ')) const Q_REQUIRED_RESULT; - QString arg(short a, int fieldWidth = 0, int base = 10, - const QChar &fillChar = QLatin1Char(' ')) const Q_REQUIRED_RESULT; - QString arg(ushort a, int fieldWidth = 0, int base = 10, - const QChar &fillChar = QLatin1Char(' ')) const Q_REQUIRED_RESULT; - QString arg(double a, int fieldWidth = 0, char fmt = 'g', int prec = -1, - const QChar &fillChar = QLatin1Char(' ')) const Q_REQUIRED_RESULT; - QString arg(char a, int fieldWidth = 0, - const QChar &fillChar = QLatin1Char(' ')) const Q_REQUIRED_RESULT; - QString arg(QChar a, int fieldWidth = 0, - const QChar &fillChar = QLatin1Char(' ')) const Q_REQUIRED_RESULT; - QString arg(const QString &a, int fieldWidth = 0, - const QChar &fillChar = QLatin1Char(' ')) const Q_REQUIRED_RESULT; - QString arg(const QString &a1, const QString &a2) const Q_REQUIRED_RESULT; - QString arg(const QString &a1, const QString &a2, const QString &a3) const Q_REQUIRED_RESULT; - QString arg(const QString &a1, const QString &a2, const QString &a3, - const QString &a4) const Q_REQUIRED_RESULT; - QString arg(const QString &a1, const QString &a2, const QString &a3, - const QString &a4, const QString &a5) const Q_REQUIRED_RESULT; - QString arg(const QString &a1, const QString &a2, const QString &a3, - const QString &a4, const QString &a5, const QString &a6) const Q_REQUIRED_RESULT; - QString arg(const QString &a1, const QString &a2, const QString &a3, - const QString &a4, const QString &a5, const QString &a6, - const QString &a7) const Q_REQUIRED_RESULT; - QString arg(const QString &a1, const QString &a2, const QString &a3, - const QString &a4, const QString &a5, const QString &a6, - const QString &a7, const QString &a8) const Q_REQUIRED_RESULT; - QString arg(const QString &a1, const QString &a2, const QString &a3, - const QString &a4, const QString &a5, const QString &a6, - const QString &a7, const QString &a8, const QString &a9) const Q_REQUIRED_RESULT; - - QString &vsprintf(const char *format, va_list ap) -#if defined(Q_CC_GNU) && !defined(__INSURE__) - __attribute__ ((format (printf, 2, 0))) -#endif - ; - QString &sprintf(const char *format, ...) -#if defined(Q_CC_GNU) && !defined(__INSURE__) - __attribute__ ((format (printf, 2, 3))) -#endif - ; - - int indexOf(QChar c, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - int indexOf(const QString &s, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - int indexOf(const QLatin1String &s, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - int indexOf(const QStringRef &s, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - int lastIndexOf(QChar c, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - int lastIndexOf(const QString &s, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - int lastIndexOf(const QLatin1String &s, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - int lastIndexOf(const QStringRef &s, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - - bool contains(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - bool contains(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - bool contains(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - int count(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - int count(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - int count(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - -#ifndef QT_NO_REGEXP - int indexOf(const QRegExp &, int from = 0) const; - int lastIndexOf(const QRegExp &, int from = -1) const; - bool contains(const QRegExp &rx) const; - int count(const QRegExp &) const; - - int indexOf(QRegExp &, int from = 0) const; - int lastIndexOf(QRegExp &, int from = -1) const; - bool contains(QRegExp &rx) const; -#endif - - enum SectionFlags { - SectionDefault = 0x00, - SectionSkipEmpty = 0x01, - SectionIncludeLeadingSep = 0x02, - SectionIncludeTrailingSep = 0x04, - SectionCaseInsensitiveSeps = 0x08 - }; - - QString section(QChar sep, int start, int end = -1, SectionFlags flags = SectionDefault) const; - QString section(const QString &in_sep, int start, int end = -1, SectionFlags flags = SectionDefault) const; -#ifndef QT_NO_REGEXP - QString section(const QRegExp ®, int start, int end = -1, SectionFlags flags = SectionDefault) const; -#endif - - QString left(int n) const Q_REQUIRED_RESULT; - QString right(int n) const Q_REQUIRED_RESULT; - QString mid(int position, int n = -1) const Q_REQUIRED_RESULT; - QStringRef leftRef(int n) const Q_REQUIRED_RESULT; - QStringRef rightRef(int n) const Q_REQUIRED_RESULT; - QStringRef midRef(int position, int n = -1) const Q_REQUIRED_RESULT; - - bool startsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - bool startsWith(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - bool startsWith(const QLatin1String &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - bool startsWith(const QChar &c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - bool endsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - bool endsWith(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - bool endsWith(const QLatin1String &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - bool endsWith(const QChar &c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - - QString leftJustified(int width, QChar fill = QLatin1Char(' '), bool trunc = false) const Q_REQUIRED_RESULT; - QString rightJustified(int width, QChar fill = QLatin1Char(' '), bool trunc = false) const Q_REQUIRED_RESULT; - - QString toLower() const Q_REQUIRED_RESULT; - QString toUpper() const Q_REQUIRED_RESULT; - QString toCaseFolded() const Q_REQUIRED_RESULT; - - QString trimmed() const Q_REQUIRED_RESULT; - QString simplified() const Q_REQUIRED_RESULT; - - QString &insert(int i, QChar c); - QString &insert(int i, const QChar *uc, int len); - QString &insert(int i, const QString &s); - QString &insert(int i, const QLatin1String &s); - QString &append(QChar c); - QString &append(const QString &s); - QString &append(const QStringRef &s); - QString &append(const QLatin1String &s); - QString &prepend(QChar c); - QString &prepend(const QString &s); - QString &prepend(const QLatin1String &s); - - QString &operator+=(QChar c); - QString &operator+=(QChar::SpecialCharacter c); - QString &operator+=(const QString &s); - QString &operator+=(const QStringRef &s); - QString &operator+=(const QLatin1String &s); - - QString &remove(int i, int len); - QString &remove(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive); - QString &remove(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive); - QString &replace(int i, int len, QChar after); - QString &replace(int i, int len, const QChar *s, int slen); - QString &replace(int i, int len, const QString &after); - QString &replace(QChar before, QChar after, Qt::CaseSensitivity cs = Qt::CaseSensitive); - QString &replace(const QChar *before, int blen, const QChar *after, int alen, Qt::CaseSensitivity cs = Qt::CaseSensitive); - QString &replace(const QLatin1String &before, const QLatin1String &after, Qt::CaseSensitivity cs = Qt::CaseSensitive); - QString &replace(const QLatin1String &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive); - QString &replace(const QString &before, const QLatin1String &after, Qt::CaseSensitivity cs = Qt::CaseSensitive); - QString &replace(const QString &before, const QString &after, - Qt::CaseSensitivity cs = Qt::CaseSensitive); - QString &replace(QChar c, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive); - QString &replace(QChar c, const QLatin1String &after, Qt::CaseSensitivity cs = Qt::CaseSensitive); -#ifndef QT_NO_REGEXP - QString &replace(const QRegExp &rx, const QString &after); - QString &remove(const QRegExp &rx); -#endif - - enum SplitBehavior { KeepEmptyParts, SkipEmptyParts }; - - QStringList split(const QString &sep, SplitBehavior behavior = KeepEmptyParts, - Qt::CaseSensitivity cs = Qt::CaseSensitive) const Q_REQUIRED_RESULT; - QStringList split(const QChar &sep, SplitBehavior behavior = KeepEmptyParts, - Qt::CaseSensitivity cs = Qt::CaseSensitive) const Q_REQUIRED_RESULT; -#ifndef QT_NO_REGEXP - QStringList split(const QRegExp &sep, SplitBehavior behavior = KeepEmptyParts) const Q_REQUIRED_RESULT; -#endif - - enum NormalizationForm { - NormalizationForm_D, - NormalizationForm_C, - NormalizationForm_KD, - NormalizationForm_KC - }; - QString normalized(NormalizationForm mode) const Q_REQUIRED_RESULT; - QString normalized(NormalizationForm mode, QChar::UnicodeVersion version) const Q_REQUIRED_RESULT; - - QString repeated(int times) const; - - const ushort *utf16() const; - - QByteArray toAscii() const Q_REQUIRED_RESULT; - QByteArray toLatin1() const Q_REQUIRED_RESULT; - QByteArray toUtf8() const Q_REQUIRED_RESULT; - QByteArray toLocal8Bit() const Q_REQUIRED_RESULT; - QVector toUcs4() const Q_REQUIRED_RESULT; - - static QString fromAscii(const char *, int size = -1); - static QString fromLatin1(const char *, int size = -1); - static QString fromUtf8(const char *, int size = -1); - static QString fromLocal8Bit(const char *, int size = -1); - static QString fromUtf16(const ushort *, int size = -1); - static QString fromUcs4(const uint *, int size = -1); - static QString fromRawData(const QChar *, int size); - - int toWCharArray(wchar_t *array) const; - static QString fromWCharArray(const wchar_t *, int size = -1); - - QString &setRawData(const QChar *unicode, int size); - QString &setUnicode(const QChar *unicode, int size); - QString &setUtf16(const ushort *utf16, int size); - - int compare(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - - int compare(const QLatin1String &other, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - - static int compare(const QString &s1, const QString &s2, Qt::CaseSensitivity cs = Qt::CaseSensitive); - - static int compare(const QString& s1, const QLatin1String &s2, - Qt::CaseSensitivity cs = Qt::CaseSensitive); - static int compare(const QLatin1String& s1, const QString &s2, - Qt::CaseSensitivity cs = Qt::CaseSensitive); - - int compare(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - static int compare(const QString &s1, const QStringRef &s2, - Qt::CaseSensitivity = Qt::CaseSensitive); - - int localeAwareCompare(const QString& s) const; - static int localeAwareCompare(const QString& s1, const QString& s2); - - int localeAwareCompare(const QStringRef &s) const; - static int localeAwareCompare(const QString& s1, const QStringRef& s2); - - short toShort(bool *ok=Q_NULLPTR, int base=10) const; - ushort toUShort(bool *ok=Q_NULLPTR, int base=10) const; - int toInt(bool *ok=Q_NULLPTR, int base=10) const; - uint toUInt(bool *ok=Q_NULLPTR, int base=10) const; - long toLong(bool *ok=Q_NULLPTR, int base=10) const; - ulong toULong(bool *ok=Q_NULLPTR, int base=10) const; - qlonglong toLongLong(bool *ok=Q_NULLPTR, int base=10) const; - qulonglong toULongLong(bool *ok=Q_NULLPTR, int base=10) const; - float toFloat(bool *ok=Q_NULLPTR) const; - double toDouble(bool *ok=Q_NULLPTR) const; - - QString &setNum(short, int base=10); - QString &setNum(ushort, int base=10); - QString &setNum(int, int base=10); - QString &setNum(uint, int base=10); - QString &setNum(long, int base=10); - QString &setNum(ulong, int base=10); - QString &setNum(qlonglong, int base=10); - QString &setNum(qulonglong, int base=10); - QString &setNum(float, char f='g', int prec=6); - QString &setNum(double, char f='g', int prec=6); - - static QString number(int, int base=10); - static QString number(uint, int base=10); - static QString number(long, int base=10); - static QString number(ulong, int base=10); - static QString number(qlonglong, int base=10); - static QString number(qulonglong, int base=10); - static QString number(double, char f='g', int prec=6); - - bool operator==(const QString &s) const; - bool operator<(const QString &s) const; - bool operator>(const QString &s) const; - bool operator!=(const QString &s) const; - bool operator<=(const QString &s) const; - bool operator>=(const QString &s) const; - - bool operator==(const QLatin1String &s) const; - bool operator<(const QLatin1String &s) const; - bool operator>(const QLatin1String &s) const; - bool operator!=(const QLatin1String &s) const; - bool operator<=(const QLatin1String &s) const; - bool operator>=(const QLatin1String &s) const; - - // ASCII compatibility -#ifndef QT_NO_CAST_FROM_ASCII - QString(const char *ch); - QString(const QByteArray &a); - QString &operator=(const char *ch); - QString &operator=(const QByteArray &a); - QString &operator=(char c); - - // these are needed, so it compiles with STL support enabled - QString &prepend(const char *s); - QString &prepend(const QByteArray &s); - QString &append(const char *s); - QString &append(const QByteArray &s); - QString &operator+=(const char *s); - QString &operator+=(const QByteArray &s); - QString &operator+=(char c); - - bool operator==(const char *s) const; - bool operator!=(const char *s) const; - bool operator<(const char *s) const; - bool operator<=(const char *s2) const; - bool operator>(const char *s2) const; - bool operator>=(const char *s2) const; - - bool operator==(const QByteArray &s) const; - bool operator!=(const QByteArray &s) const; - bool operator<(const QByteArray &s) const; - bool operator>(const QByteArray &s) const; - bool operator<=(const QByteArray &s) const; - bool operator>=(const QByteArray &s) const; -#endif - - typedef QChar *iterator; - typedef const QChar *const_iterator; - typedef iterator Iterator; - typedef const_iterator ConstIterator; - iterator begin(); - const_iterator begin() const; - const_iterator constBegin() const; - iterator end(); - const_iterator end() const; - const_iterator constEnd() const; - - // STL compatibility - typedef const QChar & const_reference; - typedef QChar & reference; - typedef QChar value_type; - void push_back(QChar c); - void push_back(const QString &s); - void push_front(QChar c); - void push_front(const QString &s); - - static QString fromStdString(const std::string &s); - std::string toStdString() const; -#ifndef QT_NO_STL_WCHAR - static QString fromStdWString(const QStdWString &s); - QStdWString toStdWString() const; -#endif // QT_NO_STL_WCHAR - - bool isSimpleText() const; - bool isRightToLeft() const; - - QString(int size, Qt::Initialization); - - typedef Data * DataPtr; - DataPtr &data_ptr(); -}; - - -class QLatin1String -{ -public: - QLatin1String(const char *s); - QLatin1String &operator=(const QLatin1String &other); - - const char *latin1() const; - - bool operator==(const QString &s) const; - bool operator!=(const QString &s) const; - bool operator>(const QString &s) const; - bool operator<(const QString &s) const; - bool operator>=(const QString &s) const; - bool operator<=(const QString &s) const; - - // QT_ASCII_CAST_WARN - bool operator==(const char *s) const; - bool operator!=(const char *s) const; - bool operator<(const char *s) const; - bool operator>(const char *s) const; - bool operator<=(const char *s) const; - bool operator>=(const char *s) const; -}; - - -class QCharRef { - QCharRef(QString &str, int idx); -public: - - // most QChar operations repeated here - - // all this is not documented: We just say "like QChar" and let it be. - operator QChar() const; - QCharRef &operator=(const QChar &c); - - // An operator= for each QChar cast constructors -#ifndef QT_NO_CAST_FROM_ASCII - QCharRef &operator=(char c); - QCharRef &operator=(uchar c); -#endif - QCharRef &operator=(const QCharRef &c); - QCharRef &operator=(ushort rc); - QCharRef &operator=(short rc); - QCharRef &operator=(uint rc); - QCharRef &operator=(int rc); - - // each function... - bool isNull() const; - bool isPrint() const; - bool isPunct() const; - bool isSpace() const; - bool isMark() const; - bool isLetter() const; - bool isNumber() const; - bool isLetterOrNumber() const; - bool isDigit() const; - bool isLower() const; - bool isUpper() const; - bool isTitleCase() const; - - int digitValue() const; - QChar toLower() const; - QChar toUpper() const; - QChar toTitleCase () const; - - QChar::Category category() const; - QChar::Direction direction() const; - QChar::Joining joining() const; - bool hasMirrored() const; - QChar mirroredChar() const; - QString decomposition() const; - QChar::Decomposition decompositionTag() const; - uchar combiningClass() const; - - QChar::UnicodeVersion unicodeVersion() const; - - uchar cell() const; - uchar row() const; - void setCell(uchar cell); - void setRow(uchar row); - - char toAscii() const; - char toLatin1() const; - ushort unicode() const; - ushort& unicode(); -}; - -#if !defined(QT_NO_DATASTREAM) -QDataStream &operator<<(QDataStream &, const QString &); -QDataStream &operator>>(QDataStream &, QString &); -#endif - -class QStringRef { -public: - QStringRef(); - QStringRef(const QString *string, int position, int size); - QStringRef(const QString *string); - QStringRef(const QStringRef &other); - - ~QStringRef(); - const QString *string() const; - int position() const; - int size() const; - int count() const; - int length() const; - - QStringRef &operator=(const QStringRef &other); - - int indexOf(const QString &str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - int indexOf(QChar ch, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - int indexOf(QLatin1String str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - int indexOf(const QStringRef &str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - int lastIndexOf(const QString &str, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - int lastIndexOf(QChar ch, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - int lastIndexOf(QLatin1String str, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - int lastIndexOf(const QStringRef &str, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - - bool contains(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - bool contains(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - bool contains(QLatin1String str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - bool contains(const QStringRef &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - - int count(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - int count(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - int count(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - - bool startsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - bool startsWith(QLatin1String s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - bool startsWith(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - bool startsWith(const QStringRef &c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - - bool endsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - bool endsWith(QLatin1String s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - bool endsWith(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - bool endsWith(const QStringRef &c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - - QStringRef &operator=(const QString *string); - - const QChar *unicode() const; - const QChar *data() const; - const QChar *constData() const; - - QByteArray toAscii() const Q_REQUIRED_RESULT; - QByteArray toLatin1() const Q_REQUIRED_RESULT; - QByteArray toUtf8() const Q_REQUIRED_RESULT; - QByteArray toLocal8Bit() const Q_REQUIRED_RESULT; - QVector toUcs4() const Q_REQUIRED_RESULT; - - void clear(); - QString toString() const; - bool isEmpty() const; - bool isNull() const; - - QStringRef appendTo(QString *string) const; - - const QChar at(int i) const; - - int compare(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - int compare(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - int compare(QLatin1String s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - static int compare(const QStringRef &s1, const QString &s2, - Qt::CaseSensitivity = Qt::CaseSensitive); - static int compare(const QStringRef &s1, const QStringRef &s2, - Qt::CaseSensitivity = Qt::CaseSensitive); - static int compare(const QStringRef &s1, QLatin1String s2, - Qt::CaseSensitivity cs = Qt::CaseSensitive); - - int localeAwareCompare(const QString &s) const; - int localeAwareCompare(const QStringRef &s) const; - static int localeAwareCompare(const QStringRef &s1, const QString &s2); - static int localeAwareCompare(const QStringRef &s1, const QStringRef &s2); -}; - -// Those are Q_CORE_EXPORT'ed not inline'ed -bool operator==(const QStringRef &s1,const QStringRef &s2); -bool operator==(const QString &s1,const QStringRef &s2); -bool operator==(const QLatin1String &s1, const QStringRef &s2); - -bool operator<(const QStringRef &s1,const QStringRef &s2); diff --git a/bindings/core/qstringlist.i b/bindings/core/qstringlist.i deleted file mode 100644 index 7aa8b981b..000000000 --- a/bindings/core/qstringlist.i +++ /dev/null @@ -1,55 +0,0 @@ -%{ -#include "QtCore/qstringlist.h" -QT_USE_NAMESPACE -%} - -typedef QListIterator QStringListIterator; -typedef QMutableListIterator QMutableStringListIterator; - -class QStringList : public QList -{ -public: - QStringList(); - QStringList(const QString &i); - QStringList(const QStringList &l); - QStringList(const QList &l); -#ifdef Q_COMPILER_INITIALIZER_LISTS - QStringList(std::initializer_list args); -#endif - - void sort(); - int removeDuplicates(); - - QString join(const QString &sep) const; - - QStringList filter(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - bool contains(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; - - QStringList &replaceInStrings(const QString &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive); - - QStringList operator+(const QStringList &other) const; - QStringList &operator<<(const QString &str); - QStringList &operator<<(const QStringList &l); - -#ifndef QT_NO_REGEXP - QStringList filter(const QRegExp &rx) const; - QStringList &replaceInStrings(const QRegExp &rx, const QString &after); - int indexOf(const QRegExp &rx, int from = 0) const; - int lastIndexOf(const QRegExp &rx, int from = -1) const; - int indexOf(QRegExp &rx, int from = 0) const; - int lastIndexOf(QRegExp &rx, int from = -1) const; -#endif -#if !defined(Q_NO_USING_KEYWORD) - using QList::indexOf; - using QList::lastIndexOf; -#else - int indexOf(const QString &str, int from = 0) const; - int lastIndexOf(const QString &str, int from = -1) const; -#endif -}; - - -#ifndef QT_NO_DATASTREAM -QDataStream &operator>>(QDataStream &in, QStringList &list); -QDataStream &operator<<(QDataStream &out, const QStringList &list); -#endif // QT_NO_DATASTREAM diff --git a/bindings/core/qvariant.i b/bindings/core/qvariant.i deleted file mode 100644 index 9d47433a6..000000000 --- a/bindings/core/qvariant.i +++ /dev/null @@ -1,269 +0,0 @@ -%{ -#include "QtCore/qvariant.h" -QT_USE_NAMESPACE -%} - -template -QVariant qVariantFromValue(const T &); - -template -T qvariant_cast(const QVariant &); - -class QVariant -{ - public: - enum Type { - Invalid = QMetaType::Void, - - Bool = QMetaType::Bool, - Int = QMetaType::Int, - UInt = QMetaType::UInt, - LongLong = QMetaType::LongLong, - ULongLong = QMetaType::ULongLong, - Double = QMetaType::Double, - Char = QMetaType::QChar, - Map = QMetaType::QVariantMap, - List = QMetaType::QVariantList, - String = QMetaType::QString, - StringList = QMetaType::QStringList, - ByteArray = QMetaType::QByteArray, - BitArray = QMetaType::QBitArray, - Date = QMetaType::QDate, - Time = QMetaType::QTime, - DateTime = QMetaType::QDateTime, - Url = QMetaType::QUrl, - Locale = QMetaType::QLocale, - Rect = QMetaType::QRect, - RectF = QMetaType::QRectF, - Size = QMetaType::QSize, - SizeF = QMetaType::QSizeF, - Line = QMetaType::QLine, - LineF = QMetaType::QLineF, - Point = QMetaType::QPoint, - PointF = QMetaType::QPointF, - RegExp = QMetaType::QRegExp, - Hash = QMetaType::QVariantHash, - EasingCurve = QMetaType::QEasingCurve, - JsonValue = QMetaType::QJsonValue, - JsonObject = QMetaType::QJsonObject, - JsonArray = QMetaType::QJsonArray, - JsonDocument = QMetaType::QJsonDocument, - LastCoreType = QMetaType::LastCoreType, - - Font = QMetaType::QFont, - Pixmap = QMetaType::QPixmap, - Brush = QMetaType::QBrush, - Color = QMetaType::QColor, - Palette = QMetaType::QPalette, - Icon = QMetaType::QIcon, - Image = QMetaType::QImage, - Polygon = QMetaType::QPolygon, - Region = QMetaType::QRegion, - Bitmap = QMetaType::QBitmap, - Cursor = QMetaType::QCursor, - SizePolicy = QMetaType::QSizePolicy, - KeySequence = QMetaType::QKeySequence, - Pen = QMetaType::QPen, - TextLength = QMetaType::QTextLength, - TextFormat = QMetaType::QTextFormat, - Matrix = QMetaType::QMatrix, - Transform = QMetaType::QTransform, - Matrix4x4 = QMetaType::QMatrix4x4, - Vector2D = QMetaType::QVector2D, - Vector3D = QMetaType::QVector3D, - Vector4D = QMetaType::QVector4D, - Quaternion = QMetaType::QQuaternion, - LastGuiType = QMetaType::LastGuiType, - - UserType = 127, - LastType = 0xffffffff // need this so that gcc >= 3.4 allocates 32 bits for Type - }; - - QVariant(); - ~QVariant(); - QVariant(Type type); - QVariant(int typeOrUserType, const void *copy); - QVariant(int typeOrUserType, const void *copy, uint flags); - QVariant(const QVariant &other); - -#ifndef QT_NO_DATASTREAM - QVariant(QDataStream &s); -#endif - - QVariant(int i); - QVariant(uint ui); - QVariant(qlonglong ll); - QVariant(qulonglong ull); - QVariant(bool b); - QVariant(double d); - QVariant(float f); -#ifndef QT_NO_CAST_FROM_ASCII - QVariant(const char *str); -#endif - - QVariant(const QByteArray &bytearray); - QVariant(const QBitArray &bitarray); - QVariant(const QString &string); - QVariant(const QLatin1String &string); - QVariant(const QStringList &stringlist); - QVariant(const QChar &qchar); - QVariant(const QDate &date); - QVariant(const QTime &time); - QVariant(const QDateTime &datetime); - QVariant(const QList &list); - QVariant(const QMap &map); - QVariant(const QHash &hash); -#ifndef QT_NO_GEOM_VARIANT - QVariant(const QSize &size); - QVariant(const QSizeF &size); - QVariant(const QPoint &pt); - QVariant(const QPointF &pt); - QVariant(const QLine &line); - QVariant(const QLineF &line); - QVariant(const QRect &rect); - QVariant(const QRectF &rect); -#endif - QVariant(const QUrl &url); - QVariant(const QLocale &locale); -#ifndef QT_NO_REGEXP - QVariant(const QRegExp ®Exp); -#endif - QVariant(const QJsonValue &jsonValue); - QVariant(const QJsonObject &jsonObject); - QVariant(const QJsonArray &jsonArray); - QVariant(const QJsonDocument &jsonDocument); -#ifndef QT_BOOTSTRAPPED - QVariant(const QEasingCurve &easing); -#endif - - QVariant& operator=(const QVariant &other); -#ifdef Q_COMPILER_RVALUE_REFS - QVariant &operator=(QVariant &&other); -#endif - - void swap(QVariant &other); - - Type type() const; - int userType() const; - const char *typeName() const; - - bool canConvert(Type t) const; - bool convert(Type t); - - - bool isValid() const; - bool isNull() const; - - void clear(); - - void detach(); - bool isDetached() const; - - - - int toInt(bool *ok = Q_NULLPTR) const; - uint toUInt(bool *ok = Q_NULLPTR) const; - qlonglong toLongLong(bool *ok = Q_NULLPTR) const; - qulonglong toULongLong(bool *ok = Q_NULLPTR) const; - bool toBool() const; - double toDouble(bool *ok = Q_NULLPTR) const; - float toFloat(bool *ok = Q_NULLPTR) const; - qreal toReal(bool *ok = Q_NULLPTR) const; - QByteArray toByteArray() const; - QBitArray toBitArray() const; - QString toString() const; - QStringList toStringList() const; - QChar toChar() const; - QDate toDate() const; - QTime toTime() const; - QDateTime toDateTime() const; - QList toList() const; - QMap toMap() const; - QHash toHash() const; - -#ifndef QT_NO_GEOM_VARIANT - QPoint toPoint() const; - QPointF toPointF() const; - QRect toRect() const; - QSize toSize() const; - QSizeF toSizeF() const; - QLine toLine() const; - QLineF toLineF() const; - QRectF toRectF() const; -#endif - QUrl toUrl() const; - QLocale toLocale() const; -#ifndef QT_NO_REGEXP - QRegExp toRegExp() const; -#endif -#ifndef QT_BOOTSTRAPPED - QJsonValue toJsonValue() const; - QJsonObject toJsonObject() const; - QJsonArray toJsonArray() const; - QJsonDocument toJsonDocument() const; - QEasingCurve toEasingCurve() const; -#endif - - -#ifndef QT_NO_DATASTREAM - void load(QDataStream &ds); - void save(QDataStream &ds) const; -#endif - static const char *typeToName(Type type); - static Type nameToType(const char *name); - - - void *data(); - const void *constData() const; - const void *data() const; - - template - void setValue(const T &value); - - template - T value() const; - - template - static QVariant fromValue(const T &value); - - template - bool canConvert() const; - - bool operator==(const QVariant &v) const; - bool operator!=(const QVariant &v) const; -}; - -bool qvariant_cast_helper(const QVariant &v, QVariant::Type tp, void *ptr); - -template -QVariant qVariantFromValue(const T &t); - -template <> -QVariant qVariantFromValue(const QVariant &t); - -template -void qVariantSetValue(QVariant &v, const T &t); - -template <> -void qVariantSetValue(QVariant &v, const QVariant &t); - -template -void QVariant::setValue(const T &avalue); - -#ifndef QT_NO_DATASTREAM -QDataStream& operator>> (QDataStream& s, QVariant& p); -QDataStream& operator<< (QDataStream& s, const QVariant& p); -QDataStream& operator>> (QDataStream& s, QVariant::Type& p); -QDataStream& operator<< (QDataStream& s, const QVariant::Type p); -#endif - -#ifndef QT_MOC -template T qvariant_cast(const QVariant &v); - -template<> QVariant qvariant_cast(const QVariant &v); -#endif // QT_MOC - -#ifndef QT_NO_DEBUG_STREAM -QDebug operator<<(QDebug, const QVariant &); -QDebug operator<<(QDebug, const QVariant::Type); -#endif diff --git a/bindings/core/qvector.i b/bindings/core/qvector.i deleted file mode 100644 index 89595cfd8..000000000 --- a/bindings/core/qvector.i +++ /dev/null @@ -1,101 +0,0 @@ -%{ -#include "QtCore/qvector.h" -QT_USE_NAMESPACE -%} - -template -class QVector -{ -public: - QVector(); - QVector(int size); - QVector(int size, const T &t); - QVector(const QVector &v); - ~QVector(); - QVector &operator=(const QVector &v); -#ifdef Q_COMPILER_RVALUE_REFS - QVector operator=(QVector &&other); -#endif - void swap(QVector &other); -#ifdef Q_COMPILER_INITIALIZER_LISTS - QVector(std::initializer_list args); -#endif - bool operator==(const QVector &v) const; - bool operator!=(const QVector &v) const; - - int size() const; - - bool isEmpty() const; - - void resize(int size); - - int capacity() const; - void reserve(int size); - void squeeze(); - - void detach(); - bool isDetached() const; - void setSharable(bool sharable); - bool isSharedWith(const QVector &other) const; - - T *data(); - const T *data() const; - const T *constData() const; - void clear(); - - const T &at(int i) const; - T &operator[](int i); - const T &operator[](int i) const; - void append(const T &t); - void prepend(const T &t); - void insert(int i, const T &t); - void insert(int i, int n, const T &t); - void replace(int i, const T &t); - void remove(int i); - void remove(int i, int n); - - QVector &fill(const T &t, int size = -1); - - int indexOf(const T &t, int from = 0) const; - int lastIndexOf(const T &t, int from = -1) const; - bool contains(const T &t) const; - int count(const T &t) const; - - // more Qt - int count() const; - T& first(); - const T &first() const; - T& last(); - const T &last() const; - bool startsWith(const T &t) const; - bool endsWith(const T &t) const; - QVector mid(int pos, int length = -1) const; - - T value(int i) const; - T value(int i, const T &defaultValue) const; - - // STL compatibility - void push_back(const T &t); - void push_front(const T &t); - void pop_back(); - void pop_front(); - bool empty() const; - T& front(); - const T &front() const; - T &back(); - const T &back(); - - // comfort - QVector &operator+=(const QVector &l); - QVector operator+(const QVector &l) const; - QVector &operator+=(const T &t); - QVector &operator<< (const T &t); - QVector &operator<<(const QVector &l); - - QList toList() const; - - static QVector fromList(const QList &list); - - static QVector fromStdVector(const std::vector &vector); - std::vector toStdVector() const; -}; diff --git a/bindings/gui/qfontinfo.i b/bindings/gui/qfontinfo.i deleted file mode 100644 index 993700bb3..000000000 --- a/bindings/gui/qfontinfo.i +++ /dev/null @@ -1,31 +0,0 @@ -%{ -#include "QtGui/qfontinfo.h" -QT_USE_NAMESPACE -%} - -class QFontInfo -{ -public: - QFontInfo(const QFont &); - QFontInfo(const QFontInfo &); - ~QFontInfo(); - - QFontInfo &operator=(const QFontInfo &); - - QString family() const; - QString styleName() const; - int pixelSize() const; - int pointSize() const; - qreal pointSizeF() const; - bool italic() const; - QFont::Style style() const; - int weight() const; - bool bold() const; - bool underline() const; - bool overline() const; - bool strikeOut() const; - bool fixedPitch() const; - QFont::StyleHint styleHint() const; - - bool exactMatch() const; -}; diff --git a/bindings/gui/qfontmetrics.i b/bindings/gui/qfontmetrics.i deleted file mode 100644 index 45e68af3b..000000000 --- a/bindings/gui/qfontmetrics.i +++ /dev/null @@ -1,115 +0,0 @@ -%{ -#include "QtGui/qfontmetrics.h" -QT_USE_NAMESPACE -%} - -class QFontMetrics -{ -public: - QFontMetrics(const QFont &); - QFontMetrics(const QFont &, QPaintDevice *pd); - QFontMetrics(const QFontMetrics &); - ~QFontMetrics(); - - QFontMetrics &operator=(const QFontMetrics &); -#ifdef Q_COMPILER_RVALUE_REFS - QFontMetrics &operator=(QFontMetrics &&other); -#endif - - int ascent() const; - int descent() const; - int height() const; - int leading() const; - int lineSpacing() const; - int minLeftBearing() const; - int minRightBearing() const; - int maxWidth() const; - - int xHeight() const; - int averageCharWidth() const; - - bool inFont(QChar) const; - bool inFontUcs4(uint ucs4) const; - - int leftBearing(QChar) const; - int rightBearing(QChar) const; - int width(const QString &, int len = -1) const; - int width(const QString &, int len, int flags) const; - - int width(QChar) const; - int charWidth(const QString &str, int pos) const; - - QRect boundingRect(QChar) const; - - QRect boundingRect(const QString &text) const; - QRect boundingRect(const QRect &r, int flags, const QString &text, int tabstops=0, int *tabarray=0) const; - QRect boundingRect(int x, int y, int w, int h, int flags, const QString &text, - int tabstops=0, int *tabarray=0) const; - QSize size(int flags, const QString& str, int tabstops=0, int *tabarray=0) const; - - QRect tightBoundingRect(const QString &text) const; - - QString elidedText(const QString &text, Qt::TextElideMode mode, int width, int flags = 0) const; - - int underlinePos() const; - int overlinePos() const; - int strikeOutPos() const; - int lineWidth() const; - - bool operator==(const QFontMetrics &other) const; - bool operator !=(const QFontMetrics &other) const; -}; - - -class QFontMetricsF -{ -public: - QFontMetricsF(const QFont &); - QFontMetricsF(const QFont &, QPaintDevice *pd); - QFontMetricsF(const QFontMetrics &); - QFontMetricsF(const QFontMetricsF &); - ~QFontMetricsF(); - - QFontMetricsF &operator=(const QFontMetricsF &); - QFontMetricsF &operator=(const QFontMetrics &); -#ifdef Q_COMPILER_RVALUE_REFS - QFontMetricsF &operator=(QFontMetricsF &&other); -#endif - qreal ascent() const; - qreal descent() const; - qreal height() const; - qreal leading() const; - qreal lineSpacing() const; - qreal minLeftBearing() const; - qreal minRightBearing() const; - qreal maxWidth() const; - - qreal xHeight() const; - qreal averageCharWidth() const; - - bool inFont(QChar) const; - bool inFontUcs4(uint ucs4) const; - - qreal leftBearing(QChar) const; - qreal rightBearing(QChar) const; - qreal width(const QString &string) const; - - qreal width(QChar) const; - - QRectF boundingRect(const QString &string) const; - QRectF boundingRect(QChar) const; - QRectF boundingRect(const QRectF &r, int flags, const QString& string, int tabstops=0, int *tabarray=0) const; - QSizeF size(int flags, const QString& str, int tabstops=0, int *tabarray=0) const; - - QRectF tightBoundingRect(const QString &text) const; - - QString elidedText(const QString &text, Qt::TextElideMode mode, qreal width, int flags = 0) const; - - qreal underlinePos() const; - qreal overlinePos() const; - qreal strikeOutPos() const; - qreal lineWidth() const; - - bool operator==(const QFontMetricsF &other) const; - bool operator !=(const QFontMetricsF &other) const; -}; diff --git a/bindings/gui/qwidget.i b/bindings/gui/qwidget.i deleted file mode 100644 index 8072e2374..000000000 --- a/bindings/gui/qwidget.i +++ /dev/null @@ -1,533 +0,0 @@ -%{ -#include "QtGui/qwidget.h" -QT_USE_NAMESPACE -%} - -class QWidget : public QObject, public QPaintDevice -{ - Q_OBJECT - - Q_PROPERTY(bool modal READ isModal) - Q_PROPERTY(Qt::WindowModality windowModality READ windowModality WRITE setWindowModality) - Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled) - Q_PROPERTY(QRect geometry READ geometry WRITE setGeometry) - Q_PROPERTY(QRect frameGeometry READ frameGeometry) - Q_PROPERTY(QRect normalGeometry READ normalGeometry) - Q_PROPERTY(int x READ x) - Q_PROPERTY(int y READ y) - Q_PROPERTY(QPoint pos READ pos WRITE move DESIGNABLE false STORED false) - Q_PROPERTY(QSize frameSize READ frameSize) - Q_PROPERTY(QSize size READ size WRITE resize DESIGNABLE false STORED false) - Q_PROPERTY(int width READ width) - Q_PROPERTY(int height READ height) - Q_PROPERTY(QRect rect READ rect) - Q_PROPERTY(QRect childrenRect READ childrenRect) - Q_PROPERTY(QRegion childrenRegion READ childrenRegion) - Q_PROPERTY(QSizePolicy sizePolicy READ sizePolicy WRITE setSizePolicy) - Q_PROPERTY(QSize minimumSize READ minimumSize WRITE setMinimumSize) - Q_PROPERTY(QSize maximumSize READ maximumSize WRITE setMaximumSize) - Q_PROPERTY(int minimumWidth READ minimumWidth WRITE setMinimumWidth STORED false DESIGNABLE false) - Q_PROPERTY(int minimumHeight READ minimumHeight WRITE setMinimumHeight STORED false DESIGNABLE false) - Q_PROPERTY(int maximumWidth READ maximumWidth WRITE setMaximumWidth STORED false DESIGNABLE false) - Q_PROPERTY(int maximumHeight READ maximumHeight WRITE setMaximumHeight STORED false DESIGNABLE false) - Q_PROPERTY(QSize sizeIncrement READ sizeIncrement WRITE setSizeIncrement) - Q_PROPERTY(QSize baseSize READ baseSize WRITE setBaseSize) - Q_PROPERTY(QPalette palette READ palette WRITE setPalette) - Q_PROPERTY(QFont font READ font WRITE setFont) -#ifndef QT_NO_CURSOR - Q_PROPERTY(QCursor cursor READ cursor WRITE setCursor RESET unsetCursor) -#endif - Q_PROPERTY(bool mouseTracking READ hasMouseTracking WRITE setMouseTracking) - Q_PROPERTY(bool isActiveWindow READ isActiveWindow) - Q_PROPERTY(Qt::FocusPolicy focusPolicy READ focusPolicy WRITE setFocusPolicy) - Q_PROPERTY(bool focus READ hasFocus) - Q_PROPERTY(Qt::ContextMenuPolicy contextMenuPolicy READ contextMenuPolicy WRITE setContextMenuPolicy) - Q_PROPERTY(bool updatesEnabled READ updatesEnabled WRITE setUpdatesEnabled DESIGNABLE false) - Q_PROPERTY(bool visible READ isVisible WRITE setVisible DESIGNABLE false) - Q_PROPERTY(bool minimized READ isMinimized) - Q_PROPERTY(bool maximized READ isMaximized) - Q_PROPERTY(bool fullScreen READ isFullScreen) - Q_PROPERTY(QSize sizeHint READ sizeHint) - Q_PROPERTY(QSize minimumSizeHint READ minimumSizeHint) - Q_PROPERTY(bool acceptDrops READ acceptDrops WRITE setAcceptDrops) - Q_PROPERTY(QString windowTitle READ windowTitle WRITE setWindowTitle DESIGNABLE isWindow) - Q_PROPERTY(QIcon windowIcon READ windowIcon WRITE setWindowIcon DESIGNABLE isWindow) - Q_PROPERTY(QString windowIconText READ windowIconText WRITE setWindowIconText DESIGNABLE isWindow) - Q_PROPERTY(double windowOpacity READ windowOpacity WRITE setWindowOpacity DESIGNABLE isWindow) - Q_PROPERTY(bool windowModified READ isWindowModified WRITE setWindowModified DESIGNABLE isWindow) -#ifndef QT_NO_TOOLTIP - Q_PROPERTY(QString toolTip READ toolTip WRITE setToolTip) -#endif -#ifndef QT_NO_STATUSTIP - Q_PROPERTY(QString statusTip READ statusTip WRITE setStatusTip) -#endif -#ifndef QT_NO_WHATSTHIS - Q_PROPERTY(QString whatsThis READ whatsThis WRITE setWhatsThis) -#endif -#ifndef QT_NO_ACCESSIBILITY - Q_PROPERTY(QString accessibleName READ accessibleName WRITE setAccessibleName) - Q_PROPERTY(QString accessibleDescription READ accessibleDescription WRITE setAccessibleDescription) -#endif - Q_PROPERTY(Qt::LayoutDirection layoutDirection READ layoutDirection WRITE setLayoutDirection RESET unsetLayoutDirection) - QDOC_PROPERTY(Qt::WindowFlags windowFlags READ windowFlags WRITE setWindowFlags) - Q_PROPERTY(bool autoFillBackground READ autoFillBackground WRITE setAutoFillBackground) -#ifndef QT_NO_STYLE_STYLESHEET - Q_PROPERTY(QString styleSheet READ styleSheet WRITE setStyleSheet) -#endif - Q_PROPERTY(QLocale locale READ locale WRITE setLocale RESET unsetLocale) - Q_PROPERTY(QString windowFilePath READ windowFilePath WRITE setWindowFilePath DESIGNABLE isWindow) - -public: - enum RenderFlags { - DrawWindowBackground = 0x1, - DrawChildren = 0x2, - IgnoreMask = 0x4 - }; - - QWidget(QWidget* parent = Q_NULLPTR, Qt::WindowFlags f = 0); - ~QWidget(); - - int devType() const; - - WId winId() const; - void createWinId(); // internal, going away - WId internalWinId() const; - WId effectiveWinId() const; - - // GUI style setting - QStyle *style() const; - void setStyle(QStyle *); - // Widget types and states - - bool isTopLevel() const; - bool isWindow() const; - - bool isModal() const; - Qt::WindowModality windowModality() const; - void setWindowModality(Qt::WindowModality windowModality); - - bool isEnabled() const; - bool isEnabledTo(QWidget*) const; - bool isEnabledToTLW() const; - -public Q_SLOTS: - void setEnabled(bool); - void setDisabled(bool); - void setWindowModified(bool); - - // Widget coordinates - -public: - QRect frameGeometry() const; - const QRect &geometry() const; - QRect normalGeometry() const; - - int x() const; - int y() const; - QPoint pos() const; - QSize frameSize() const; - QSize size() const; - int width() const; - int height() const; - QRect rect() const; - QRect childrenRect() const; - QRegion childrenRegion() const; - - QSize minimumSize() const; - QSize maximumSize() const; - int minimumWidth() const; - int minimumHeight() const; - int maximumWidth() const; - int maximumHeight() const; - void setMinimumSize(const QSize &); - void setMinimumSize(int minw, int minh); - void setMaximumSize(const QSize &); - void setMaximumSize(int maxw, int maxh); - void setMinimumWidth(int minw); - void setMinimumHeight(int minh); - void setMaximumWidth(int maxw); - void setMaximumHeight(int maxh); - - - QSize sizeIncrement() const; - void setSizeIncrement(const QSize &); - void setSizeIncrement(int w, int h); - QSize baseSize() const; - void setBaseSize(const QSize &); - void setBaseSize(int basew, int baseh); - - void setFixedSize(const QSize &); - void setFixedSize(int w, int h); - void setFixedWidth(int w); - void setFixedHeight(int h); - - // Widget coordinate mapping - - QPoint mapToGlobal(const QPoint &) const; - QPoint mapFromGlobal(const QPoint &) const; - QPoint mapToParent(const QPoint &) const; - QPoint mapFromParent(const QPoint &) const; - QPoint mapTo(QWidget *, const QPoint &) const; - QPoint mapFrom(QWidget *, const QPoint &) const; - - QWidget *window() const; - QWidget *nativeParentWidget() const; - QWidget *topLevelWidget() const; - - // Widget appearance functions - const QPalette &palette() const; - void setPalette(const QPalette &); - - void setBackgroundRole(QPalette::ColorRole); - QPalette::ColorRole backgroundRole() const; - - void setForegroundRole(QPalette::ColorRole); - QPalette::ColorRole foregroundRole() const; - - const QFont &font() const; - void setFont(const QFont &); - QFontMetrics fontMetrics() const; - QFontInfo fontInfo() const; - -#ifndef QT_NO_CURSOR - QCursor cursor() const; - void setCursor(const QCursor &); - void unsetCursor(); -#endif - - void setMouseTracking(bool enable); - bool hasMouseTracking() const; - bool underMouse() const; - - void setMask(const QBitmap &); - void setMask(const QRegion &); - QRegion mask() const; - void clearMask(); - - void render(QPaintDevice *target, const QPoint &targetOffset = QPoint(), - const QRegion &sourceRegion = QRegion(), - RenderFlags renderFlags = RenderFlags(DrawWindowBackground | DrawChildren)); - - void render(QPainter *painter, const QPoint &targetOffset = QPoint(), - const QRegion &sourceRegion = QRegion(), - RenderFlags renderFlags = RenderFlags(DrawWindowBackground | DrawChildren)); - -#ifndef QT_NO_GRAPHICSEFFECT - QGraphicsEffect *graphicsEffect() const; - void setGraphicsEffect(QGraphicsEffect *effect); -#endif //QT_NO_GRAPHICSEFFECT - -#ifndef QT_NO_GESTURES - void grabGesture(Qt::GestureType type, Qt::GestureFlags flags = Qt::GestureFlags()); - void ungrabGesture(Qt::GestureType type); -#endif - -public Q_SLOTS: - void setWindowTitle(const QString &); -#ifndef QT_NO_STYLE_STYLESHEET - void setStyleSheet(const QString& styleSheet); -#endif -public: -#ifndef QT_NO_STYLE_STYLESHEET - QString styleSheet() const; -#endif - QString windowTitle() const; - void setWindowIcon(const QIcon &icon); - QIcon windowIcon() const; - void setWindowIconText(const QString &); - QString windowIconText() const; - void setWindowRole(const QString &); - QString windowRole() const; - void setWindowFilePath(const QString &filePath); - QString windowFilePath() const; - - void setWindowOpacity(qreal level); - qreal windowOpacity() const; - - bool isWindowModified() const; -#ifndef QT_NO_TOOLTIP - void setToolTip(const QString &); - QString toolTip() const; -#endif -#ifndef QT_NO_STATUSTIP - void setStatusTip(const QString &); - QString statusTip() const; -#endif -#ifndef QT_NO_WHATSTHIS - void setWhatsThis(const QString &); - QString whatsThis() const; -#endif -#ifndef QT_NO_ACCESSIBILITY - QString accessibleName() const; - void setAccessibleName(const QString &name); - QString accessibleDescription() const; - void setAccessibleDescription(const QString &description); -#endif - - void setLayoutDirection(Qt::LayoutDirection direction); - Qt::LayoutDirection layoutDirection() const; - void unsetLayoutDirection(); - - void setLocale(const QLocale &locale); - QLocale locale() const; - void unsetLocale(); - - bool isRightToLeft() const; - bool isLeftToRight() const; - -public Q_SLOTS: - void setFocus(); - -public: - bool isActiveWindow() const; - void activateWindow(); - void clearFocus(); - - void setFocus(Qt::FocusReason reason); - Qt::FocusPolicy focusPolicy() const; - void setFocusPolicy(Qt::FocusPolicy policy); - bool hasFocus() const; - static void setTabOrder(QWidget *, QWidget *); - void setFocusProxy(QWidget *); - QWidget *focusProxy() const; - Qt::ContextMenuPolicy contextMenuPolicy() const; - void setContextMenuPolicy(Qt::ContextMenuPolicy policy); - - // Grab functions - void grabMouse(); -#ifndef QT_NO_CURSOR - void grabMouse(const QCursor &); -#endif - void releaseMouse(); - void grabKeyboard(); - void releaseKeyboard(); -#ifndef QT_NO_SHORTCUT - int grabShortcut(const QKeySequence &key, Qt::ShortcutContext context = Qt::WindowShortcut); - void releaseShortcut(int id); - void setShortcutEnabled(int id, bool enable = true); - void setShortcutAutoRepeat(int id, bool enable = true); -#endif - static QWidget *mouseGrabber(); - static QWidget *keyboardGrabber(); - - // Update/refresh functions - bool updatesEnabled() const; - void setUpdatesEnabled(bool enable); - -#ifndef QT_NO_GRAPHICSVIEW - QGraphicsProxyWidget *graphicsProxyWidget() const; -#endif - -public Q_SLOTS: - void update(); - void repaint(); - -public: - void update(int x, int y, int w, int h); - void update(const QRect&); - void update(const QRegion&); - - void repaint(int x, int y, int w, int h); - void repaint(const QRect &); - void repaint(const QRegion &); - -public Q_SLOTS: - // Widget management functions - - virtual void setVisible(bool visible); - void setHidden(bool hidden); - void show(); - void hide(); - - void showMinimized(); - void showMaximized(); - void showFullScreen(); - void showNormal(); - - bool close(); - void raise(); - void lower(); - -public: - void stackUnder(QWidget*); - void move(int x, int y); - void move(const QPoint &); - void resize(int w, int h); - void resize(const QSize &); - void setGeometry(int x, int y, int w, int h); - void setGeometry(const QRect &); - QByteArray saveGeometry() const; - bool restoreGeometry(const QByteArray &geometry); - void adjustSize(); - bool isVisible() const; - bool isVisibleTo(const QWidget*) const; - bool isHidden() const; - - bool isMinimized() const; - bool isMaximized() const; - bool isFullScreen() const; - - Qt::WindowStates windowState() const; - void setWindowState(Qt::WindowStates state); - void overrideWindowState(Qt::WindowStates state); - - virtual QSize sizeHint() const; - virtual QSize minimumSizeHint() const; - - QSizePolicy sizePolicy() const; - void setSizePolicy(QSizePolicy); - void setSizePolicy(QSizePolicy::Policy horizontal, QSizePolicy::Policy vertical); - virtual int heightForWidth(int) const; - - QRegion visibleRegion() const; - - void setContentsMargins(int left, int top, int right, int bottom); - void setContentsMargins(const QMargins &margins); - void getContentsMargins(int *left, int *top, int *right, int *bottom) const; - QMargins contentsMargins() const; - - QRect contentsRect() const; - -public: - QLayout *layout() const; - void setLayout(QLayout *); - void updateGeometry(); - - void setParent(QWidget *parent); - void setParent(QWidget *parent, Qt::WindowFlags f); - - void scroll(int dx, int dy); - void scroll(int dx, int dy, const QRect&); - - // Misc. functions - - QWidget *focusWidget() const; - QWidget *nextInFocusChain() const; - QWidget *previousInFocusChain() const; - - // drag and drop - bool acceptDrops() const; - void setAcceptDrops(bool on); - -#ifndef QT_NO_ACTION - //actions - void addAction(QAction *action); - void addActions(QList actions); - void insertAction(QAction *before, QAction *action); - void insertActions(QAction *before, QList actions); - void removeAction(QAction *action); - QList actions() const; -#endif - - QWidget *parentWidget() const; - - void setWindowFlags(Qt::WindowFlags type); - Qt::WindowFlags windowFlags() const; - void overrideWindowFlags(Qt::WindowFlags type); - - Qt::WindowType windowType() const; - - static QWidget *find(WId); - QWidget *childAt(int x, int y) const; - QWidget *childAt(const QPoint &p) const; - -#if defined(Q_WS_X11) - const QX11Info &x11Info() const; - Qt::HANDLE x11PictureHandle() const; -#endif - - Qt::HANDLE handle() const; - - void setAttribute(Qt::WidgetAttribute, bool on = true); - bool testAttribute(Qt::WidgetAttribute) const; - - QPaintEngine *paintEngine() const; - - void ensurePolished() const; - bool isAncestorOf(const QWidget *child) const; - -#ifdef QT_KEYPAD_NAVIGATION - bool hasEditFocus() const; - void setEditFocus(bool on); -#endif - - bool autoFillBackground() const; - void setAutoFillBackground(bool enabled); - - void setWindowSurface(QWindowSurface *surface); - QWindowSurface *windowSurface() const; - -Q_SIGNALS: - void customContextMenuRequested(const QPoint &pos); - -protected: - // Event handlers - bool event(QEvent *); - virtual void mousePressEvent(QMouseEvent *); - virtual void mouseReleaseEvent(QMouseEvent *); - virtual void mouseDoubleClickEvent(QMouseEvent *); - virtual void mouseMoveEvent(QMouseEvent *); -#ifndef QT_NO_WHEELEVENT - virtual void wheelEvent(QWheelEvent *); -#endif - virtual void keyPressEvent(QKeyEvent *); - virtual void keyReleaseEvent(QKeyEvent *); - virtual void focusInEvent(QFocusEvent *); - virtual void focusOutEvent(QFocusEvent *); - virtual void enterEvent(QEvent *); - virtual void leaveEvent(QEvent *); - virtual void paintEvent(QPaintEvent *); - virtual void moveEvent(QMoveEvent *); - virtual void resizeEvent(QResizeEvent *); - virtual void closeEvent(QCloseEvent *); -#ifndef QT_NO_CONTEXTMENU - virtual void contextMenuEvent(QContextMenuEvent *); -#endif -#ifndef QT_NO_ACTION - virtual void actionEvent(QActionEvent *); -#endif - -#ifndef QT_NO_DRAGANDDROP - virtual void dragEnterEvent(QDragEnterEvent *); - virtual void dragMoveEvent(QDragMoveEvent *); - virtual void dragLeaveEvent(QDragLeaveEvent *); - virtual void dropEvent(QDropEvent *); -#endif - - virtual void showEvent(QShowEvent *); - virtual void hideEvent(QHideEvent *); - -#if defined(Q_WS_X11) - virtual bool x11Event(XEvent *); -#endif - - // Misc. protected functions - virtual void changeEvent(QEvent *); - - int metric(PaintDeviceMetric) const; - -protected Q_SLOTS: - void updateMicroFocus(); - -protected: - void create(WId = 0, bool initializeWindow = true, - bool destroyOldWindow = true); - void destroy(bool destroyWindow = true, - bool destroySubWindows = true); - - virtual bool focusNextPrevChild(bool next); - bool focusNextChild(); - bool focusPreviousChild(); - - QWidget(QWidgetPrivate &d, QWidget* parent, Qt::WindowFlags f); - - virtual void styleChange(QStyle&); // compat - virtual void enabledChange(bool); // compat - virtual void paletteChange(const QPalette &); // compat - virtual void fontChange(const QFont &); // compat - virtual void windowActivationChange(bool); // compat - virtual void languageChange(); // compat -}; - -template <> QWidget *qobject_cast(QObject *o); -template <> const QWidget *qobject_cast(const QObject *o); diff --git a/bindings/test.py b/bindings/test.py index 97fe5140c..86e422ded 100755 --- a/bindings/test.py +++ b/bindings/test.py @@ -1,9 +1,6 @@ #!/usr/bin/python -import sys, KtCore, KtGui +import sys, KtCore -a = KtGui.QApplication(0, None) -w = KtGui.QMainWindow() -w.setWindowTitle(KtCore.QString('Test')) -w.show() +a = KtCore.QCoreApplication(0, None) sys.exit(a._exec()) \ No newline at end of file diff --git a/bindings/tricks.i b/bindings/tricks.i deleted file mode 100644 index 42a9f19d8..000000000 --- a/bindings/tricks.i +++ /dev/null @@ -1,19 +0,0 @@ -#include "QtCore/qglobal.h" - -/* ASCII interface is needed and macro uses are purged anyway -#define QT_ASCII_CAST_WARN -#define QT_ASCII_CAST_WARN_CONSTRUCTOR -*/ - -#define Q_GADGET -#define Q_ENUMS(x) -#define Q_NO_USING_KEYWORD -#define Q_REQUIRED_RESULT -#define QT_FASTCALL -#define Q_OBJECT -#define Q_PROPERTY(x) -#define QDOC_PROPERTY(x) -#define Q_SLOTS -#define Q_SIGNALS protected -#define Q_INVOKABLE - diff --git a/bindings/typesystem_KtCore.xml b/bindings/typesystem_KtCore.xml new file mode 100644 index 000000000..c54500124 --- /dev/null +++ b/bindings/typesystem_KtCore.xml @@ -0,0 +1,282 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + PyObject *%out = PyTuple_New(2); + PyTuple_SET_ITEM(%out, 0, %CONVERTTOPYTHON[%INTYPE_0](%in.first)); + PyTuple_SET_ITEM(%out, 1, %CONVERTTOPYTHON[%INTYPE_1](%in.second)); + return %out; + + + + %out.first = %CONVERTTOCPP[%OUTTYPE_0](PySequence_Fast_GET_ITEM(%in, 0)); + %out.second = %CONVERTTOCPP[%OUTTYPE_1](PySequence_Fast_GET_ITEM(%in, 1)); + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + int %out = PySequence_Size(%PYARG_1); + + + + + + Shiboken::AutoArrayPointer<char*> %out(%1); + for (int i = 0; i < %1; ++i) + %out[i] = %CONVERTTOCPP[char*](PySequence_Fast_GET_ITEM(%PYARG_1, i)); + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/cmake/modules/FindShiboken.cmake b/cmake/modules/FindShiboken.cmake new file mode 100644 index 000000000..58d03b5f2 --- /dev/null +++ b/cmake/modules/FindShiboken.cmake @@ -0,0 +1,82 @@ +# - Try to find Shiboken +# Once done this will define +# +# SHIBOKEN_FOUND - system has Shiboken +# SHIBOKEN_INCLUDES - the Shiboken include directory +# SHIBOKEN_LIBRARIES - the libraries needed to use Shiboken +# SHIBOKEN_BINARY - the binary needed to use Shiboken +# SHIBOKEN_VERSION - the Shiboken version + +if(SHIBOKEN_INCLUDES AND SHIBOKEN_LIBRARIES AND SHIBOKEN_BINARY) + set(SHIBOKEN_FIND_QUIETLY TRUE) +endif() + +include(FindPkgConfig) +pkg_check_modules(PC_SHIBOKEN QUIET shiboken2) + +execute_process( + COMMAND ${PKG_CONFIG_EXECUTABLE} --variable=includedir shiboken2 + WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}" + RESULT_VARIABLE pkg_result + ERROR_VARIABLE pkg_error + OUTPUT_VARIABLE shiboken_includedir + OUTPUT_STRIP_TRAILING_WHITESPACE +) + +execute_process( + COMMAND ${PKG_CONFIG_EXECUTABLE} --variable=python_include_dir shiboken2 + WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}" + RESULT_VARIABLE pkg_result + ERROR_VARIABLE pkg_error + OUTPUT_VARIABLE python_shiboken_include_dir + OUTPUT_STRIP_TRAILING_WHITESPACE +) + +set(SHIBOKEN_INCLUDES + ${shiboken_includedir} + ${python_shiboken_include_dir} +) + +execute_process( + COMMAND ${PKG_CONFIG_EXECUTABLE} --libs shiboken2 + WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}" + RESULT_VARIABLE pkg_result + ERROR_VARIABLE pkg_error + OUTPUT_VARIABLE shiboken_libraries + OUTPUT_STRIP_TRAILING_WHITESPACE +) + +set(SHIBOKEN_LIBRARIES) +foreach(lib ${shiboken_libraries}) + # message(STATUS "shiboken_libraries: ${lib}") + set(SHIBOKEN_LIBRARIES + ${SHIBOKEN_LIBRARIES} + ${lib} + ) +endforeach() + +execute_process( + COMMAND ${PKG_CONFIG_EXECUTABLE} --variable=generator_location shiboken2 + WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}" + RESULT_VARIABLE pkg_result + ERROR_VARIABLE pkg_error + OUTPUT_VARIABLE SHIBOKEN_BINARY + OUTPUT_STRIP_TRAILING_WHITESPACE +) + +execute_process( + COMMAND ${PKG_CONFIG_EXECUTABLE} --modversion shiboken2 + WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}" + RESULT_VARIABLE pkg_result + ERROR_VARIABLE pkg_error + OUTPUT_VARIABLE SHIBOKEN_VERSION + OUTPUT_STRIP_TRAILING_WHITESPACE +) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(Shiboken + VERSION_VAR SHIBOKEN_VERSION + REQUIRED_VARS SHIBOKEN_INCLUDES SHIBOKEN_LIBRARIES SHIBOKEN_BINARY +) + +mark_as_advanced(SHIBOKEN_INCLUDES SHIBOKEN_LIBRARIES SHIBOKEN_BINARY) diff --git a/cmake/modules/KatieBuildMacros.cmake b/cmake/modules/KatieBuildMacros.cmake index 46113b792..5979e5ab9 100644 --- a/cmake/modules/KatieBuildMacros.cmake +++ b/cmake/modules/KatieBuildMacros.cmake @@ -291,3 +291,41 @@ macro(KATIE_TEST TESTNAME TESTSOURCES) COMMAND ${CMAKE_BINARY_DIR}/runtest.sh ${CMAKE_CURRENT_BINARY_DIR}/${TESTNAME} ) endmacro() + +# a macro to generate Python bindings sources +macro(KATANA_GENERATE_BINDINGS FORTARGET OUTPUTFILES) + set(outputfiles ${OUTPUTFILES} ${ARGN}) + set(includedirs) + get_directory_property(dirincs INCLUDE_DIRECTORIES) + foreach(incdir ${SHIBOKEN_INCLUDES} ${dirincs}) + if(NOT includedirs) + set(includedirs "${incdir}") + else() + set(includedirs "${includedirs}:${incdir}") + endif() + endforeach() + get_target_property(targetsources ${FORTARGET} SOURCES) + + add_custom_command( + COMMENT "Generating Python bindings for: ${FORTARGET}" + COMMAND ${SHIBOKEN_BINARY} + --use-isnull-as-nb_nonzero + --enable-return-value-heuristic + --enable-parent-ctor-heuristic + --avoid-protected-hack + --include-paths="${includedirs}" + --output-directory="${CMAKE_SOURCE_DIR}/bindings" + --license-file="${CMAKE_SOURCE_DIR}/header.BSD" + "${CMAKE_SOURCE_DIR}/bindings/${FORTARGET}_global.hpp" + "${CMAKE_SOURCE_DIR}/bindings/typesystem_${FORTARGET}.xml" + DEPENDS + ${FORTARGET} + ${targetsources} + "${CMAKE_SOURCE_DIR}/bindings/${FORTARGET}_global.hpp" + "${CMAKE_SOURCE_DIR}/bindings/typesystem_${FORTARGET}.xml" + "${CMAKE_SOURCE_DIR}/header.BSD" + OUTPUT ${outputfiles} + ) + set_source_files_properties(${outputfiles} PROPERTIES GENERATED TRUE) + set_source_files_properties(${outputfiles} PROPERTIES SKIP_AUTOGEN ON) +endmacro()