luke
/
klayout
mirror of https://github.com/KLayout/klayout.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Some issues with the byte array binding fixed, less ambiguitites with Qt bindings, tests added.

This commit is contained in:
Matthias Koefferlein 2021-01-24 23:44:40 +01:00
parent 405445a427
commit 77f6327940
26 changed files with 233 additions and 2225 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
scripts/mkqtdecl4/mkqtdecl.conf
View File

@ -183,6 +183,10 @@ drop_class "QVectorIterator"
drop_class "QVectorTypedData"
drop_enum_const "QEvent", /CocoaRequestModal/ # not available on WIN
drop_method "QCollator", /QCollator::compare\(.*QStringRef/ # clashes with QString version
drop_method "QLocale", /QLocale::(toDouble|toFloat|toInt|toLongLong|toShort|quoteString|toUInt|toULongLong|toUShort)\(.*QStringRef/ # clashes with QString version
drop_method "QRegularExpression", /QRegularExpression::(match|globalMatch)\(.*QStringRef/ # clashes with QString version
drop_method "QSignalBlocker", /QSignalBlocker::QSignalBlocker\(.*&/ # clashes with pointer version
drop_method "QFont", /QFont::initialize/ # Must not hide Ruby's initialize and is not public
drop_method "QColormap", /QColormap::initialize/ # Must not hide Ruby's initialize and is not public
drop_method "QAccessible", /QAccessible::initialize/ # Must not hide Ruby's initialize and is not public
@ -193,6 +197,7 @@ drop_method "QMetaObject", /QMetaObject::invokeMethod/ # requires QGenericArgume
drop_method "QMetaObject", /QMetaObject::metacall/ # requires void**
drop_method "QMetaMethod", /QMetaMethod::invoke/ # requires QGenericArgument which is a macro
drop_method "QMetaMethod", /QMetaMethod::newInstance/ # requires QGenericArgument which is a macro
drop_method "QMetaObject", /QMetaObject::cast\(/ # internal
drop_method "QMetaObject", /QMetaObject::activate/ # requires void**
drop_method "QMetaObject", /QMetaObject::static_metacall/ # requires void**
drop_method "QMetaObject", /QMetaObject::addGuard/ # requires QObject**
@ -563,6 +568,8 @@ drop_method "QMessageBox", /QMessageBox::critical.*QMessageBox::StandardButton\s
drop_method "QMessageBox", /QMessageBox::information.*QMessageBox::StandardButton\s+\w+,\s*QMessageBox::StandardButton\s+\w+\s*\)/ # clashes with enum version
drop_method "QTreeWidgetItem", /::QTreeWidgetItem\(const\s+QTreeWidgetItem\s*&/ # will hide the parent-constructor otherwise. Use dup/copy protocol instead.
rename "QRawFont", /QRawFont::supportsCharacter\(.*ucs4/, "supportsCharacter_ucs4"
drop_method "QTextLine", /QTextLine::cursorToX\(.*int\s*\*/ # clashes with int-only version
drop_method "QPainter", /QPainter::drawRects.*QRect\s+\*/ # requires pointers, alternative available
drop_method "QPainter", /QPainter::drawRects.*QRectF\s+\*/ # requires pointers, alternative available
drop_method "QPainter", /QPainter::drawConvexPolygon.*QPoint\s+\*/ # requires pointers, alternative available
@ -672,6 +679,11 @@ final_class "QAccessibleWidget" # because navigate cannot be implemented
# --------------------------------------------------------------
# QtXml
drop_method "QXmlReader", /QXmlReader::parse\(.*QXmlInputSource\s*&/ # Clashes with pointer version
drop_method "QXmlStreamReader", /QXmlStreamReader::QXmlStreamReader\(.*const\s+char\s*\*/ # Clashes with QString version
drop_method "QXmlStreamReader", /QXmlStreamReader::addData\(.*const\s+char\s*\*/ # Clashes with QString version
drop_method "QXmlStreamStringRef", /QXmlStreamStringRef::QXmlStreamStringRef\(.*const\s+char\s*\*/ # Clashes with QString version
drop_method "QXmlAttributes", /QXmlAttributes::value\(\s*const\s+QLatin1String/ # QLatin1String not available
drop_method "QXmlAttributes", /QXmlAttributes::index\(\s*const\s+QLatin1String/ # QLatin1String not available
drop_method "QXmlInputSource", /QXmlInputSource::setData\(.*QByteArray/ # clashes with QString version

17
scripts/mkqtdecl5/mkqtdecl.conf
View File

@ -223,8 +223,14 @@ drop_class "QVectorIterator"
drop_class "QVectorTypedData"
drop_enum_const "QEvent", /CocoaRequestModal/ # not available on WIN
drop_method "QCollator", /QCollator::compare\(.*QStringRef/ # clashes with QString version
drop_method "QLocale", /QLocale::(toDouble|toFloat|toInt|toLongLong|toShort|quoteString|toUInt|toULongLong|toUShort)\(.*QStringRef/ # clashes with QString version
drop_method "QRegularExpression", /QRegularExpression::(match|globalMatch)\(.*QStringRef/ # clashes with QString version
drop_method "QSignalBlocker", /QSignalBlocker::QSignalBlocker\(.*&/ # clashes with pointer version
drop_method "QQuaternion", /QQuaternion::toRotationMatrix\(/ # GenericMatrix not available
drop_method "QQuaternion", /QQuaternion::fromRotationMatrix\(/ # GenericMatrix not available
drop_method "QJsonValue", /QJsonValue::QJsonValue\(\s*const\s+char\s*\*/ # clashes with QString version
drop_method "QJsonValue", /QJsonValue::QJsonValue\(\s*int\s+/ # clashes with long version
drop_method "QJsonValue", /QJsonValue::QJsonValue\(\s*QLatin1String/ # QLatin1String not available
drop_method "QTextBoundaryFinder", /QTextBoundaryFinder::QTextBoundaryFinder\(.*unsigned\s+char\s*\*/ # unsigned char * not available
drop_method "QMessageLogger", /QMessageLogger::critical\(.*catFunc/ # function pointers not supported currently
@ -246,6 +252,7 @@ drop_method "QEasingCurve", /QEasingCurve::setCustomType/ # requires function *
drop_method "QEasingCurve", /QEasingCurve::customType/ # requires function *
drop_method "QLibrary", /QLibrary::resolve/ # requires function *
drop_method "QLoggingCategory", /QLoggingCategory::installFilter/ # requires function *
drop_method "QMetaObject", /QMetaObject::cast\(/ # internal
drop_method "QMetaObject", /QMetaObject::d\(/ # invalid return value (struct)
drop_method "QMetaObject", /QMetaObject::invokeMethod/ # requires QGenericArgument which is a macro
drop_method "QMetaObject", /QMetaObject::metacall/ # requires void**
@ -674,6 +681,8 @@ drop_method "QMenu", /QMenu::setPlatformMenu/ # QPlatformMenu not available
drop_method "QMenuBar", /QMenuBar::platformMenuBar/ # QPlatformMenu not available
drop_method "QTreeWidgetItem", /::QTreeWidgetItem\(const\s+QTreeWidgetItem\s*&/ # will hide the parent-constructor otherwise. Use dup/copy protocol instead.
rename "QRawFont", /QRawFont::supportsCharacter\(.*ucs4/, "supportsCharacter_ucs4"
drop_method "QTextLine", /QTextLine::cursorToX\(.*int\s*\*/ # clashes with int-only version
drop_method "QPainter", /QPainter::drawRects.*QRect\s+\*/ # requires pointers, alternative available
drop_method "QPainter", /QPainter::drawRects.*QRectF\s+\*/ # requires pointers, alternative available
drop_method "QPainter", /QPainter::drawConvexPolygon.*QPoint\s+\*/ # requires pointers, alternative available
@ -797,6 +806,10 @@ include "QXmlSerializer", [ "<QXmlSerializer>", "<QXmlQuery>" ]
no_imports "QXmlStreamAttributes" # base class is a template.
drop_method "QXmlReader", /QXmlReader::parse\(.*QXmlInputSource\s*&/ # Clashes with pointer version
drop_method "QXmlStreamReader", /QXmlStreamReader::QXmlStreamReader\(.*const\s+char\s*\*/ # Clashes with QString version
drop_method "QXmlStreamReader", /QXmlStreamReader::addData\(.*const\s+char\s*\*/ # Clashes with QString version
drop_method "QXmlStreamStringRef", /QXmlStreamStringRef::QXmlStreamStringRef\(.*const\s+char\s*\*/ # Clashes with QString version
drop_method "QXmlStreamAttributes", /QXmlStreamAttributes::append\(const\s+QVector/ # QVector is a template
drop_method "QXmlStreamAttributes", /QXmlStreamAttributes::hasAttribute\(\s*QLatin1String/ # QLatin1String is not available
drop_method "QXmlStreamAttributes", /QXmlStreamAttributes::value\(.*QLatin1String/ # QLatin1String is not available
@ -934,10 +947,6 @@ drop_method "QAbstractVideoBuffer", /QAbstractVideoBuffer::mapPlanes/ # int[] no
drop_method "QAbstractVideoBuffer", /QAbstractVideoBuffer::map\(QAbstractVideoBuffer::MapMode/ # unsigned char * not available
drop_method "QVideoFrame", /^unsigned\s+char\s*\*/ # unsigned char * not available
# --------------------------------------------------------------
# QtDesigner
# --------------------------------------------------------------
no_default_ctor "QRadioTunerControl"

3
src/db/db/dbRegion.cc
View File

@ -31,6 +31,9 @@
#include "dbPolygonTools.h"
#include "tlGlobPattern.h"
// NOTE: include this to provide the symbols for "make_variant"
#include "gsiDecl.h"
namespace db
{

71
src/gsi/gsi/gsiClassBase.cc
View File

@ -421,6 +421,53 @@ static const std::set<std::pair<std::string, bool> > &name_map_for_class (const
return cc->second;
}
#if defined(_DEBUG)
static std::string type_signature (const gsi::ArgType &t)
{
gsi::ArgType tr (t);
tr.set_is_ptr (false);
tr.set_is_ref (false);
tr.set_is_cptr (false);
tr.set_is_cref (false);
return tr.to_string ();
}
static std::string signature (const gsi::MethodBase *m, const gsi::MethodBase::MethodSynonym &s)
{
std::string res;
if (m->is_static ()) {
res += "static ";
}
res += type_signature (m->ret_type ());
res += " ";
res += s.name;
if (s.is_predicate) {
res += "?";
}
if (s.is_setter) {
res += "=";
}
res += "(";
for (gsi::MethodBase::argument_iterator a = m->begin_arguments (); a != m->end_arguments (); ++a) {
if (a != m->begin_arguments ()) {
res += ", ";
}
res += type_signature (*a);
}
res += ")";
if (m->is_const ()) {
res += " const";
}
return res;
}
#endif
void
ClassBase::merge_declarations ()
{
@ -563,6 +610,30 @@ ClassBase::merge_declarations ()
// lym::ExternalClass)
tl_assert (! c->declaration () || c->declaration () == &*c);
}
#if defined(_DEBUG)
// do a sanity check
for (gsi::ClassBase::class_iterator c = gsi::ClassBase::begin_classes (); c != gsi::ClassBase::end_classes (); ++c) {
std::map<std::string, int> method_counts;
for (gsi::ClassBase::method_iterator m = c->begin_methods (); m != c->end_methods (); ++m) {
if (! (*m)->is_callback ()) {
for (gsi::MethodBase::synonym_iterator s = (*m)->begin_synonyms (); s != (*m)->end_synonyms (); ++s) {
method_counts [signature (*m, *s)] += 1;
}
}
}
for (std::map<std::string, int>::const_iterator mc = method_counts.begin (); mc != method_counts.end (); ++mc) {
if (mc->second > 1) {
tl::warn << "Ambiguous method declarations in class " << c->name () << " for method " << mc->first;
}
}
}
#endif
}
static void collect_classes (const gsi::ClassBase *cls, std::list<const gsi::ClassBase *> &unsorted_classes)

25
src/gsi/gsi_test/gsiTest.cc
View File

@ -129,6 +129,17 @@ A::ia_cref_to_qba (const std::vector<int> &ia)
return ba;
}
const QByteArray &
A::ia_cref_to_qba_cref (const std::vector<int> &ia)
{
static QByteArray ba;
ba.clear ();
for (std::vector<int>::const_iterator i = ia.begin (); i != ia.end (); ++i) {
ba.push_back (char (*i));
}
return ba;
}
std::vector<int>
A::ba_cref_to_ia (const std::vector<char> &ba)
{
@ -149,6 +160,18 @@ A::ia_cref_to_ba (const std::vector<int> &ia)
return ba;
}
const std::vector<char> &
A::ia_cref_to_ba_cref (const std::vector<int> &ia)
{
static std::vector<char> ba;
ba.clear ();
for (std::vector<int>::const_iterator i = ia.begin (); i != ia.end (); ++i) {
ba.push_back (char (*i));
}
return ba;
}
static A *a_ctor (int i)
{
return new A (i);
@ -831,6 +854,7 @@ static gsi::Class<A> decl_a ("", "A",
gsi::method ("qba_ptr_to_ia", &A::qba_ptr_to_ia) +
gsi::method ("qba_to_ia", &A::qba_to_ia) +
gsi::method ("ia_cref_to_qba", &A::ia_cref_to_qba) +
gsi::method ("ia_cref_to_qba_cref", &A::ia_cref_to_qba_cref) +
#endif
gsi::method ("ba_cref_to_ia", &A::ba_cref_to_ia) +
gsi::method ("ba_ref_to_ia", &A::ba_ref_to_ia) +
@ -838,6 +862,7 @@ static gsi::Class<A> decl_a ("", "A",
gsi::method ("ba_ptr_to_ia", &A::ba_ptr_to_ia) +
gsi::method ("ba_to_ia", &A::ba_to_ia) +
gsi::method ("ia_cref_to_ba", &A::ia_cref_to_ba) +
gsi::method ("ia_cref_to_ba_cref", &A::ia_cref_to_ba_cref) +
gsi::method ("br", &A::br) +
gsi::method ("get_e", &A::get_e) +

3
src/gsi/gsi_test/gsiTest.h
View File

@ -107,6 +107,8 @@ struct A
* @brief Byte sequences: tests return of QByteArray
*/
static QByteArray ia_cref_to_qba (const std::vector<int> &ia);
static const QByteArray &ia_cref_to_qba_cref (const std::vector<int> &ia);
#endif
/**
@ -122,6 +124,7 @@ struct A
* @brief Byte sequences: tests return of std::vector<char>
*/
static std::vector<char> ia_cref_to_ba (const std::vector<int> &ia);
static const std::vector<char> &ia_cref_to_ba_cref (const std::vector<int> &ia);
/*
* @brief A dummy method providing a chance to set a breakpoint in the script

20
src/gsiqt/qt4/QtCore/gsiDeclQMetaObject.cc
View File

@ -56,25 +56,6 @@ static void _call_ctor_QMetaObject_0 (const qt_gsi::GenericStaticMethod * /*decl
}
// QObject *QMetaObject::cast(QObject *obj)
static void _init_f_cast_c1302 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("obj");
decl->add_arg<QObject * > (argspec_0);
decl->set_return<QObject * > ();
}
static void _call_f_cast_c1302 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
QObject *arg1 = gsi::arg_reader<QObject * >() (args, heap);
ret.write<QObject * > ((QObject *)((QMetaObject *)cls)->cast (arg1));
}
// QMetaClassInfo QMetaObject::classInfo(int index)
@ -754,7 +735,6 @@ namespace gsi
static gsi::Methods methods_QMetaObject () {
gsi::Methods methods;
methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QMetaObject::QMetaObject()\nThis method creates an object of class QMetaObject.", &_init_ctor_QMetaObject_0, &_call_ctor_QMetaObject_0);
methods += new qt_gsi::GenericMethod ("cast", "@brief Method QObject *QMetaObject::cast(QObject *obj)\n", true, &_init_f_cast_c1302, &_call_f_cast_c1302);
methods += new qt_gsi::GenericMethod ("classInfo", "@brief Method QMetaClassInfo QMetaObject::classInfo(int index)\n", true, &_init_f_classInfo_c767, &_call_f_classInfo_c767);
methods += new qt_gsi::GenericMethod ("classInfoCount", "@brief Method int QMetaObject::classInfoCount()\n", true, &_init_f_classInfoCount_c0, &_call_f_classInfoCount_c0);
methods += new qt_gsi::GenericMethod ("classInfoOffset", "@brief Method int QMetaObject::classInfoOffset()\n", true, &_init_f_classInfoOffset_c0, &_call_f_classInfoOffset_c0);

23
src/gsiqt/qt4/QtGui/gsiDeclQTextLine.cc
View File

@ -69,28 +69,6 @@ static void _call_f_ascent_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls
}
// double QTextLine::cursorToX(int *cursorPos, QTextLine::Edge edge)
static void _init_f_cursorToX_c2664 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("cursorPos");
decl->add_arg<int * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("edge", true, "QTextLine::Leading");
decl->add_arg<const qt_gsi::Converter<QTextLine::Edge>::target_type & > (argspec_1);
decl->set_return<double > ();
}
static void _call_f_cursorToX_c2664 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
int *arg1 = gsi::arg_reader<int * >() (args, heap);
const qt_gsi::Converter<QTextLine::Edge>::target_type & arg2 = args ? gsi::arg_reader<const qt_gsi::Converter<QTextLine::Edge>::target_type & >() (args, heap) : gsi::arg_maker<const qt_gsi::Converter<QTextLine::Edge>::target_type & >() (qt_gsi::CppToQtReadAdaptor<QTextLine::Edge>(heap, QTextLine::Leading), heap);
ret.write<double > ((double)((QTextLine *)cls)->cursorToX (arg1, qt_gsi::QtToCppAdaptor<QTextLine::Edge>(arg2).cref()));
}
// double QTextLine::cursorToX(int cursorPos, QTextLine::Edge edge)
@ -497,7 +475,6 @@ static gsi::Methods methods_QTextLine () {
gsi::Methods methods;
methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QTextLine::QTextLine()\nThis method creates an object of class QTextLine.", &_init_ctor_QTextLine_0, &_call_ctor_QTextLine_0);
methods += new qt_gsi::GenericMethod ("ascent", "@brief Method double QTextLine::ascent()\n", true, &_init_f_ascent_c0, &_call_f_ascent_c0);
methods += new qt_gsi::GenericMethod ("cursorToX", "@brief Method double QTextLine::cursorToX(int *cursorPos, QTextLine::Edge edge)\n", true, &_init_f_cursorToX_c2664, &_call_f_cursorToX_c2664);
methods += new qt_gsi::GenericMethod ("cursorToX", "@brief Method double QTextLine::cursorToX(int cursorPos, QTextLine::Edge edge)\n", true, &_init_f_cursorToX_c2478, &_call_f_cursorToX_c2478);
methods += new qt_gsi::GenericMethod ("descent", "@brief Method double QTextLine::descent()\n", true, &_init_f_descent_c0, &_call_f_descent_c0);
methods += new qt_gsi::GenericMethod ("draw", "@brief Method void QTextLine::draw(QPainter *p, const QPointF &point, const QTextLayout::FormatRange *selection)\n", true, &_init_f_draw_c6879, &_call_f_draw_c6879);

858
src/gsiqt/qt4/QtXml/gsiDeclQXmlReader.cc
View File

@ -193,25 +193,6 @@ static void _call_f_lexicalHandler_c0 (const qt_gsi::GenericMethod * /*decl*/, v
}
// bool QXmlReader::parse(const QXmlInputSource &input)
static void _init_f_parse_2852 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("input");
decl->add_arg<const QXmlInputSource & > (argspec_0);
decl->set_return<bool > ();
}
static void _call_f_parse_2852 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const QXmlInputSource &arg1 = gsi::arg_reader<const QXmlInputSource & >() (args, heap);
ret.write<bool > ((bool)((QXmlReader *)cls)->parse (arg1));
}
// bool QXmlReader::parse(const QXmlInputSource *input)
@ -419,6 +400,7 @@ static void _call_f_setProperty_2973 (const qt_gsi::GenericMethod * /*decl*/, vo
}
namespace gsi
{
@ -433,7 +415,6 @@ static gsi::Methods methods_QXmlReader () {
methods += new qt_gsi::GenericMethod ("hasFeature", "@brief Method bool QXmlReader::hasFeature(const QString &name)\n", true, &_init_f_hasFeature_c2025, &_call_f_hasFeature_c2025);
methods += new qt_gsi::GenericMethod ("hasProperty", "@brief Method bool QXmlReader::hasProperty(const QString &name)\n", true, &_init_f_hasProperty_c2025, &_call_f_hasProperty_c2025);
methods += new qt_gsi::GenericMethod (":lexicalHandler", "@brief Method QXmlLexicalHandler *QXmlReader::lexicalHandler()\n", true, &_init_f_lexicalHandler_c0, &_call_f_lexicalHandler_c0);
methods += new qt_gsi::GenericMethod ("parse", "@brief Method bool QXmlReader::parse(const QXmlInputSource &input)\n", false, &_init_f_parse_2852, &_call_f_parse_2852);
methods += new qt_gsi::GenericMethod ("parse", "@brief Method bool QXmlReader::parse(const QXmlInputSource *input)\n", false, &_init_f_parse_2856, &_call_f_parse_2856);
methods += new qt_gsi::GenericMethod ("property", "@brief Method void *QXmlReader::property(const QString &name, bool *ok)\n", true, &_init_f_property_c2967, &_call_f_property_c2967);
methods += new qt_gsi::GenericMethod ("setContentHandler|contentHandler=", "@brief Method void QXmlReader::setContentHandler(QXmlContentHandler *handler)\n", false, &_init_f_setContentHandler_2441, &_call_f_setContentHandler_2441);
@ -447,843 +428,10 @@ static gsi::Methods methods_QXmlReader () {
return methods;
}
gsi::Class<QXmlReader> decl_QXmlReader ("QtXml", "QXmlReader_Native",
gsi::Class<QXmlReader> decl_QXmlReader ("QtXml", "QXmlReader",
methods_QXmlReader (),
"@hide\n@alias QXmlReader");
"@qt\n@brief Binding of QXmlReader");
GSI_QTXML_PUBLIC gsi::Class<QXmlReader> &qtdecl_QXmlReader () { return decl_QXmlReader; }
}
class QXmlReader_Adaptor : public QXmlReader, public qt_gsi::QtObjectBase
{
public:
virtual ~QXmlReader_Adaptor();
// [adaptor ctor] QXmlReader::QXmlReader()
QXmlReader_Adaptor() : QXmlReader()
{
qt_gsi::QtObjectBase::init (this);
}
// [adaptor impl] QXmlDTDHandler *QXmlReader::DTDHandler()
QXmlDTDHandler * cbs_DTDHandler_c0_0() const
{
throw qt_gsi::AbstractMethodCalledException("DTDHandler");
}
virtual QXmlDTDHandler * DTDHandler() const
{
if (cb_DTDHandler_c0_0.can_issue()) {
return cb_DTDHandler_c0_0.issue<QXmlReader_Adaptor, QXmlDTDHandler *>(&QXmlReader_Adaptor::cbs_DTDHandler_c0_0);
} else {
throw qt_gsi::AbstractMethodCalledException("DTDHandler");
}
}
// [adaptor impl] QXmlContentHandler *QXmlReader::contentHandler()
QXmlContentHandler * cbs_contentHandler_c0_0() const
{
throw qt_gsi::AbstractMethodCalledException("contentHandler");
}
virtual QXmlContentHandler * contentHandler() const
{
if (cb_contentHandler_c0_0.can_issue()) {
return cb_contentHandler_c0_0.issue<QXmlReader_Adaptor, QXmlContentHandler *>(&QXmlReader_Adaptor::cbs_contentHandler_c0_0);
} else {
throw qt_gsi::AbstractMethodCalledException("contentHandler");
}
}
// [adaptor impl] QXmlDeclHandler *QXmlReader::declHandler()
QXmlDeclHandler * cbs_declHandler_c0_0() const
{
throw qt_gsi::AbstractMethodCalledException("declHandler");
}
virtual QXmlDeclHandler * declHandler() const
{
if (cb_declHandler_c0_0.can_issue()) {
return cb_declHandler_c0_0.issue<QXmlReader_Adaptor, QXmlDeclHandler *>(&QXmlReader_Adaptor::cbs_declHandler_c0_0);
} else {
throw qt_gsi::AbstractMethodCalledException("declHandler");
}
}
// [adaptor impl] QXmlEntityResolver *QXmlReader::entityResolver()
QXmlEntityResolver * cbs_entityResolver_c0_0() const
{
throw qt_gsi::AbstractMethodCalledException("entityResolver");
}
virtual QXmlEntityResolver * entityResolver() const
{
if (cb_entityResolver_c0_0.can_issue()) {
return cb_entityResolver_c0_0.issue<QXmlReader_Adaptor, QXmlEntityResolver *>(&QXmlReader_Adaptor::cbs_entityResolver_c0_0);
} else {
throw qt_gsi::AbstractMethodCalledException("entityResolver");
}
}
// [adaptor impl] QXmlErrorHandler *QXmlReader::errorHandler()
QXmlErrorHandler * cbs_errorHandler_c0_0() const
{
throw qt_gsi::AbstractMethodCalledException("errorHandler");
}
virtual QXmlErrorHandler * errorHandler() const
{
if (cb_errorHandler_c0_0.can_issue()) {
return cb_errorHandler_c0_0.issue<QXmlReader_Adaptor, QXmlErrorHandler *>(&QXmlReader_Adaptor::cbs_errorHandler_c0_0);
} else {
throw qt_gsi::AbstractMethodCalledException("errorHandler");
}
}
// [adaptor impl] bool QXmlReader::feature(const QString &name, bool *ok)
bool cbs_feature_c2967_1(const QString &name, bool *ok) const
{
__SUPPRESS_UNUSED_WARNING (name);
__SUPPRESS_UNUSED_WARNING (ok);
throw qt_gsi::AbstractMethodCalledException("feature");
}
virtual bool feature(const QString &name, bool *ok) const
{
if (cb_feature_c2967_1.can_issue()) {
return cb_feature_c2967_1.issue<QXmlReader_Adaptor, bool, const QString &, bool *>(&QXmlReader_Adaptor::cbs_feature_c2967_1, name, ok);
} else {
throw qt_gsi::AbstractMethodCalledException("feature");
}
}
// [adaptor impl] bool QXmlReader::hasFeature(const QString &name)
bool cbs_hasFeature_c2025_0(const QString &name) const
{
__SUPPRESS_UNUSED_WARNING (name);
throw qt_gsi::AbstractMethodCalledException("hasFeature");
}
virtual bool hasFeature(const QString &name) const
{
if (cb_hasFeature_c2025_0.can_issue()) {
return cb_hasFeature_c2025_0.issue<QXmlReader_Adaptor, bool, const QString &>(&QXmlReader_Adaptor::cbs_hasFeature_c2025_0, name);
} else {
throw qt_gsi::AbstractMethodCalledException("hasFeature");
}
}
// [adaptor impl] bool QXmlReader::hasProperty(const QString &name)
bool cbs_hasProperty_c2025_0(const QString &name) const
{
__SUPPRESS_UNUSED_WARNING (name);
throw qt_gsi::AbstractMethodCalledException("hasProperty");
}
virtual bool hasProperty(const QString &name) const
{
if (cb_hasProperty_c2025_0.can_issue()) {
return cb_hasProperty_c2025_0.issue<QXmlReader_Adaptor, bool, const QString &>(&QXmlReader_Adaptor::cbs_hasProperty_c2025_0, name);
} else {
throw qt_gsi::AbstractMethodCalledException("hasProperty");
}
}
// [adaptor impl] QXmlLexicalHandler *QXmlReader::lexicalHandler()
QXmlLexicalHandler * cbs_lexicalHandler_c0_0() const
{
throw qt_gsi::AbstractMethodCalledException("lexicalHandler");
}
virtual QXmlLexicalHandler * lexicalHandler() const
{
if (cb_lexicalHandler_c0_0.can_issue()) {
return cb_lexicalHandler_c0_0.issue<QXmlReader_Adaptor, QXmlLexicalHandler *>(&QXmlReader_Adaptor::cbs_lexicalHandler_c0_0);
} else {
throw qt_gsi::AbstractMethodCalledException("lexicalHandler");
}
}
// [adaptor impl] bool QXmlReader::parse(const QXmlInputSource &input)
bool cbs_parse_2852_0(const QXmlInputSource &input)
{
__SUPPRESS_UNUSED_WARNING (input);
throw qt_gsi::AbstractMethodCalledException("parse");
}
virtual bool parse(const QXmlInputSource &input)
{
if (cb_parse_2852_0.can_issue()) {
return cb_parse_2852_0.issue<QXmlReader_Adaptor, bool, const QXmlInputSource &>(&QXmlReader_Adaptor::cbs_parse_2852_0, input);
} else {
throw qt_gsi::AbstractMethodCalledException("parse");
}
}
// [adaptor impl] bool QXmlReader::parse(const QXmlInputSource *input)
bool cbs_parse_2856_0(const QXmlInputSource *input)
{
__SUPPRESS_UNUSED_WARNING (input);
throw qt_gsi::AbstractMethodCalledException("parse");
}
virtual bool parse(const QXmlInputSource *input)
{
if (cb_parse_2856_0.can_issue()) {
return cb_parse_2856_0.issue<QXmlReader_Adaptor, bool, const QXmlInputSource *>(&QXmlReader_Adaptor::cbs_parse_2856_0, input);
} else {
throw qt_gsi::AbstractMethodCalledException("parse");
}
}
// [adaptor impl] void *QXmlReader::property(const QString &name, bool *ok)
void * cbs_property_c2967_1(const QString &name, bool *ok) const
{
__SUPPRESS_UNUSED_WARNING (name);
__SUPPRESS_UNUSED_WARNING (ok);
throw qt_gsi::AbstractMethodCalledException("property");
}
virtual void * property(const QString &name, bool *ok) const
{
if (cb_property_c2967_1.can_issue()) {
return cb_property_c2967_1.issue<QXmlReader_Adaptor, void *, const QString &, bool *>(&QXmlReader_Adaptor::cbs_property_c2967_1, name, ok);
} else {
throw qt_gsi::AbstractMethodCalledException("property");
}
}
// [adaptor impl] void QXmlReader::setContentHandler(QXmlContentHandler *handler)
void cbs_setContentHandler_2441_0(QXmlContentHandler *handler)
{
__SUPPRESS_UNUSED_WARNING (handler);
throw qt_gsi::AbstractMethodCalledException("setContentHandler");
}
virtual void setContentHandler(QXmlContentHandler *handler)
{
if (cb_setContentHandler_2441_0.can_issue()) {
cb_setContentHandler_2441_0.issue<QXmlReader_Adaptor, QXmlContentHandler *>(&QXmlReader_Adaptor::cbs_setContentHandler_2441_0, handler);
} else {
throw qt_gsi::AbstractMethodCalledException("setContentHandler");
}
}
// [adaptor impl] void QXmlReader::setDTDHandler(QXmlDTDHandler *handler)
void cbs_setDTDHandler_1930_0(QXmlDTDHandler *handler)
{
__SUPPRESS_UNUSED_WARNING (handler);
throw qt_gsi::AbstractMethodCalledException("setDTDHandler");
}
virtual void setDTDHandler(QXmlDTDHandler *handler)
{
if (cb_setDTDHandler_1930_0.can_issue()) {
cb_setDTDHandler_1930_0.issue<QXmlReader_Adaptor, QXmlDTDHandler *>(&QXmlReader_Adaptor::cbs_setDTDHandler_1930_0, handler);
} else {
throw qt_gsi::AbstractMethodCalledException("setDTDHandler");
}
}
// [adaptor impl] void QXmlReader::setDeclHandler(QXmlDeclHandler *handler)
void cbs_setDeclHandler_2086_0(QXmlDeclHandler *handler)
{
__SUPPRESS_UNUSED_WARNING (handler);
throw qt_gsi::AbstractMethodCalledException("setDeclHandler");
}
virtual void setDeclHandler(QXmlDeclHandler *handler)
{
if (cb_setDeclHandler_2086_0.can_issue()) {
cb_setDeclHandler_2086_0.issue<QXmlReader_Adaptor, QXmlDeclHandler *>(&QXmlReader_Adaptor::cbs_setDeclHandler_2086_0, handler);
} else {
throw qt_gsi::AbstractMethodCalledException("setDeclHandler");
}
}
// [adaptor impl] void QXmlReader::setEntityResolver(QXmlEntityResolver *handler)
void cbs_setEntityResolver_2495_0(QXmlEntityResolver *handler)
{
__SUPPRESS_UNUSED_WARNING (handler);
throw qt_gsi::AbstractMethodCalledException("setEntityResolver");
}
virtual void setEntityResolver(QXmlEntityResolver *handler)
{
if (cb_setEntityResolver_2495_0.can_issue()) {
cb_setEntityResolver_2495_0.issue<QXmlReader_Adaptor, QXmlEntityResolver *>(&QXmlReader_Adaptor::cbs_setEntityResolver_2495_0, handler);
} else {
throw qt_gsi::AbstractMethodCalledException("setEntityResolver");
}
}
// [adaptor impl] void QXmlReader::setErrorHandler(QXmlErrorHandler *handler)
void cbs_setErrorHandler_2232_0(QXmlErrorHandler *handler)
{
__SUPPRESS_UNUSED_WARNING (handler);
throw qt_gsi::AbstractMethodCalledException("setErrorHandler");
}
virtual void setErrorHandler(QXmlErrorHandler *handler)
{
if (cb_setErrorHandler_2232_0.can_issue()) {
cb_setErrorHandler_2232_0.issue<QXmlReader_Adaptor, QXmlErrorHandler *>(&QXmlReader_Adaptor::cbs_setErrorHandler_2232_0, handler);
} else {
throw qt_gsi::AbstractMethodCalledException("setErrorHandler");
}
}
// [adaptor impl] void QXmlReader::setFeature(const QString &name, bool value)
void cbs_setFeature_2781_0(const QString &name, bool value)
{
__SUPPRESS_UNUSED_WARNING (name);
__SUPPRESS_UNUSED_WARNING (value);
throw qt_gsi::AbstractMethodCalledException("setFeature");
}
virtual void setFeature(const QString &name, bool value)
{
if (cb_setFeature_2781_0.can_issue()) {
cb_setFeature_2781_0.issue<QXmlReader_Adaptor, const QString &, bool>(&QXmlReader_Adaptor::cbs_setFeature_2781_0, name, value);
} else {
throw qt_gsi::AbstractMethodCalledException("setFeature");
}
}
// [adaptor impl] void QXmlReader::setLexicalHandler(QXmlLexicalHandler *handler)
void cbs_setLexicalHandler_2416_0(QXmlLexicalHandler *handler)
{
__SUPPRESS_UNUSED_WARNING (handler);
throw qt_gsi::AbstractMethodCalledException("setLexicalHandler");
}
virtual void setLexicalHandler(QXmlLexicalHandler *handler)
{
if (cb_setLexicalHandler_2416_0.can_issue()) {
cb_setLexicalHandler_2416_0.issue<QXmlReader_Adaptor, QXmlLexicalHandler *>(&QXmlReader_Adaptor::cbs_setLexicalHandler_2416_0, handler);
} else {
throw qt_gsi::AbstractMethodCalledException("setLexicalHandler");
}
}
// [adaptor impl] void QXmlReader::setProperty(const QString &name, void *value)
void cbs_setProperty_2973_0(const QString &name, void *value)
{
__SUPPRESS_UNUSED_WARNING (name);
__SUPPRESS_UNUSED_WARNING (value);
throw qt_gsi::AbstractMethodCalledException("setProperty");
}
virtual void setProperty(const QString &name, void *value)
{
if (cb_setProperty_2973_0.can_issue()) {
cb_setProperty_2973_0.issue<QXmlReader_Adaptor, const QString &, void *>(&QXmlReader_Adaptor::cbs_setProperty_2973_0, name, value);
} else {
throw qt_gsi::AbstractMethodCalledException("setProperty");
}
}
gsi::Callback cb_DTDHandler_c0_0;
gsi::Callback cb_contentHandler_c0_0;
gsi::Callback cb_declHandler_c0_0;
gsi::Callback cb_entityResolver_c0_0;
gsi::Callback cb_errorHandler_c0_0;
gsi::Callback cb_feature_c2967_1;
gsi::Callback cb_hasFeature_c2025_0;
gsi::Callback cb_hasProperty_c2025_0;
gsi::Callback cb_lexicalHandler_c0_0;
gsi::Callback cb_parse_2852_0;
gsi::Callback cb_parse_2856_0;
gsi::Callback cb_property_c2967_1;
gsi::Callback cb_setContentHandler_2441_0;
gsi::Callback cb_setDTDHandler_1930_0;
gsi::Callback cb_setDeclHandler_2086_0;
gsi::Callback cb_setEntityResolver_2495_0;
gsi::Callback cb_setErrorHandler_2232_0;
gsi::Callback cb_setFeature_2781_0;
gsi::Callback cb_setLexicalHandler_2416_0;
gsi::Callback cb_setProperty_2973_0;
};
QXmlReader_Adaptor::~QXmlReader_Adaptor() { }
// Constructor QXmlReader::QXmlReader() (adaptor class)
static void _init_ctor_QXmlReader_Adaptor_0 (qt_gsi::GenericStaticMethod *decl)
{
decl->set_return_new<QXmlReader_Adaptor> ();
}
static void _call_ctor_QXmlReader_Adaptor_0 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
ret.write<QXmlReader_Adaptor *> (new QXmlReader_Adaptor ());
}
// QXmlDTDHandler *QXmlReader::DTDHandler()
static void _init_cbs_DTDHandler_c0_0 (qt_gsi::GenericMethod *decl)
{
decl->set_return<QXmlDTDHandler * > ();
}
static void _call_cbs_DTDHandler_c0_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
ret.write<QXmlDTDHandler * > ((QXmlDTDHandler *)((QXmlReader_Adaptor *)cls)->cbs_DTDHandler_c0_0 ());
}
static void _set_callback_cbs_DTDHandler_c0_0 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_DTDHandler_c0_0 = cb;
}
// QXmlContentHandler *QXmlReader::contentHandler()
static void _init_cbs_contentHandler_c0_0 (qt_gsi::GenericMethod *decl)
{
decl->set_return<QXmlContentHandler * > ();
}
static void _call_cbs_contentHandler_c0_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
ret.write<QXmlContentHandler * > ((QXmlContentHandler *)((QXmlReader_Adaptor *)cls)->cbs_contentHandler_c0_0 ());
}
static void _set_callback_cbs_contentHandler_c0_0 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_contentHandler_c0_0 = cb;
}
// QXmlDeclHandler *QXmlReader::declHandler()
static void _init_cbs_declHandler_c0_0 (qt_gsi::GenericMethod *decl)
{
decl->set_return<QXmlDeclHandler * > ();
}
static void _call_cbs_declHandler_c0_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
ret.write<QXmlDeclHandler * > ((QXmlDeclHandler *)((QXmlReader_Adaptor *)cls)->cbs_declHandler_c0_0 ());
}
static void _set_callback_cbs_declHandler_c0_0 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_declHandler_c0_0 = cb;
}
// QXmlEntityResolver *QXmlReader::entityResolver()
static void _init_cbs_entityResolver_c0_0 (qt_gsi::GenericMethod *decl)
{
decl->set_return<QXmlEntityResolver * > ();
}
static void _call_cbs_entityResolver_c0_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
ret.write<QXmlEntityResolver * > ((QXmlEntityResolver *)((QXmlReader_Adaptor *)cls)->cbs_entityResolver_c0_0 ());
}
static void _set_callback_cbs_entityResolver_c0_0 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_entityResolver_c0_0 = cb;
}
// QXmlErrorHandler *QXmlReader::errorHandler()
static void _init_cbs_errorHandler_c0_0 (qt_gsi::GenericMethod *decl)
{
decl->set_return<QXmlErrorHandler * > ();
}
static void _call_cbs_errorHandler_c0_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
ret.write<QXmlErrorHandler * > ((QXmlErrorHandler *)((QXmlReader_Adaptor *)cls)->cbs_errorHandler_c0_0 ());
}
static void _set_callback_cbs_errorHandler_c0_0 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_errorHandler_c0_0 = cb;
}
// bool QXmlReader::feature(const QString &name, bool *ok)
static void _init_cbs_feature_c2967_1 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("name");
decl->add_arg<const QString & > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("ok");
decl->add_arg<bool * > (argspec_1);
decl->set_return<bool > ();
}
static void _call_cbs_feature_c2967_1 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const QString &arg1 = args.read<const QString & > (heap);
bool *arg2 = args.read<bool * > (heap);
ret.write<bool > ((bool)((QXmlReader_Adaptor *)cls)->cbs_feature_c2967_1 (arg1, arg2));
}
static void _set_callback_cbs_feature_c2967_1 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_feature_c2967_1 = cb;
}
// bool QXmlReader::hasFeature(const QString &name)
static void _init_cbs_hasFeature_c2025_0 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("name");
decl->add_arg<const QString & > (argspec_0);
decl->set_return<bool > ();
}
static void _call_cbs_hasFeature_c2025_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const QString &arg1 = args.read<const QString & > (heap);
ret.write<bool > ((bool)((QXmlReader_Adaptor *)cls)->cbs_hasFeature_c2025_0 (arg1));
}
static void _set_callback_cbs_hasFeature_c2025_0 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_hasFeature_c2025_0 = cb;
}
// bool QXmlReader::hasProperty(const QString &name)
static void _init_cbs_hasProperty_c2025_0 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("name");
decl->add_arg<const QString & > (argspec_0);
decl->set_return<bool > ();
}
static void _call_cbs_hasProperty_c2025_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const QString &arg1 = args.read<const QString & > (heap);
ret.write<bool > ((bool)((QXmlReader_Adaptor *)cls)->cbs_hasProperty_c2025_0 (arg1));
}
static void _set_callback_cbs_hasProperty_c2025_0 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_hasProperty_c2025_0 = cb;
}
// QXmlLexicalHandler *QXmlReader::lexicalHandler()
static void _init_cbs_lexicalHandler_c0_0 (qt_gsi::GenericMethod *decl)
{
decl->set_return<QXmlLexicalHandler * > ();
}
static void _call_cbs_lexicalHandler_c0_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
ret.write<QXmlLexicalHandler * > ((QXmlLexicalHandler *)((QXmlReader_Adaptor *)cls)->cbs_lexicalHandler_c0_0 ());
}
static void _set_callback_cbs_lexicalHandler_c0_0 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_lexicalHandler_c0_0 = cb;
}
// bool QXmlReader::parse(const QXmlInputSource &input)
static void _init_cbs_parse_2852_0 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("input");
decl->add_arg<const QXmlInputSource & > (argspec_0);
decl->set_return<bool > ();
}
static void _call_cbs_parse_2852_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const QXmlInputSource &arg1 = args.read<const QXmlInputSource & > (heap);
ret.write<bool > ((bool)((QXmlReader_Adaptor *)cls)->cbs_parse_2852_0 (arg1));
}
static void _set_callback_cbs_parse_2852_0 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_parse_2852_0 = cb;
}
// bool QXmlReader::parse(const QXmlInputSource *input)
static void _init_cbs_parse_2856_0 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("input");
decl->add_arg<const QXmlInputSource * > (argspec_0);
decl->set_return<bool > ();
}
static void _call_cbs_parse_2856_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const QXmlInputSource *arg1 = args.read<const QXmlInputSource * > (heap);
ret.write<bool > ((bool)((QXmlReader_Adaptor *)cls)->cbs_parse_2856_0 (arg1));
}
static void _set_callback_cbs_parse_2856_0 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_parse_2856_0 = cb;
}
// void *QXmlReader::property(const QString &name, bool *ok)
static void _init_cbs_property_c2967_1 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("name");
decl->add_arg<const QString & > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("ok");
decl->add_arg<bool * > (argspec_1);
decl->set_return<void * > ();
}
static void _call_cbs_property_c2967_1 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const QString &arg1 = args.read<const QString & > (heap);
bool *arg2 = args.read<bool * > (heap);
ret.write<void * > ((void *)((QXmlReader_Adaptor *)cls)->cbs_property_c2967_1 (arg1, arg2));
}
static void _set_callback_cbs_property_c2967_1 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_property_c2967_1 = cb;
}
// void QXmlReader::setContentHandler(QXmlContentHandler *handler)
static void _init_cbs_setContentHandler_2441_0 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("handler");
decl->add_arg<QXmlContentHandler * > (argspec_0);
decl->set_return<void > ();
}
static void _call_cbs_setContentHandler_2441_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
QXmlContentHandler *arg1 = args.read<QXmlContentHandler * > (heap);
__SUPPRESS_UNUSED_WARNING(ret);
((QXmlReader_Adaptor *)cls)->cbs_setContentHandler_2441_0 (arg1);
}
static void _set_callback_cbs_setContentHandler_2441_0 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_setContentHandler_2441_0 = cb;
}
// void QXmlReader::setDTDHandler(QXmlDTDHandler *handler)
static void _init_cbs_setDTDHandler_1930_0 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("handler");
decl->add_arg<QXmlDTDHandler * > (argspec_0);
decl->set_return<void > ();
}
static void _call_cbs_setDTDHandler_1930_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
QXmlDTDHandler *arg1 = args.read<QXmlDTDHandler * > (heap);
__SUPPRESS_UNUSED_WARNING(ret);
((QXmlReader_Adaptor *)cls)->cbs_setDTDHandler_1930_0 (arg1);
}
static void _set_callback_cbs_setDTDHandler_1930_0 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_setDTDHandler_1930_0 = cb;
}
// void QXmlReader::setDeclHandler(QXmlDeclHandler *handler)
static void _init_cbs_setDeclHandler_2086_0 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("handler");
decl->add_arg<QXmlDeclHandler * > (argspec_0);
decl->set_return<void > ();
}
static void _call_cbs_setDeclHandler_2086_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
QXmlDeclHandler *arg1 = args.read<QXmlDeclHandler * > (heap);
__SUPPRESS_UNUSED_WARNING(ret);
((QXmlReader_Adaptor *)cls)->cbs_setDeclHandler_2086_0 (arg1);
}
static void _set_callback_cbs_setDeclHandler_2086_0 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_setDeclHandler_2086_0 = cb;
}
// void QXmlReader::setEntityResolver(QXmlEntityResolver *handler)
static void _init_cbs_setEntityResolver_2495_0 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("handler");
decl->add_arg<QXmlEntityResolver * > (argspec_0);
decl->set_return<void > ();
}
static void _call_cbs_setEntityResolver_2495_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
QXmlEntityResolver *arg1 = args.read<QXmlEntityResolver * > (heap);
__SUPPRESS_UNUSED_WARNING(ret);
((QXmlReader_Adaptor *)cls)->cbs_setEntityResolver_2495_0 (arg1);
}
static void _set_callback_cbs_setEntityResolver_2495_0 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_setEntityResolver_2495_0 = cb;
}
// void QXmlReader::setErrorHandler(QXmlErrorHandler *handler)
static void _init_cbs_setErrorHandler_2232_0 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("handler");
decl->add_arg<QXmlErrorHandler * > (argspec_0);
decl->set_return<void > ();
}
static void _call_cbs_setErrorHandler_2232_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
QXmlErrorHandler *arg1 = args.read<QXmlErrorHandler * > (heap);
__SUPPRESS_UNUSED_WARNING(ret);
((QXmlReader_Adaptor *)cls)->cbs_setErrorHandler_2232_0 (arg1);
}
static void _set_callback_cbs_setErrorHandler_2232_0 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_setErrorHandler_2232_0 = cb;
}
// void QXmlReader::setFeature(const QString &name, bool value)
static void _init_cbs_setFeature_2781_0 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("name");
decl->add_arg<const QString & > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("value");
decl->add_arg<bool > (argspec_1);
decl->set_return<void > ();
}
static void _call_cbs_setFeature_2781_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const QString &arg1 = args.read<const QString & > (heap);
bool arg2 = args.read<bool > (heap);
__SUPPRESS_UNUSED_WARNING(ret);
((QXmlReader_Adaptor *)cls)->cbs_setFeature_2781_0 (arg1, arg2);
}
static void _set_callback_cbs_setFeature_2781_0 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_setFeature_2781_0 = cb;
}
// void QXmlReader::setLexicalHandler(QXmlLexicalHandler *handler)
static void _init_cbs_setLexicalHandler_2416_0 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("handler");
decl->add_arg<QXmlLexicalHandler * > (argspec_0);
decl->set_return<void > ();
}
static void _call_cbs_setLexicalHandler_2416_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
QXmlLexicalHandler *arg1 = args.read<QXmlLexicalHandler * > (heap);
__SUPPRESS_UNUSED_WARNING(ret);
((QXmlReader_Adaptor *)cls)->cbs_setLexicalHandler_2416_0 (arg1);
}
static void _set_callback_cbs_setLexicalHandler_2416_0 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_setLexicalHandler_2416_0 = cb;
}
// void QXmlReader::setProperty(const QString &name, void *value)
static void _init_cbs_setProperty_2973_0 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("name");
decl->add_arg<const QString & > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("value");
decl->add_arg<void * > (argspec_1);
decl->set_return<void > ();
}
static void _call_cbs_setProperty_2973_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const QString &arg1 = args.read<const QString & > (heap);
void *arg2 = args.read<void * > (heap);
__SUPPRESS_UNUSED_WARNING(ret);
((QXmlReader_Adaptor *)cls)->cbs_setProperty_2973_0 (arg1, arg2);
}
static void _set_callback_cbs_setProperty_2973_0 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_setProperty_2973_0 = cb;
}
namespace gsi
{
gsi::Class<QXmlReader> &qtdecl_QXmlReader ();
static gsi::Methods methods_QXmlReader_Adaptor () {
gsi::Methods methods;

6
src/gsiqt/qt4/QtXml/gsiDeclQtXmlTypeTraits.h
View File

@ -387,12 +387,6 @@ template <> struct type_traits<QXmlReader> : public type_traits<void> {
};
}
class QXmlReader_Adaptor;
namespace tl {
template <> struct type_traits<QXmlReader_Adaptor> : public type_traits<void> {
};
}
class QXmlSimpleReader;
namespace tl {
template <> struct type_traits<QXmlSimpleReader> : public type_traits<void> {

23
src/gsiqt/qt5/QtCore/gsiDeclQCollator.cc
View File

@ -113,28 +113,6 @@ static void _call_f_compare_c3942 (const qt_gsi::GenericMethod * /*decl*/, void
}
// int QCollator::compare(const QStringRef &s1, const QStringRef &s2)
static void _init_f_compare_c4512 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s1");
decl->add_arg<const QStringRef & > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("s2");
decl->add_arg<const QStringRef & > (argspec_1);
decl->set_return<int > ();
}
static void _call_f_compare_c4512 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const QStringRef &arg1 = gsi::arg_reader<const QStringRef & >() (args, heap);
const QStringRef &arg2 = gsi::arg_reader<const QStringRef & >() (args, heap);
ret.write<int > ((int)((QCollator *)cls)->compare (arg1, arg2));
}
// int QCollator::compare(const QChar *s1, int len1, const QChar *s2, int len2)
@ -378,7 +356,6 @@ static gsi::Methods methods_QCollator () {
methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QCollator::QCollator(const QCollator &)\nThis method creates an object of class QCollator.", &_init_ctor_QCollator_2226, &_call_ctor_QCollator_2226);
methods += new qt_gsi::GenericMethod (":caseSensitivity", "@brief Method Qt::CaseSensitivity QCollator::caseSensitivity()\n", true, &_init_f_caseSensitivity_c0, &_call_f_caseSensitivity_c0);
methods += new qt_gsi::GenericMethod ("compare", "@brief Method int QCollator::compare(const QString &s1, const QString &s2)\n", true, &_init_f_compare_c3942, &_call_f_compare_c3942);
methods += new qt_gsi::GenericMethod ("compare", "@brief Method int QCollator::compare(const QStringRef &s1, const QStringRef &s2)\n", true, &_init_f_compare_c4512, &_call_f_compare_c4512);
methods += new qt_gsi::GenericMethod ("compare", "@brief Method int QCollator::compare(const QChar *s1, int len1, const QChar *s2, int len2)\n", true, &_init_f_compare_c4770, &_call_f_compare_c4770);
methods += new qt_gsi::GenericMethod (":ignorePunctuation", "@brief Method bool QCollator::ignorePunctuation()\n", true, &_init_f_ignorePunctuation_c0, &_call_f_ignorePunctuation_c0);
methods += new qt_gsi::GenericMethod (":locale", "@brief Method QLocale QCollator::locale()\n", true, &_init_f_locale_c0, &_call_f_locale_c0);

40
src/gsiqt/qt5/QtCore/gsiDeclQJsonValue.cc
View File

@ -95,25 +95,6 @@ static void _call_ctor_QJsonValue_1071 (const qt_gsi::GenericStaticMethod * /*de
}
// Constructor QJsonValue::QJsonValue(int n)
static void _init_ctor_QJsonValue_767 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("n");
decl->add_arg<int > (argspec_0);
decl->set_return_new<QJsonValue> ();
}
static void _call_ctor_QJsonValue_767 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
int arg1 = gsi::arg_reader<int >() (args, heap);
ret.write<QJsonValue *> (new QJsonValue (arg1));
}
// Constructor QJsonValue::QJsonValue(qint64 n)
@ -152,25 +133,6 @@ static void _call_ctor_QJsonValue_2025 (const qt_gsi::GenericStaticMethod * /*de
}
// Constructor QJsonValue::QJsonValue(const char *s)
static void _init_ctor_QJsonValue_1731 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const char * > (argspec_0);
decl->set_return_new<QJsonValue> ();
}
static void _call_ctor_QJsonValue_1731 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
ret.write<QJsonValue *> (new QJsonValue (arg1));
}
// Constructor QJsonValue::QJsonValue(const QJsonArray &a)
@ -592,10 +554,8 @@ static gsi::Methods methods_QJsonValue () {
methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QJsonValue::QJsonValue(QJsonValue::Type)\nThis method creates an object of class QJsonValue.", &_init_ctor_QJsonValue_1970, &_call_ctor_QJsonValue_1970);
methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QJsonValue::QJsonValue(bool b)\nThis method creates an object of class QJsonValue.", &_init_ctor_QJsonValue_864, &_call_ctor_QJsonValue_864);
methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QJsonValue::QJsonValue(double n)\nThis method creates an object of class QJsonValue.", &_init_ctor_QJsonValue_1071, &_call_ctor_QJsonValue_1071);
methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QJsonValue::QJsonValue(int n)\nThis method creates an object of class QJsonValue.", &_init_ctor_QJsonValue_767, &_call_ctor_QJsonValue_767);
methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QJsonValue::QJsonValue(qint64 n)\nThis method creates an object of class QJsonValue.", &_init_ctor_QJsonValue_986, &_call_ctor_QJsonValue_986);
methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QJsonValue::QJsonValue(const QString &s)\nThis method creates an object of class QJsonValue.", &_init_ctor_QJsonValue_2025, &_call_ctor_QJsonValue_2025);
methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QJsonValue::QJsonValue(const char *s)\nThis method creates an object of class QJsonValue.", &_init_ctor_QJsonValue_1731, &_call_ctor_QJsonValue_1731);
methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QJsonValue::QJsonValue(const QJsonArray &a)\nThis method creates an object of class QJsonValue.", &_init_ctor_QJsonValue_2315, &_call_ctor_QJsonValue_2315);
methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QJsonValue::QJsonValue(const QJsonObject &o)\nThis method creates an object of class QJsonValue.", &_init_ctor_QJsonValue_2403, &_call_ctor_QJsonValue_2403);
methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QJsonValue::QJsonValue(const QJsonValue &other)\nThis method creates an object of class QJsonValue.", &_init_ctor_QJsonValue_2313, &_call_ctor_QJsonValue_2313);

207
src/gsiqt/qt5/QtCore/gsiDeclQLocale.cc
View File

@ -593,28 +593,6 @@ static void _call_f_quoteString_c4635 (const qt_gsi::GenericMethod * /*decl*/, v
}
// QString QLocale::quoteString(const QStringRef &str, QLocale::QuotationStyle style)
static void _init_f_quoteString_c4920 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("str");
decl->add_arg<const QStringRef & > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("style", true, "QLocale::StandardQuotation");
decl->add_arg<const qt_gsi::Converter<QLocale::QuotationStyle>::target_type & > (argspec_1);
decl->set_return<QString > ();
}
static void _call_f_quoteString_c4920 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const QStringRef &arg1 = gsi::arg_reader<const QStringRef & >() (args, heap);
const qt_gsi::Converter<QLocale::QuotationStyle>::target_type & arg2 = args ? gsi::arg_reader<const qt_gsi::Converter<QLocale::QuotationStyle>::target_type & >() (args, heap) : gsi::arg_maker<const qt_gsi::Converter<QLocale::QuotationStyle>::target_type & >() (qt_gsi::CppToQtReadAdaptor<QLocale::QuotationStyle>(heap, QLocale::StandardQuotation), heap);
ret.write<QString > ((QString)((QLocale *)cls)->quoteString (arg1, qt_gsi::QtToCppAdaptor<QLocale::QuotationStyle>(arg2).cref()));
}
// QLocale::Script QLocale::script()
@ -1014,28 +992,6 @@ static void _call_f_toDouble_c2967 (const qt_gsi::GenericMethod * /*decl*/, void
}
// double QLocale::toDouble(const QStringRef &s, bool *ok)
static void _init_f_toDouble_c3252 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const QStringRef & > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("ok", true, "0");
decl->add_arg<bool * > (argspec_1);
decl->set_return<double > ();
}
static void _call_f_toDouble_c3252 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const QStringRef &arg1 = gsi::arg_reader<const QStringRef & >() (args, heap);
bool *arg2 = args ? gsi::arg_reader<bool * >() (args, heap) : gsi::arg_maker<bool * >() (0, heap);
ret.write<double > ((double)((QLocale *)cls)->toDouble (arg1, arg2));
}
// float QLocale::toFloat(const QString &s, bool *ok)
@ -1058,28 +1014,6 @@ static void _call_f_toFloat_c2967 (const qt_gsi::GenericMethod * /*decl*/, void
}
// float QLocale::toFloat(const QStringRef &s, bool *ok)
static void _init_f_toFloat_c3252 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const QStringRef & > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("ok", true, "0");
decl->add_arg<bool * > (argspec_1);
decl->set_return<float > ();
}
static void _call_f_toFloat_c3252 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const QStringRef &arg1 = gsi::arg_reader<const QStringRef & >() (args, heap);
bool *arg2 = args ? gsi::arg_reader<bool * >() (args, heap) : gsi::arg_maker<bool * >() (0, heap);
ret.write<float > ((float)((QLocale *)cls)->toFloat (arg1, arg2));
}
// int QLocale::toInt(const QString &s, bool *ok)
@ -1102,28 +1036,6 @@ static void _call_f_toInt_c2967 (const qt_gsi::GenericMethod * /*decl*/, void *c
}
// int QLocale::toInt(const QStringRef &s, bool *ok)
static void _init_f_toInt_c3252 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const QStringRef & > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("ok", true, "0");
decl->add_arg<bool * > (argspec_1);
decl->set_return<int > ();
}
static void _call_f_toInt_c3252 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const QStringRef &arg1 = gsi::arg_reader<const QStringRef & >() (args, heap);
bool *arg2 = args ? gsi::arg_reader<bool * >() (args, heap) : gsi::arg_maker<bool * >() (0, heap);
ret.write<int > ((int)((QLocale *)cls)->toInt (arg1, arg2));
}
// qlonglong QLocale::toLongLong(const QString &s, bool *ok)
@ -1146,28 +1058,6 @@ static void _call_f_toLongLong_c2967 (const qt_gsi::GenericMethod * /*decl*/, vo
}
// qlonglong QLocale::toLongLong(const QStringRef &s, bool *ok)
static void _init_f_toLongLong_c3252 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const QStringRef & > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("ok", true, "0");
decl->add_arg<bool * > (argspec_1);
decl->set_return<qlonglong > ();
}
static void _call_f_toLongLong_c3252 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const QStringRef &arg1 = gsi::arg_reader<const QStringRef & >() (args, heap);
bool *arg2 = args ? gsi::arg_reader<bool * >() (args, heap) : gsi::arg_maker<bool * >() (0, heap);
ret.write<qlonglong > ((qlonglong)((QLocale *)cls)->toLongLong (arg1, arg2));
}
// QString QLocale::toLower(const QString &str)
@ -1209,28 +1099,6 @@ static void _call_f_toShort_c2967 (const qt_gsi::GenericMethod * /*decl*/, void
}
// short int QLocale::toShort(const QStringRef &s, bool *ok)
static void _init_f_toShort_c3252 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const QStringRef & > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("ok", true, "0");
decl->add_arg<bool * > (argspec_1);
decl->set_return<short int > ();
}
static void _call_f_toShort_c3252 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const QStringRef &arg1 = gsi::arg_reader<const QStringRef & >() (args, heap);
bool *arg2 = args ? gsi::arg_reader<bool * >() (args, heap) : gsi::arg_maker<bool * >() (0, heap);
ret.write<short int > ((short int)((QLocale *)cls)->toShort (arg1, arg2));
}
// QString QLocale::toString(qlonglong i)
@ -1593,28 +1461,6 @@ static void _call_f_toUInt_c2967 (const qt_gsi::GenericMethod * /*decl*/, void *
}
// unsigned int QLocale::toUInt(const QStringRef &s, bool *ok)
static void _init_f_toUInt_c3252 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const QStringRef & > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("ok", true, "0");
decl->add_arg<bool * > (argspec_1);
decl->set_return<unsigned int > ();
}
static void _call_f_toUInt_c3252 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const QStringRef &arg1 = gsi::arg_reader<const QStringRef & >() (args, heap);
bool *arg2 = args ? gsi::arg_reader<bool * >() (args, heap) : gsi::arg_maker<bool * >() (0, heap);
ret.write<unsigned int > ((unsigned int)((QLocale *)cls)->toUInt (arg1, arg2));
}
// qulonglong QLocale::toULongLong(const QString &s, bool *ok)
@ -1637,28 +1483,6 @@ static void _call_f_toULongLong_c2967 (const qt_gsi::GenericMethod * /*decl*/, v
}
// qulonglong QLocale::toULongLong(const QStringRef &s, bool *ok)
static void _init_f_toULongLong_c3252 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const QStringRef & > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("ok", true, "0");
decl->add_arg<bool * > (argspec_1);
decl->set_return<qulonglong > ();
}
static void _call_f_toULongLong_c3252 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const QStringRef &arg1 = gsi::arg_reader<const QStringRef & >() (args, heap);
bool *arg2 = args ? gsi::arg_reader<bool * >() (args, heap) : gsi::arg_maker<bool * >() (0, heap);
ret.write<qulonglong > ((qulonglong)((QLocale *)cls)->toULongLong (arg1, arg2));
}
// unsigned short int QLocale::toUShort(const QString &s, bool *ok)
@ -1681,28 +1505,6 @@ static void _call_f_toUShort_c2967 (const qt_gsi::GenericMethod * /*decl*/, void
}
// unsigned short int QLocale::toUShort(const QStringRef &s, bool *ok)
static void _init_f_toUShort_c3252 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("s");
decl->add_arg<const QStringRef & > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("ok", true, "0");
decl->add_arg<bool * > (argspec_1);
decl->set_return<unsigned short int > ();
}
static void _call_f_toUShort_c3252 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const QStringRef &arg1 = gsi::arg_reader<const QStringRef & >() (args, heap);
bool *arg2 = args ? gsi::arg_reader<bool * >() (args, heap) : gsi::arg_maker<bool * >() (0, heap);
ret.write<unsigned short int > ((unsigned short int)((QLocale *)cls)->toUShort (arg1, arg2));
}
// QString QLocale::toUpper(const QString &str)
@ -1956,7 +1758,6 @@ static gsi::Methods methods_QLocale () {
methods += new qt_gsi::GenericMethod ("pmText", "@brief Method QString QLocale::pmText()\n", true, &_init_f_pmText_c0, &_call_f_pmText_c0);
methods += new qt_gsi::GenericMethod ("positiveSign", "@brief Method QChar QLocale::positiveSign()\n", true, &_init_f_positiveSign_c0, &_call_f_positiveSign_c0);
methods += new qt_gsi::GenericMethod ("quoteString", "@brief Method QString QLocale::quoteString(const QString &str, QLocale::QuotationStyle style)\n", true, &_init_f_quoteString_c4635, &_call_f_quoteString_c4635);
methods += new qt_gsi::GenericMethod ("quoteString", "@brief Method QString QLocale::quoteString(const QStringRef &str, QLocale::QuotationStyle style)\n", true, &_init_f_quoteString_c4920, &_call_f_quoteString_c4920);
methods += new qt_gsi::GenericMethod ("script", "@brief Method QLocale::Script QLocale::script()\n", true, &_init_f_script_c0, &_call_f_script_c0);
methods += new qt_gsi::GenericMethod ("setNumberOptions|numberOptions=", "@brief Method void QLocale::setNumberOptions(QFlags<QLocale::NumberOption> options)\n", false, &_init_f_setNumberOptions_3171, &_call_f_setNumberOptions_3171);
methods += new qt_gsi::GenericMethod ("standaloneDayName", "@brief Method QString QLocale::standaloneDayName(int, QLocale::FormatType format)\n", true, &_init_f_standaloneDayName_c2919, &_call_f_standaloneDayName_c2919);
@ -1976,16 +1777,11 @@ static gsi::Methods methods_QLocale () {
methods += new qt_gsi::GenericMethod ("toDateTime", "@brief Method QDateTime QLocale::toDateTime(const QString &string, QLocale::FormatType format)\n", true, &_init_f_toDateTime_c4177, &_call_f_toDateTime_c4177);
methods += new qt_gsi::GenericMethod ("toDateTime", "@brief Method QDateTime QLocale::toDateTime(const QString &string, const QString &format)\n", true, &_init_f_toDateTime_c3942, &_call_f_toDateTime_c3942);
methods += new qt_gsi::GenericMethod ("toDouble", "@brief Method double QLocale::toDouble(const QString &s, bool *ok)\n", true, &_init_f_toDouble_c2967, &_call_f_toDouble_c2967);
methods += new qt_gsi::GenericMethod ("toDouble", "@brief Method double QLocale::toDouble(const QStringRef &s, bool *ok)\n", true, &_init_f_toDouble_c3252, &_call_f_toDouble_c3252);
methods += new qt_gsi::GenericMethod ("toFloat", "@brief Method float QLocale::toFloat(const QString &s, bool *ok)\n", true, &_init_f_toFloat_c2967, &_call_f_toFloat_c2967);
methods += new qt_gsi::GenericMethod ("toFloat", "@brief Method float QLocale::toFloat(const QStringRef &s, bool *ok)\n", true, &_init_f_toFloat_c3252, &_call_f_toFloat_c3252);
methods += new qt_gsi::GenericMethod ("toInt", "@brief Method int QLocale::toInt(const QString &s, bool *ok)\n", true, &_init_f_toInt_c2967, &_call_f_toInt_c2967);
methods += new qt_gsi::GenericMethod ("toInt", "@brief Method int QLocale::toInt(const QStringRef &s, bool *ok)\n", true, &_init_f_toInt_c3252, &_call_f_toInt_c3252);
methods += new qt_gsi::GenericMethod ("toLongLong", "@brief Method qlonglong QLocale::toLongLong(const QString &s, bool *ok)\n", true, &_init_f_toLongLong_c2967, &_call_f_toLongLong_c2967);
methods += new qt_gsi::GenericMethod ("toLongLong", "@brief Method qlonglong QLocale::toLongLong(const QStringRef &s, bool *ok)\n", true, &_init_f_toLongLong_c3252, &_call_f_toLongLong_c3252);
methods += new qt_gsi::GenericMethod ("toLower", "@brief Method QString QLocale::toLower(const QString &str)\n", true, &_init_f_toLower_c2025, &_call_f_toLower_c2025);
methods += new qt_gsi::GenericMethod ("toShort", "@brief Method short int QLocale::toShort(const QString &s, bool *ok)\n", true, &_init_f_toShort_c2967, &_call_f_toShort_c2967);
methods += new qt_gsi::GenericMethod ("toShort", "@brief Method short int QLocale::toShort(const QStringRef &s, bool *ok)\n", true, &_init_f_toShort_c3252, &_call_f_toShort_c3252);
methods += new qt_gsi::GenericMethod ("toString_ll", "@brief Method QString QLocale::toString(qlonglong i)\n", true, &_init_f_toString_c1413, &_call_f_toString_c1413);
methods += new qt_gsi::GenericMethod ("toString_ull", "@brief Method QString QLocale::toString(qulonglong i)\n", true, &_init_f_toString_c1530, &_call_f_toString_c1530);
methods += new qt_gsi::GenericMethod ("toString_s", "@brief Method QString QLocale::toString(short int i)\n", true, &_init_f_toString_c1471, &_call_f_toString_c1471);
@ -2003,11 +1799,8 @@ static gsi::Methods methods_QLocale () {
methods += new qt_gsi::GenericMethod ("toTime", "@brief Method QTime QLocale::toTime(const QString &string, QLocale::FormatType)\n", true, &_init_f_toTime_c4177, &_call_f_toTime_c4177);
methods += new qt_gsi::GenericMethod ("toTime", "@brief Method QTime QLocale::toTime(const QString &string, const QString &format)\n", true, &_init_f_toTime_c3942, &_call_f_toTime_c3942);
methods += new qt_gsi::GenericMethod ("toUInt", "@brief Method unsigned int QLocale::toUInt(const QString &s, bool *ok)\n", true, &_init_f_toUInt_c2967, &_call_f_toUInt_c2967);
methods += new qt_gsi::GenericMethod ("toUInt", "@brief Method unsigned int QLocale::toUInt(const QStringRef &s, bool *ok)\n", true, &_init_f_toUInt_c3252, &_call_f_toUInt_c3252);
methods += new qt_gsi::GenericMethod ("toULongLong", "@brief Method qulonglong QLocale::toULongLong(const QString &s, bool *ok)\n", true, &_init_f_toULongLong_c2967, &_call_f_toULongLong_c2967);
methods += new qt_gsi::GenericMethod ("toULongLong", "@brief Method qulonglong QLocale::toULongLong(const QStringRef &s, bool *ok)\n", true, &_init_f_toULongLong_c3252, &_call_f_toULongLong_c3252);
methods += new qt_gsi::GenericMethod ("toUShort", "@brief Method unsigned short int QLocale::toUShort(const QString &s, bool *ok)\n", true, &_init_f_toUShort_c2967, &_call_f_toUShort_c2967);
methods += new qt_gsi::GenericMethod ("toUShort", "@brief Method unsigned short int QLocale::toUShort(const QStringRef &s, bool *ok)\n", true, &_init_f_toUShort_c3252, &_call_f_toUShort_c3252);
methods += new qt_gsi::GenericMethod ("toUpper", "@brief Method QString QLocale::toUpper(const QString &str)\n", true, &_init_f_toUpper_c2025, &_call_f_toUpper_c2025);
methods += new qt_gsi::GenericMethod ("uiLanguages", "@brief Method QStringList QLocale::uiLanguages()\n", true, &_init_f_uiLanguages_c0, &_call_f_uiLanguages_c0);
methods += new qt_gsi::GenericMethod ("weekdays", "@brief Method QList<Qt::DayOfWeek> QLocale::weekdays()\n", true, &_init_f_weekdays_c0, &_call_f_weekdays_c0);

40
src/gsiqt/qt5/QtCore/gsiDeclQMetaObject.cc
View File

@ -56,44 +56,6 @@ static void _call_ctor_QMetaObject_0 (const qt_gsi::GenericStaticMethod * /*decl
}
// QObject *QMetaObject::cast(QObject *obj)
static void _init_f_cast_c1302 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("obj");
decl->add_arg<QObject * > (argspec_0);
decl->set_return<QObject * > ();
}
static void _call_f_cast_c1302 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
QObject *arg1 = gsi::arg_reader<QObject * >() (args, heap);
ret.write<QObject * > ((QObject *)((QMetaObject *)cls)->cast (arg1));
}
// const QObject *QMetaObject::cast(const QObject *obj)
static void _init_f_cast_c1997 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("obj");
decl->add_arg<const QObject * > (argspec_0);
decl->set_return<const QObject * > ();
}
static void _call_f_cast_c1997 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const QObject *arg1 = gsi::arg_reader<const QObject * >() (args, heap);
ret.write<const QObject * > ((const QObject *)((QMetaObject *)cls)->cast (arg1));
}
// QMetaClassInfo QMetaObject::classInfo(int index)
@ -726,8 +688,6 @@ namespace gsi
static gsi::Methods methods_QMetaObject () {
gsi::Methods methods;
methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QMetaObject::QMetaObject()\nThis method creates an object of class QMetaObject.", &_init_ctor_QMetaObject_0, &_call_ctor_QMetaObject_0);
methods += new qt_gsi::GenericMethod ("cast", "@brief Method QObject *QMetaObject::cast(QObject *obj)\n", true, &_init_f_cast_c1302, &_call_f_cast_c1302);
methods += new qt_gsi::GenericMethod ("cast", "@brief Method const QObject *QMetaObject::cast(const QObject *obj)\n", true, &_init_f_cast_c1997, &_call_f_cast_c1997);
methods += new qt_gsi::GenericMethod ("classInfo", "@brief Method QMetaClassInfo QMetaObject::classInfo(int index)\n", true, &_init_f_classInfo_c767, &_call_f_classInfo_c767);
methods += new qt_gsi::GenericMethod ("classInfoCount", "@brief Method int QMetaObject::classInfoCount()\n", true, &_init_f_classInfoCount_c0, &_call_f_classInfoCount_c0);
methods += new qt_gsi::GenericMethod ("classInfoOffset", "@brief Method int QMetaObject::classInfoOffset()\n", true, &_init_f_classInfoOffset_c0, &_call_f_classInfoOffset_c0);

58
src/gsiqt/qt5/QtCore/gsiDeclQRegularExpression.cc
View File

@ -152,34 +152,6 @@ static void _call_f_globalMatch_c10055 (const qt_gsi::GenericMethod * /*decl*/,
}
// QRegularExpressionMatchIterator QRegularExpression::globalMatch(const QStringRef &subjectRef, int offset, QRegularExpression::MatchType matchType, QFlags<QRegularExpression::MatchOption> matchOptions)
static void _init_f_globalMatch_c10340 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("subjectRef");
decl->add_arg<const QStringRef & > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("offset", true, "0");
decl->add_arg<int > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("matchType", true, "QRegularExpression::NormalMatch");
decl->add_arg<const qt_gsi::Converter<QRegularExpression::MatchType>::target_type & > (argspec_2);
static gsi::ArgSpecBase argspec_3 ("matchOptions", true, "QRegularExpression::NoMatchOption");
decl->add_arg<QFlags<QRegularExpression::MatchOption> > (argspec_3);
decl->set_return<QRegularExpressionMatchIterator > ();
}
static void _call_f_globalMatch_c10340 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const QStringRef &arg1 = gsi::arg_reader<const QStringRef & >() (args, heap);
int arg2 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (0, heap);
const qt_gsi::Converter<QRegularExpression::MatchType>::target_type & arg3 = args ? gsi::arg_reader<const qt_gsi::Converter<QRegularExpression::MatchType>::target_type & >() (args, heap) : gsi::arg_maker<const qt_gsi::Converter<QRegularExpression::MatchType>::target_type & >() (qt_gsi::CppToQtReadAdaptor<QRegularExpression::MatchType>(heap, QRegularExpression::NormalMatch), heap);
QFlags<QRegularExpression::MatchOption> arg4 = args ? gsi::arg_reader<QFlags<QRegularExpression::MatchOption> >() (args, heap) : gsi::arg_maker<QFlags<QRegularExpression::MatchOption> >() (QRegularExpression::NoMatchOption, heap);
ret.write<QRegularExpressionMatchIterator > ((QRegularExpressionMatchIterator)((QRegularExpression *)cls)->globalMatch (arg1, arg2, qt_gsi::QtToCppAdaptor<QRegularExpression::MatchType>(arg3).cref(), arg4));
}
// bool QRegularExpression::isValid()
@ -223,34 +195,6 @@ static void _call_f_match_c10055 (const qt_gsi::GenericMethod * /*decl*/, void *
}
// QRegularExpressionMatch QRegularExpression::match(const QStringRef &subjectRef, int offset, QRegularExpression::MatchType matchType, QFlags<QRegularExpression::MatchOption> matchOptions)
static void _init_f_match_c10340 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("subjectRef");
decl->add_arg<const QStringRef & > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("offset", true, "0");
decl->add_arg<int > (argspec_1);
static gsi::ArgSpecBase argspec_2 ("matchType", true, "QRegularExpression::NormalMatch");
decl->add_arg<const qt_gsi::Converter<QRegularExpression::MatchType>::target_type & > (argspec_2);
static gsi::ArgSpecBase argspec_3 ("matchOptions", true, "QRegularExpression::NoMatchOption");
decl->add_arg<QFlags<QRegularExpression::MatchOption> > (argspec_3);
decl->set_return<QRegularExpressionMatch > ();
}
static void _call_f_match_c10340 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const QStringRef &arg1 = gsi::arg_reader<const QStringRef & >() (args, heap);
int arg2 = args ? gsi::arg_reader<int >() (args, heap) : gsi::arg_maker<int >() (0, heap);
const qt_gsi::Converter<QRegularExpression::MatchType>::target_type & arg3 = args ? gsi::arg_reader<const qt_gsi::Converter<QRegularExpression::MatchType>::target_type & >() (args, heap) : gsi::arg_maker<const qt_gsi::Converter<QRegularExpression::MatchType>::target_type & >() (qt_gsi::CppToQtReadAdaptor<QRegularExpression::MatchType>(heap, QRegularExpression::NormalMatch), heap);
QFlags<QRegularExpression::MatchOption> arg4 = args ? gsi::arg_reader<QFlags<QRegularExpression::MatchOption> >() (args, heap) : gsi::arg_maker<QFlags<QRegularExpression::MatchOption> >() (QRegularExpression::NoMatchOption, heap);
ret.write<QRegularExpressionMatch > ((QRegularExpressionMatch)((QRegularExpression *)cls)->match (arg1, arg2, qt_gsi::QtToCppAdaptor<QRegularExpression::MatchType>(arg3).cref(), arg4));
}
// QStringList QRegularExpression::namedCaptureGroups()
@ -475,10 +419,8 @@ static gsi::Methods methods_QRegularExpression () {
methods += new qt_gsi::GenericMethod ("captureCount", "@brief Method int QRegularExpression::captureCount()\n", true, &_init_f_captureCount_c0, &_call_f_captureCount_c0);
methods += new qt_gsi::GenericMethod ("errorString", "@brief Method QString QRegularExpression::errorString()\n", true, &_init_f_errorString_c0, &_call_f_errorString_c0);
methods += new qt_gsi::GenericMethod ("globalMatch", "@brief Method QRegularExpressionMatchIterator QRegularExpression::globalMatch(const QString &subject, int offset, QRegularExpression::MatchType matchType, QFlags<QRegularExpression::MatchOption> matchOptions)\n", true, &_init_f_globalMatch_c10055, &_call_f_globalMatch_c10055);
methods += new qt_gsi::GenericMethod ("globalMatch", "@brief Method QRegularExpressionMatchIterator QRegularExpression::globalMatch(const QStringRef &subjectRef, int offset, QRegularExpression::MatchType matchType, QFlags<QRegularExpression::MatchOption> matchOptions)\n", true, &_init_f_globalMatch_c10340, &_call_f_globalMatch_c10340);
methods += new qt_gsi::GenericMethod ("isValid?", "@brief Method bool QRegularExpression::isValid()\n", true, &_init_f_isValid_c0, &_call_f_isValid_c0);
methods += new qt_gsi::GenericMethod ("match", "@brief Method QRegularExpressionMatch QRegularExpression::match(const QString &subject, int offset, QRegularExpression::MatchType matchType, QFlags<QRegularExpression::MatchOption> matchOptions)\n", true, &_init_f_match_c10055, &_call_f_match_c10055);
methods += new qt_gsi::GenericMethod ("match", "@brief Method QRegularExpressionMatch QRegularExpression::match(const QStringRef &subjectRef, int offset, QRegularExpression::MatchType matchType, QFlags<QRegularExpression::MatchOption> matchOptions)\n", true, &_init_f_match_c10340, &_call_f_match_c10340);
methods += new qt_gsi::GenericMethod ("namedCaptureGroups", "@brief Method QStringList QRegularExpression::namedCaptureGroups()\n", true, &_init_f_namedCaptureGroups_c0, &_call_f_namedCaptureGroups_c0);
methods += new qt_gsi::GenericMethod ("!=", "@brief Method bool QRegularExpression::operator!=(const QRegularExpression &re)\n", true, &_init_f_operator_excl__eq__c3188, &_call_f_operator_excl__eq__c3188);
methods += new qt_gsi::GenericMethod ("assign", "@brief Method QRegularExpression &QRegularExpression::operator=(const QRegularExpression &re)\n", false, &_init_f_operator_eq__3188, &_call_f_operator_eq__3188);

20
src/gsiqt/qt5/QtCore/gsiDeclQSignalBlocker.cc
View File

@ -56,25 +56,6 @@ static void _call_ctor_QSignalBlocker_1302 (const qt_gsi::GenericStaticMethod *
}
// Constructor QSignalBlocker::QSignalBlocker(QObject &o)
static void _init_ctor_QSignalBlocker_1298 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("o");
decl->add_arg<QObject & > (argspec_0);
decl->set_return_new<QSignalBlocker> ();
}
static void _call_ctor_QSignalBlocker_1298 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
QObject &arg1 = gsi::arg_reader<QObject & >() (args, heap);
ret.write<QSignalBlocker *> (new QSignalBlocker (arg1));
}
// void QSignalBlocker::reblock()
@ -114,7 +95,6 @@ namespace gsi
static gsi::Methods methods_QSignalBlocker () {
gsi::Methods methods;
methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QSignalBlocker::QSignalBlocker(QObject *o)\nThis method creates an object of class QSignalBlocker.", &_init_ctor_QSignalBlocker_1302, &_call_ctor_QSignalBlocker_1302);
methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QSignalBlocker::QSignalBlocker(QObject &o)\nThis method creates an object of class QSignalBlocker.", &_init_ctor_QSignalBlocker_1298, &_call_ctor_QSignalBlocker_1298);
methods += new qt_gsi::GenericMethod ("reblock", "@brief Method void QSignalBlocker::reblock()\n", false, &_init_f_reblock_0, &_call_f_reblock_0);
methods += new qt_gsi::GenericMethod ("unblock", "@brief Method void QSignalBlocker::unblock()\n", false, &_init_f_unblock_0, &_call_f_unblock_0);
return methods;

41
src/gsiqt/qt5/QtCore/gsiDeclQXmlStreamReader.cc
View File

@ -114,25 +114,6 @@ static void _call_ctor_QXmlStreamReader_2025 (const qt_gsi::GenericStaticMethod
}
// Constructor QXmlStreamReader::QXmlStreamReader(const char *data)
static void _init_ctor_QXmlStreamReader_1731 (qt_gsi::GenericStaticMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("data");
decl->add_arg<const char * > (argspec_0);
decl->set_return_new<QXmlStreamReader> ();
}
static void _call_ctor_QXmlStreamReader_1731 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
ret.write<QXmlStreamReader *> (new QXmlStreamReader (arg1));
}
// void QXmlStreamReader::addData(const QByteArray &data)
@ -173,26 +154,6 @@ static void _call_f_addData_2025 (const qt_gsi::GenericMethod * /*decl*/, void *
}
// void QXmlStreamReader::addData(const char *data)
static void _init_f_addData_1731 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("data");
decl->add_arg<const char * > (argspec_0);
decl->set_return<void > ();
}
static void _call_f_addData_1731 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const char *arg1 = gsi::arg_reader<const char * >() (args, heap);
__SUPPRESS_UNUSED_WARNING(ret);
((QXmlStreamReader *)cls)->addData (arg1);
}
// void QXmlStreamReader::addExtraNamespaceDeclaration(const QXmlStreamNamespaceDeclaration &extraNamespaceDeclaraction)
@ -1004,10 +965,8 @@ static gsi::Methods methods_QXmlStreamReader () {
methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QXmlStreamReader::QXmlStreamReader(QIODevice *device)\nThis method creates an object of class QXmlStreamReader.", &_init_ctor_QXmlStreamReader_1447, &_call_ctor_QXmlStreamReader_1447);
methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QXmlStreamReader::QXmlStreamReader(const QByteArray &data)\nThis method creates an object of class QXmlStreamReader.", &_init_ctor_QXmlStreamReader_2309, &_call_ctor_QXmlStreamReader_2309);
methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QXmlStreamReader::QXmlStreamReader(const QString &data)\nThis method creates an object of class QXmlStreamReader.", &_init_ctor_QXmlStreamReader_2025, &_call_ctor_QXmlStreamReader_2025);
methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QXmlStreamReader::QXmlStreamReader(const char *data)\nThis method creates an object of class QXmlStreamReader.", &_init_ctor_QXmlStreamReader_1731, &_call_ctor_QXmlStreamReader_1731);
methods += new qt_gsi::GenericMethod ("addData", "@brief Method void QXmlStreamReader::addData(const QByteArray &data)\n", false, &_init_f_addData_2309, &_call_f_addData_2309);
methods += new qt_gsi::GenericMethod ("addData", "@brief Method void QXmlStreamReader::addData(const QString &data)\n", false, &_init_f_addData_2025, &_call_f_addData_2025);
methods += new qt_gsi::GenericMethod ("addData", "@brief Method void QXmlStreamReader::addData(const char *data)\n", false, &_init_f_addData_1731, &_call_f_addData_1731);
methods += new qt_gsi::GenericMethod ("addExtraNamespaceDeclaration", "@brief Method void QXmlStreamReader::addExtraNamespaceDeclaration(const QXmlStreamNamespaceDeclaration &extraNamespaceDeclaraction)\n", false, &_init_f_addExtraNamespaceDeclaration_4354, &_call_f_addExtraNamespaceDeclaration_4354);
methods += new qt_gsi::GenericMethod ("addExtraNamespaceDeclarations", "@brief Method void QXmlStreamReader::addExtraNamespaceDeclarations(const QVector<QXmlStreamNamespaceDeclaration> &extraNamespaceDeclaractions)\n", false, &_init_f_addExtraNamespaceDeclarations_5184, &_call_f_addExtraNamespaceDeclarations_5184);
methods += new qt_gsi::GenericMethod ("atEnd", "@brief Method bool QXmlStreamReader::atEnd()\n", true, &_init_f_atEnd_c0, &_call_f_atEnd_c0);

2
src/gsiqt/qt5/QtGui/gsiDeclQRawFont.cc
View File

@ -852,7 +852,7 @@ static gsi::Methods methods_QRawFont () {
methods += new qt_gsi::GenericMethod ("style", "@brief Method QFont::Style QRawFont::style()\n", true, &_init_f_style_c0, &_call_f_style_c0);
methods += new qt_gsi::GenericMethod ("styleName", "@brief Method QString QRawFont::styleName()\n", true, &_init_f_styleName_c0, &_call_f_styleName_c0);
methods += new qt_gsi::GenericMethod ("supportedWritingSystems", "@brief Method QList<QFontDatabase::WritingSystem> QRawFont::supportedWritingSystems()\n", true, &_init_f_supportedWritingSystems_c0, &_call_f_supportedWritingSystems_c0);
methods += new qt_gsi::GenericMethod ("supportsCharacter", "@brief Method bool QRawFont::supportsCharacter(unsigned int ucs4)\n", true, &_init_f_supportsCharacter_c1772, &_call_f_supportsCharacter_c1772);
methods += new qt_gsi::GenericMethod ("supportsCharacter_ucs4", "@brief Method bool QRawFont::supportsCharacter(unsigned int ucs4)\n", true, &_init_f_supportsCharacter_c1772, &_call_f_supportsCharacter_c1772);
methods += new qt_gsi::GenericMethod ("supportsCharacter", "@brief Method bool QRawFont::supportsCharacter(QChar character)\n", true, &_init_f_supportsCharacter_c899, &_call_f_supportsCharacter_c899);
methods += new qt_gsi::GenericMethod ("swap", "@brief Method void QRawFont::swap(QRawFont &other)\n", false, &_init_f_swap_1404, &_call_f_swap_1404);
methods += new qt_gsi::GenericMethod ("underlinePosition", "@brief Method double QRawFont::underlinePosition()\n", true, &_init_f_underlinePosition_c0, &_call_f_underlinePosition_c0);

23
src/gsiqt/qt5/QtGui/gsiDeclQTextLine.cc
View File

@ -70,28 +70,6 @@ static void _call_f_ascent_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls
}
// double QTextLine::cursorToX(int *cursorPos, QTextLine::Edge edge)
static void _init_f_cursorToX_c2664 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("cursorPos");
decl->add_arg<int * > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("edge", true, "QTextLine::Leading");
decl->add_arg<const qt_gsi::Converter<QTextLine::Edge>::target_type & > (argspec_1);
decl->set_return<double > ();
}
static void _call_f_cursorToX_c2664 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
int *arg1 = gsi::arg_reader<int * >() (args, heap);
const qt_gsi::Converter<QTextLine::Edge>::target_type & arg2 = args ? gsi::arg_reader<const qt_gsi::Converter<QTextLine::Edge>::target_type & >() (args, heap) : gsi::arg_maker<const qt_gsi::Converter<QTextLine::Edge>::target_type & >() (qt_gsi::CppToQtReadAdaptor<QTextLine::Edge>(heap, QTextLine::Leading), heap);
ret.write<double > ((double)((QTextLine *)cls)->cursorToX (arg1, qt_gsi::QtToCppAdaptor<QTextLine::Edge>(arg2).cref()));
}
// double QTextLine::cursorToX(int cursorPos, QTextLine::Edge edge)
@ -535,7 +513,6 @@ static gsi::Methods methods_QTextLine () {
gsi::Methods methods;
methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QTextLine::QTextLine()\nThis method creates an object of class QTextLine.", &_init_ctor_QTextLine_0, &_call_ctor_QTextLine_0);
methods += new qt_gsi::GenericMethod ("ascent", "@brief Method double QTextLine::ascent()\n", true, &_init_f_ascent_c0, &_call_f_ascent_c0);
methods += new qt_gsi::GenericMethod ("cursorToX", "@brief Method double QTextLine::cursorToX(int *cursorPos, QTextLine::Edge edge)\n", true, &_init_f_cursorToX_c2664, &_call_f_cursorToX_c2664);
methods += new qt_gsi::GenericMethod ("cursorToX", "@brief Method double QTextLine::cursorToX(int cursorPos, QTextLine::Edge edge)\n", true, &_init_f_cursorToX_c2478, &_call_f_cursorToX_c2478);
methods += new qt_gsi::GenericMethod ("descent", "@brief Method double QTextLine::descent()\n", true, &_init_f_descent_c0, &_call_f_descent_c0);
methods += new qt_gsi::GenericMethod ("draw", "@brief Method void QTextLine::draw(QPainter *p, const QPointF &point, const QTextLayout::FormatRange *selection)\n", true, &_init_f_draw_c6879, &_call_f_draw_c6879);

858
src/gsiqt/qt5/QtXml/gsiDeclQXmlReader.cc
View File

@ -193,25 +193,6 @@ static void _call_f_lexicalHandler_c0 (const qt_gsi::GenericMethod * /*decl*/, v
}
// bool QXmlReader::parse(const QXmlInputSource &input)
static void _init_f_parse_2852 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("input");
decl->add_arg<const QXmlInputSource & > (argspec_0);
decl->set_return<bool > ();
}
static void _call_f_parse_2852 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const QXmlInputSource &arg1 = gsi::arg_reader<const QXmlInputSource & >() (args, heap);
ret.write<bool > ((bool)((QXmlReader *)cls)->parse (arg1));
}
// bool QXmlReader::parse(const QXmlInputSource *input)
@ -419,6 +400,7 @@ static void _call_f_setProperty_2973 (const qt_gsi::GenericMethod * /*decl*/, vo
}
namespace gsi
{
@ -433,7 +415,6 @@ static gsi::Methods methods_QXmlReader () {
methods += new qt_gsi::GenericMethod ("hasFeature", "@brief Method bool QXmlReader::hasFeature(const QString &name)\n", true, &_init_f_hasFeature_c2025, &_call_f_hasFeature_c2025);
methods += new qt_gsi::GenericMethod ("hasProperty", "@brief Method bool QXmlReader::hasProperty(const QString &name)\n", true, &_init_f_hasProperty_c2025, &_call_f_hasProperty_c2025);
methods += new qt_gsi::GenericMethod (":lexicalHandler", "@brief Method QXmlLexicalHandler *QXmlReader::lexicalHandler()\n", true, &_init_f_lexicalHandler_c0, &_call_f_lexicalHandler_c0);
methods += new qt_gsi::GenericMethod ("parse", "@brief Method bool QXmlReader::parse(const QXmlInputSource &input)\n", false, &_init_f_parse_2852, &_call_f_parse_2852);
methods += new qt_gsi::GenericMethod ("parse", "@brief Method bool QXmlReader::parse(const QXmlInputSource *input)\n", false, &_init_f_parse_2856, &_call_f_parse_2856);
methods += new qt_gsi::GenericMethod ("property", "@brief Method void *QXmlReader::property(const QString &name, bool *ok)\n", true, &_init_f_property_c2967, &_call_f_property_c2967);
methods += new qt_gsi::GenericMethod ("setContentHandler|contentHandler=", "@brief Method void QXmlReader::setContentHandler(QXmlContentHandler *handler)\n", false, &_init_f_setContentHandler_2441, &_call_f_setContentHandler_2441);
@ -447,843 +428,10 @@ static gsi::Methods methods_QXmlReader () {
return methods;
}
gsi::Class<QXmlReader> decl_QXmlReader ("QtXml", "QXmlReader_Native",
gsi::Class<QXmlReader> decl_QXmlReader ("QtXml", "QXmlReader",
methods_QXmlReader (),
"@hide\n@alias QXmlReader");
"@qt\n@brief Binding of QXmlReader");
GSI_QTXML_PUBLIC gsi::Class<QXmlReader> &qtdecl_QXmlReader () { return decl_QXmlReader; }
}
class QXmlReader_Adaptor : public QXmlReader, public qt_gsi::QtObjectBase
{
public:
virtual ~QXmlReader_Adaptor();
// [adaptor ctor] QXmlReader::QXmlReader()
QXmlReader_Adaptor() : QXmlReader()
{
qt_gsi::QtObjectBase::init (this);
}
// [adaptor impl] QXmlDTDHandler *QXmlReader::DTDHandler()
QXmlDTDHandler * cbs_DTDHandler_c0_0() const
{
throw qt_gsi::AbstractMethodCalledException("DTDHandler");
}
virtual QXmlDTDHandler * DTDHandler() const
{
if (cb_DTDHandler_c0_0.can_issue()) {
return cb_DTDHandler_c0_0.issue<QXmlReader_Adaptor, QXmlDTDHandler *>(&QXmlReader_Adaptor::cbs_DTDHandler_c0_0);
} else {
throw qt_gsi::AbstractMethodCalledException("DTDHandler");
}
}
// [adaptor impl] QXmlContentHandler *QXmlReader::contentHandler()
QXmlContentHandler * cbs_contentHandler_c0_0() const
{
throw qt_gsi::AbstractMethodCalledException("contentHandler");
}
virtual QXmlContentHandler * contentHandler() const
{
if (cb_contentHandler_c0_0.can_issue()) {
return cb_contentHandler_c0_0.issue<QXmlReader_Adaptor, QXmlContentHandler *>(&QXmlReader_Adaptor::cbs_contentHandler_c0_0);
} else {
throw qt_gsi::AbstractMethodCalledException("contentHandler");
}
}
// [adaptor impl] QXmlDeclHandler *QXmlReader::declHandler()
QXmlDeclHandler * cbs_declHandler_c0_0() const
{
throw qt_gsi::AbstractMethodCalledException("declHandler");
}
virtual QXmlDeclHandler * declHandler() const
{
if (cb_declHandler_c0_0.can_issue()) {
return cb_declHandler_c0_0.issue<QXmlReader_Adaptor, QXmlDeclHandler *>(&QXmlReader_Adaptor::cbs_declHandler_c0_0);
} else {
throw qt_gsi::AbstractMethodCalledException("declHandler");
}
}
// [adaptor impl] QXmlEntityResolver *QXmlReader::entityResolver()
QXmlEntityResolver * cbs_entityResolver_c0_0() const
{
throw qt_gsi::AbstractMethodCalledException("entityResolver");
}
virtual QXmlEntityResolver * entityResolver() const
{
if (cb_entityResolver_c0_0.can_issue()) {
return cb_entityResolver_c0_0.issue<QXmlReader_Adaptor, QXmlEntityResolver *>(&QXmlReader_Adaptor::cbs_entityResolver_c0_0);
} else {
throw qt_gsi::AbstractMethodCalledException("entityResolver");
}
}
// [adaptor impl] QXmlErrorHandler *QXmlReader::errorHandler()
QXmlErrorHandler * cbs_errorHandler_c0_0() const
{
throw qt_gsi::AbstractMethodCalledException("errorHandler");
}
virtual QXmlErrorHandler * errorHandler() const
{
if (cb_errorHandler_c0_0.can_issue()) {
return cb_errorHandler_c0_0.issue<QXmlReader_Adaptor, QXmlErrorHandler *>(&QXmlReader_Adaptor::cbs_errorHandler_c0_0);
} else {
throw qt_gsi::AbstractMethodCalledException("errorHandler");
}
}
// [adaptor impl] bool QXmlReader::feature(const QString &name, bool *ok)
bool cbs_feature_c2967_1(const QString &name, bool *ok) const
{
__SUPPRESS_UNUSED_WARNING (name);
__SUPPRESS_UNUSED_WARNING (ok);
throw qt_gsi::AbstractMethodCalledException("feature");
}
virtual bool feature(const QString &name, bool *ok) const
{
if (cb_feature_c2967_1.can_issue()) {
return cb_feature_c2967_1.issue<QXmlReader_Adaptor, bool, const QString &, bool *>(&QXmlReader_Adaptor::cbs_feature_c2967_1, name, ok);
} else {
throw qt_gsi::AbstractMethodCalledException("feature");
}
}
// [adaptor impl] bool QXmlReader::hasFeature(const QString &name)
bool cbs_hasFeature_c2025_0(const QString &name) const
{
__SUPPRESS_UNUSED_WARNING (name);
throw qt_gsi::AbstractMethodCalledException("hasFeature");
}
virtual bool hasFeature(const QString &name) const
{
if (cb_hasFeature_c2025_0.can_issue()) {
return cb_hasFeature_c2025_0.issue<QXmlReader_Adaptor, bool, const QString &>(&QXmlReader_Adaptor::cbs_hasFeature_c2025_0, name);
} else {
throw qt_gsi::AbstractMethodCalledException("hasFeature");
}
}
// [adaptor impl] bool QXmlReader::hasProperty(const QString &name)
bool cbs_hasProperty_c2025_0(const QString &name) const
{
__SUPPRESS_UNUSED_WARNING (name);
throw qt_gsi::AbstractMethodCalledException("hasProperty");
}
virtual bool hasProperty(const QString &name) const
{
if (cb_hasProperty_c2025_0.can_issue()) {
return cb_hasProperty_c2025_0.issue<QXmlReader_Adaptor, bool, const QString &>(&QXmlReader_Adaptor::cbs_hasProperty_c2025_0, name);
} else {
throw qt_gsi::AbstractMethodCalledException("hasProperty");
}
}
// [adaptor impl] QXmlLexicalHandler *QXmlReader::lexicalHandler()
QXmlLexicalHandler * cbs_lexicalHandler_c0_0() const
{
throw qt_gsi::AbstractMethodCalledException("lexicalHandler");
}
virtual QXmlLexicalHandler * lexicalHandler() const
{
if (cb_lexicalHandler_c0_0.can_issue()) {
return cb_lexicalHandler_c0_0.issue<QXmlReader_Adaptor, QXmlLexicalHandler *>(&QXmlReader_Adaptor::cbs_lexicalHandler_c0_0);
} else {
throw qt_gsi::AbstractMethodCalledException("lexicalHandler");
}
}
// [adaptor impl] bool QXmlReader::parse(const QXmlInputSource &input)
bool cbs_parse_2852_0(const QXmlInputSource &input)
{
__SUPPRESS_UNUSED_WARNING (input);
throw qt_gsi::AbstractMethodCalledException("parse");
}
virtual bool parse(const QXmlInputSource &input)
{
if (cb_parse_2852_0.can_issue()) {
return cb_parse_2852_0.issue<QXmlReader_Adaptor, bool, const QXmlInputSource &>(&QXmlReader_Adaptor::cbs_parse_2852_0, input);
} else {
throw qt_gsi::AbstractMethodCalledException("parse");
}
}
// [adaptor impl] bool QXmlReader::parse(const QXmlInputSource *input)
bool cbs_parse_2856_0(const QXmlInputSource *input)
{
__SUPPRESS_UNUSED_WARNING (input);
throw qt_gsi::AbstractMethodCalledException("parse");
}
virtual bool parse(const QXmlInputSource *input)
{
if (cb_parse_2856_0.can_issue()) {
return cb_parse_2856_0.issue<QXmlReader_Adaptor, bool, const QXmlInputSource *>(&QXmlReader_Adaptor::cbs_parse_2856_0, input);
} else {
throw qt_gsi::AbstractMethodCalledException("parse");
}
}
// [adaptor impl] void *QXmlReader::property(const QString &name, bool *ok)
void * cbs_property_c2967_1(const QString &name, bool *ok) const
{
__SUPPRESS_UNUSED_WARNING (name);
__SUPPRESS_UNUSED_WARNING (ok);
throw qt_gsi::AbstractMethodCalledException("property");
}
virtual void * property(const QString &name, bool *ok) const
{
if (cb_property_c2967_1.can_issue()) {
return cb_property_c2967_1.issue<QXmlReader_Adaptor, void *, const QString &, bool *>(&QXmlReader_Adaptor::cbs_property_c2967_1, name, ok);
} else {
throw qt_gsi::AbstractMethodCalledException("property");
}
}
// [adaptor impl] void QXmlReader::setContentHandler(QXmlContentHandler *handler)
void cbs_setContentHandler_2441_0(QXmlContentHandler *handler)
{
__SUPPRESS_UNUSED_WARNING (handler);
throw qt_gsi::AbstractMethodCalledException("setContentHandler");
}
virtual void setContentHandler(QXmlContentHandler *handler)
{
if (cb_setContentHandler_2441_0.can_issue()) {
cb_setContentHandler_2441_0.issue<QXmlReader_Adaptor, QXmlContentHandler *>(&QXmlReader_Adaptor::cbs_setContentHandler_2441_0, handler);
} else {
throw qt_gsi::AbstractMethodCalledException("setContentHandler");
}
}
// [adaptor impl] void QXmlReader::setDTDHandler(QXmlDTDHandler *handler)
void cbs_setDTDHandler_1930_0(QXmlDTDHandler *handler)
{
__SUPPRESS_UNUSED_WARNING (handler);
throw qt_gsi::AbstractMethodCalledException("setDTDHandler");
}
virtual void setDTDHandler(QXmlDTDHandler *handler)
{
if (cb_setDTDHandler_1930_0.can_issue()) {
cb_setDTDHandler_1930_0.issue<QXmlReader_Adaptor, QXmlDTDHandler *>(&QXmlReader_Adaptor::cbs_setDTDHandler_1930_0, handler);
} else {
throw qt_gsi::AbstractMethodCalledException("setDTDHandler");
}
}
// [adaptor impl] void QXmlReader::setDeclHandler(QXmlDeclHandler *handler)
void cbs_setDeclHandler_2086_0(QXmlDeclHandler *handler)
{
__SUPPRESS_UNUSED_WARNING (handler);
throw qt_gsi::AbstractMethodCalledException("setDeclHandler");
}
virtual void setDeclHandler(QXmlDeclHandler *handler)
{
if (cb_setDeclHandler_2086_0.can_issue()) {
cb_setDeclHandler_2086_0.issue<QXmlReader_Adaptor, QXmlDeclHandler *>(&QXmlReader_Adaptor::cbs_setDeclHandler_2086_0, handler);
} else {
throw qt_gsi::AbstractMethodCalledException("setDeclHandler");
}
}
// [adaptor impl] void QXmlReader::setEntityResolver(QXmlEntityResolver *handler)
void cbs_setEntityResolver_2495_0(QXmlEntityResolver *handler)
{
__SUPPRESS_UNUSED_WARNING (handler);
throw qt_gsi::AbstractMethodCalledException("setEntityResolver");
}
virtual void setEntityResolver(QXmlEntityResolver *handler)
{
if (cb_setEntityResolver_2495_0.can_issue()) {
cb_setEntityResolver_2495_0.issue<QXmlReader_Adaptor, QXmlEntityResolver *>(&QXmlReader_Adaptor::cbs_setEntityResolver_2495_0, handler);
} else {
throw qt_gsi::AbstractMethodCalledException("setEntityResolver");
}
}
// [adaptor impl] void QXmlReader::setErrorHandler(QXmlErrorHandler *handler)
void cbs_setErrorHandler_2232_0(QXmlErrorHandler *handler)
{
__SUPPRESS_UNUSED_WARNING (handler);
throw qt_gsi::AbstractMethodCalledException("setErrorHandler");
}
virtual void setErrorHandler(QXmlErrorHandler *handler)
{
if (cb_setErrorHandler_2232_0.can_issue()) {
cb_setErrorHandler_2232_0.issue<QXmlReader_Adaptor, QXmlErrorHandler *>(&QXmlReader_Adaptor::cbs_setErrorHandler_2232_0, handler);
} else {
throw qt_gsi::AbstractMethodCalledException("setErrorHandler");
}
}
// [adaptor impl] void QXmlReader::setFeature(const QString &name, bool value)
void cbs_setFeature_2781_0(const QString &name, bool value)
{
__SUPPRESS_UNUSED_WARNING (name);
__SUPPRESS_UNUSED_WARNING (value);
throw qt_gsi::AbstractMethodCalledException("setFeature");
}
virtual void setFeature(const QString &name, bool value)
{
if (cb_setFeature_2781_0.can_issue()) {
cb_setFeature_2781_0.issue<QXmlReader_Adaptor, const QString &, bool>(&QXmlReader_Adaptor::cbs_setFeature_2781_0, name, value);
} else {
throw qt_gsi::AbstractMethodCalledException("setFeature");
}
}
// [adaptor impl] void QXmlReader::setLexicalHandler(QXmlLexicalHandler *handler)
void cbs_setLexicalHandler_2416_0(QXmlLexicalHandler *handler)
{
__SUPPRESS_UNUSED_WARNING (handler);
throw qt_gsi::AbstractMethodCalledException("setLexicalHandler");
}
virtual void setLexicalHandler(QXmlLexicalHandler *handler)
{
if (cb_setLexicalHandler_2416_0.can_issue()) {
cb_setLexicalHandler_2416_0.issue<QXmlReader_Adaptor, QXmlLexicalHandler *>(&QXmlReader_Adaptor::cbs_setLexicalHandler_2416_0, handler);
} else {
throw qt_gsi::AbstractMethodCalledException("setLexicalHandler");
}
}
// [adaptor impl] void QXmlReader::setProperty(const QString &name, void *value)
void cbs_setProperty_2973_0(const QString &name, void *value)
{
__SUPPRESS_UNUSED_WARNING (name);
__SUPPRESS_UNUSED_WARNING (value);
throw qt_gsi::AbstractMethodCalledException("setProperty");
}
virtual void setProperty(const QString &name, void *value)
{
if (cb_setProperty_2973_0.can_issue()) {
cb_setProperty_2973_0.issue<QXmlReader_Adaptor, const QString &, void *>(&QXmlReader_Adaptor::cbs_setProperty_2973_0, name, value);
} else {
throw qt_gsi::AbstractMethodCalledException("setProperty");
}
}
gsi::Callback cb_DTDHandler_c0_0;
gsi::Callback cb_contentHandler_c0_0;
gsi::Callback cb_declHandler_c0_0;
gsi::Callback cb_entityResolver_c0_0;
gsi::Callback cb_errorHandler_c0_0;
gsi::Callback cb_feature_c2967_1;
gsi::Callback cb_hasFeature_c2025_0;
gsi::Callback cb_hasProperty_c2025_0;
gsi::Callback cb_lexicalHandler_c0_0;
gsi::Callback cb_parse_2852_0;
gsi::Callback cb_parse_2856_0;
gsi::Callback cb_property_c2967_1;
gsi::Callback cb_setContentHandler_2441_0;
gsi::Callback cb_setDTDHandler_1930_0;
gsi::Callback cb_setDeclHandler_2086_0;
gsi::Callback cb_setEntityResolver_2495_0;
gsi::Callback cb_setErrorHandler_2232_0;
gsi::Callback cb_setFeature_2781_0;
gsi::Callback cb_setLexicalHandler_2416_0;
gsi::Callback cb_setProperty_2973_0;
};
QXmlReader_Adaptor::~QXmlReader_Adaptor() { }
// Constructor QXmlReader::QXmlReader() (adaptor class)
static void _init_ctor_QXmlReader_Adaptor_0 (qt_gsi::GenericStaticMethod *decl)
{
decl->set_return_new<QXmlReader_Adaptor> ();
}
static void _call_ctor_QXmlReader_Adaptor_0 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
ret.write<QXmlReader_Adaptor *> (new QXmlReader_Adaptor ());
}
// QXmlDTDHandler *QXmlReader::DTDHandler()
static void _init_cbs_DTDHandler_c0_0 (qt_gsi::GenericMethod *decl)
{
decl->set_return<QXmlDTDHandler * > ();
}
static void _call_cbs_DTDHandler_c0_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
ret.write<QXmlDTDHandler * > ((QXmlDTDHandler *)((QXmlReader_Adaptor *)cls)->cbs_DTDHandler_c0_0 ());
}
static void _set_callback_cbs_DTDHandler_c0_0 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_DTDHandler_c0_0 = cb;
}
// QXmlContentHandler *QXmlReader::contentHandler()
static void _init_cbs_contentHandler_c0_0 (qt_gsi::GenericMethod *decl)
{
decl->set_return<QXmlContentHandler * > ();
}
static void _call_cbs_contentHandler_c0_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
ret.write<QXmlContentHandler * > ((QXmlContentHandler *)((QXmlReader_Adaptor *)cls)->cbs_contentHandler_c0_0 ());
}
static void _set_callback_cbs_contentHandler_c0_0 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_contentHandler_c0_0 = cb;
}
// QXmlDeclHandler *QXmlReader::declHandler()
static void _init_cbs_declHandler_c0_0 (qt_gsi::GenericMethod *decl)
{
decl->set_return<QXmlDeclHandler * > ();
}
static void _call_cbs_declHandler_c0_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
ret.write<QXmlDeclHandler * > ((QXmlDeclHandler *)((QXmlReader_Adaptor *)cls)->cbs_declHandler_c0_0 ());
}
static void _set_callback_cbs_declHandler_c0_0 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_declHandler_c0_0 = cb;
}
// QXmlEntityResolver *QXmlReader::entityResolver()
static void _init_cbs_entityResolver_c0_0 (qt_gsi::GenericMethod *decl)
{
decl->set_return<QXmlEntityResolver * > ();
}
static void _call_cbs_entityResolver_c0_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
ret.write<QXmlEntityResolver * > ((QXmlEntityResolver *)((QXmlReader_Adaptor *)cls)->cbs_entityResolver_c0_0 ());
}
static void _set_callback_cbs_entityResolver_c0_0 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_entityResolver_c0_0 = cb;
}
// QXmlErrorHandler *QXmlReader::errorHandler()
static void _init_cbs_errorHandler_c0_0 (qt_gsi::GenericMethod *decl)
{
decl->set_return<QXmlErrorHandler * > ();
}
static void _call_cbs_errorHandler_c0_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
ret.write<QXmlErrorHandler * > ((QXmlErrorHandler *)((QXmlReader_Adaptor *)cls)->cbs_errorHandler_c0_0 ());
}
static void _set_callback_cbs_errorHandler_c0_0 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_errorHandler_c0_0 = cb;
}
// bool QXmlReader::feature(const QString &name, bool *ok)
static void _init_cbs_feature_c2967_1 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("name");
decl->add_arg<const QString & > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("ok");
decl->add_arg<bool * > (argspec_1);
decl->set_return<bool > ();
}
static void _call_cbs_feature_c2967_1 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const QString &arg1 = args.read<const QString & > (heap);
bool *arg2 = args.read<bool * > (heap);
ret.write<bool > ((bool)((QXmlReader_Adaptor *)cls)->cbs_feature_c2967_1 (arg1, arg2));
}
static void _set_callback_cbs_feature_c2967_1 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_feature_c2967_1 = cb;
}
// bool QXmlReader::hasFeature(const QString &name)
static void _init_cbs_hasFeature_c2025_0 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("name");
decl->add_arg<const QString & > (argspec_0);
decl->set_return<bool > ();
}
static void _call_cbs_hasFeature_c2025_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const QString &arg1 = args.read<const QString & > (heap);
ret.write<bool > ((bool)((QXmlReader_Adaptor *)cls)->cbs_hasFeature_c2025_0 (arg1));
}
static void _set_callback_cbs_hasFeature_c2025_0 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_hasFeature_c2025_0 = cb;
}
// bool QXmlReader::hasProperty(const QString &name)
static void _init_cbs_hasProperty_c2025_0 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("name");
decl->add_arg<const QString & > (argspec_0);
decl->set_return<bool > ();
}
static void _call_cbs_hasProperty_c2025_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const QString &arg1 = args.read<const QString & > (heap);
ret.write<bool > ((bool)((QXmlReader_Adaptor *)cls)->cbs_hasProperty_c2025_0 (arg1));
}
static void _set_callback_cbs_hasProperty_c2025_0 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_hasProperty_c2025_0 = cb;
}
// QXmlLexicalHandler *QXmlReader::lexicalHandler()
static void _init_cbs_lexicalHandler_c0_0 (qt_gsi::GenericMethod *decl)
{
decl->set_return<QXmlLexicalHandler * > ();
}
static void _call_cbs_lexicalHandler_c0_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
ret.write<QXmlLexicalHandler * > ((QXmlLexicalHandler *)((QXmlReader_Adaptor *)cls)->cbs_lexicalHandler_c0_0 ());
}
static void _set_callback_cbs_lexicalHandler_c0_0 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_lexicalHandler_c0_0 = cb;
}
// bool QXmlReader::parse(const QXmlInputSource &input)
static void _init_cbs_parse_2852_0 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("input");
decl->add_arg<const QXmlInputSource & > (argspec_0);
decl->set_return<bool > ();
}
static void _call_cbs_parse_2852_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const QXmlInputSource &arg1 = args.read<const QXmlInputSource & > (heap);
ret.write<bool > ((bool)((QXmlReader_Adaptor *)cls)->cbs_parse_2852_0 (arg1));
}
static void _set_callback_cbs_parse_2852_0 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_parse_2852_0 = cb;
}
// bool QXmlReader::parse(const QXmlInputSource *input)
static void _init_cbs_parse_2856_0 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("input");
decl->add_arg<const QXmlInputSource * > (argspec_0);
decl->set_return<bool > ();
}
static void _call_cbs_parse_2856_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const QXmlInputSource *arg1 = args.read<const QXmlInputSource * > (heap);
ret.write<bool > ((bool)((QXmlReader_Adaptor *)cls)->cbs_parse_2856_0 (arg1));
}
static void _set_callback_cbs_parse_2856_0 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_parse_2856_0 = cb;
}
// void *QXmlReader::property(const QString &name, bool *ok)
static void _init_cbs_property_c2967_1 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("name");
decl->add_arg<const QString & > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("ok");
decl->add_arg<bool * > (argspec_1);
decl->set_return<void * > ();
}
static void _call_cbs_property_c2967_1 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const QString &arg1 = args.read<const QString & > (heap);
bool *arg2 = args.read<bool * > (heap);
ret.write<void * > ((void *)((QXmlReader_Adaptor *)cls)->cbs_property_c2967_1 (arg1, arg2));
}
static void _set_callback_cbs_property_c2967_1 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_property_c2967_1 = cb;
}
// void QXmlReader::setContentHandler(QXmlContentHandler *handler)
static void _init_cbs_setContentHandler_2441_0 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("handler");
decl->add_arg<QXmlContentHandler * > (argspec_0);
decl->set_return<void > ();
}
static void _call_cbs_setContentHandler_2441_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
QXmlContentHandler *arg1 = args.read<QXmlContentHandler * > (heap);
__SUPPRESS_UNUSED_WARNING(ret);
((QXmlReader_Adaptor *)cls)->cbs_setContentHandler_2441_0 (arg1);
}
static void _set_callback_cbs_setContentHandler_2441_0 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_setContentHandler_2441_0 = cb;
}
// void QXmlReader::setDTDHandler(QXmlDTDHandler *handler)
static void _init_cbs_setDTDHandler_1930_0 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("handler");
decl->add_arg<QXmlDTDHandler * > (argspec_0);
decl->set_return<void > ();
}
static void _call_cbs_setDTDHandler_1930_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
QXmlDTDHandler *arg1 = args.read<QXmlDTDHandler * > (heap);
__SUPPRESS_UNUSED_WARNING(ret);
((QXmlReader_Adaptor *)cls)->cbs_setDTDHandler_1930_0 (arg1);
}
static void _set_callback_cbs_setDTDHandler_1930_0 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_setDTDHandler_1930_0 = cb;
}
// void QXmlReader::setDeclHandler(QXmlDeclHandler *handler)
static void _init_cbs_setDeclHandler_2086_0 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("handler");
decl->add_arg<QXmlDeclHandler * > (argspec_0);
decl->set_return<void > ();
}
static void _call_cbs_setDeclHandler_2086_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
QXmlDeclHandler *arg1 = args.read<QXmlDeclHandler * > (heap);
__SUPPRESS_UNUSED_WARNING(ret);
((QXmlReader_Adaptor *)cls)->cbs_setDeclHandler_2086_0 (arg1);
}
static void _set_callback_cbs_setDeclHandler_2086_0 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_setDeclHandler_2086_0 = cb;
}
// void QXmlReader::setEntityResolver(QXmlEntityResolver *handler)
static void _init_cbs_setEntityResolver_2495_0 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("handler");
decl->add_arg<QXmlEntityResolver * > (argspec_0);
decl->set_return<void > ();
}
static void _call_cbs_setEntityResolver_2495_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
QXmlEntityResolver *arg1 = args.read<QXmlEntityResolver * > (heap);
__SUPPRESS_UNUSED_WARNING(ret);
((QXmlReader_Adaptor *)cls)->cbs_setEntityResolver_2495_0 (arg1);
}
static void _set_callback_cbs_setEntityResolver_2495_0 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_setEntityResolver_2495_0 = cb;
}
// void QXmlReader::setErrorHandler(QXmlErrorHandler *handler)
static void _init_cbs_setErrorHandler_2232_0 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("handler");
decl->add_arg<QXmlErrorHandler * > (argspec_0);
decl->set_return<void > ();
}
static void _call_cbs_setErrorHandler_2232_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
QXmlErrorHandler *arg1 = args.read<QXmlErrorHandler * > (heap);
__SUPPRESS_UNUSED_WARNING(ret);
((QXmlReader_Adaptor *)cls)->cbs_setErrorHandler_2232_0 (arg1);
}
static void _set_callback_cbs_setErrorHandler_2232_0 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_setErrorHandler_2232_0 = cb;
}
// void QXmlReader::setFeature(const QString &name, bool value)
static void _init_cbs_setFeature_2781_0 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("name");
decl->add_arg<const QString & > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("value");
decl->add_arg<bool > (argspec_1);
decl->set_return<void > ();
}
static void _call_cbs_setFeature_2781_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const QString &arg1 = args.read<const QString & > (heap);
bool arg2 = args.read<bool > (heap);
__SUPPRESS_UNUSED_WARNING(ret);
((QXmlReader_Adaptor *)cls)->cbs_setFeature_2781_0 (arg1, arg2);
}
static void _set_callback_cbs_setFeature_2781_0 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_setFeature_2781_0 = cb;
}
// void QXmlReader::setLexicalHandler(QXmlLexicalHandler *handler)
static void _init_cbs_setLexicalHandler_2416_0 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("handler");
decl->add_arg<QXmlLexicalHandler * > (argspec_0);
decl->set_return<void > ();
}
static void _call_cbs_setLexicalHandler_2416_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
QXmlLexicalHandler *arg1 = args.read<QXmlLexicalHandler * > (heap);
__SUPPRESS_UNUSED_WARNING(ret);
((QXmlReader_Adaptor *)cls)->cbs_setLexicalHandler_2416_0 (arg1);
}
static void _set_callback_cbs_setLexicalHandler_2416_0 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_setLexicalHandler_2416_0 = cb;
}
// void QXmlReader::setProperty(const QString &name, void *value)
static void _init_cbs_setProperty_2973_0 (qt_gsi::GenericMethod *decl)
{
static gsi::ArgSpecBase argspec_0 ("name");
decl->add_arg<const QString & > (argspec_0);
static gsi::ArgSpecBase argspec_1 ("value");
decl->add_arg<void * > (argspec_1);
decl->set_return<void > ();
}
static void _call_cbs_setProperty_2973_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
tl::Heap heap;
const QString &arg1 = args.read<const QString & > (heap);
void *arg2 = args.read<void * > (heap);
__SUPPRESS_UNUSED_WARNING(ret);
((QXmlReader_Adaptor *)cls)->cbs_setProperty_2973_0 (arg1, arg2);
}
static void _set_callback_cbs_setProperty_2973_0 (void *cls, const gsi::Callback &cb)
{
((QXmlReader_Adaptor *)cls)->cb_setProperty_2973_0 = cb;
}
namespace gsi
{
gsi::Class<QXmlReader> &qtdecl_QXmlReader ();
static gsi::Methods methods_QXmlReader_Adaptor () {
gsi::Methods methods;

6
src/gsiqt/qt5/QtXml/gsiDeclQtXmlTypeTraits.h
View File

@ -1759,12 +1759,6 @@ template <> struct type_traits<QXmlReader> : public type_traits<void> {
};
}
class QXmlReader_Adaptor;
namespace tl {
template <> struct type_traits<QXmlReader_Adaptor> : public type_traits<void> {
};
}
class QXmlSimpleReader;
namespace tl {
template <> struct type_traits<QXmlSimpleReader> : public type_traits<void> {

6
src/pya/pya/pyaMarshal.cc
View File

@ -631,7 +631,11 @@ struct reader<gsi::ByteArrayType>
} else {
const char *cp = a->c_str ();
size_t sz = a->size ();
*ret = c2python (std::vector<char> (cp, cp + sz));
#if PY_MAJOR_VERSION < 3
*ret = PyByteArray_FromStringAndSize (cp, sz);
#else
*ret = PyBytes_FromStringAndSize (cp, sz);
#endif
}
}
};

6
testdata/python/basic.py vendored
View File

@ -2821,6 +2821,9 @@ class BasicTest(unittest.TestCase):
self.assertEqual(pya.A.qba_ref_to_ia(qba), [ 17, 42, 0, 8 ])
self.assertEqual(pya.A.qba_ptr_to_ia(qba), [ 17, 42, 0, 8 ])
qba = pya.A.ia_cref_to_qba_cref([ 17, 42, 0, 8 ])
self.assertEqual(repr(qba), "b'\\x11*\\x00\\x08'")
self.assertEqual(pya.A.qba_to_ia(b'\x00\x01\x02'), [ 0, 1, 2 ])
ba = pya.A.ia_cref_to_ba([ 17, 42, 0, 8 ])
@ -2831,6 +2834,9 @@ class BasicTest(unittest.TestCase):
self.assertEqual(pya.A.ba_ref_to_ia(ba), [ 17, 42, 0, 8 ])
self.assertEqual(pya.A.ba_ptr_to_ia(ba), [ 17, 42, 0, 8 ])
ba = pya.A.ia_cref_to_ba_cref([ 17, 42, 0, 8 ])
self.assertEqual(repr(ba), "b'\\x11*\\x00\\x08'")
self.assertEqual(pya.A.ba_to_ia(b'\x00\x01\x02'), [ 0, 1, 2 ])
# Custom factory implemented in Python

41
testdata/python/qtbinding.py vendored
View File

@ -487,12 +487,12 @@ class QtBindingTest(unittest.TestCase):
slm = MyStandardItemModel()
rn = slm.roleNames()
self.assertEqual(map2str(rn), "{0: display, 1: decoration, 2: edit, 3: toolTip, 4: statusTip, 5: whatsThis}")
self.assertEqual(map2str(rn), "{0: b'display', 1: b'decoration', 2: b'edit', 3: b'toolTip', 4: b'statusTip', 5: b'whatsThis'}")
rnNew = slm.roleNames()
rnNew[7] = "blabla"
slm.srn(rnNew)
rn = slm.roleNames()
self.assertEqual(map2str(rn), "{0: display, 1: decoration, 2: edit, 3: toolTip, 4: statusTip, 5: whatsThis, 7: blabla}")
self.assertEqual(map2str(rn), "{0: b'display', 1: b'decoration', 2: b'edit', 3: b'toolTip', 4: b'statusTip', 5: b'whatsThis', 7: b'blabla'}")
def test_44(self):
@ -586,6 +586,43 @@ class QtBindingTest(unittest.TestCase):
b.emit_clicked(False)
self.assertEqual(trigger_log, "+-xx")
def test_51(self):
# issue #707 (QJsonValue constructor ambiguous)
if "QJsonValue" in pya.__dict__:
v = pya.QJsonValue("hello")
self.assertEqual(v.toString(), "hello")
self.assertEqual(v.toVariant(), "hello")
self.assertEqual(v.toInt(), 0)
v = pya.QJsonValue(17)
self.assertEqual(v.toString(), "")
self.assertEqual(v.toVariant(), 17)
self.assertEqual(v.toInt(), 17)
v = pya.QJsonValue(2.5)
self.assertEqual(v.toString(), "")
self.assertEqual(v.toVariant(), 2.5)
self.assertEqual(v.toDouble(), 2.5)
v = pya.QJsonValue(True)
self.assertEqual(v.toString(), "")
self.assertEqual(v.toVariant(), True)
self.assertEqual(v.toBool(), True)
def test_52(self):
# issue #708 (Image serialization to QByteArray)
img = pya.QImage(10, 10, pya.QImage.Format_Mono)
img.fill(0)
buf = pya.QBuffer()
img.save(buf, "PNG")
self.assertEqual(len(buf.data) > 100, True)
self.assertEqual(buf.data[0:8], b'\x89PNG\r\n\x1a\n')
# run unit tests
if __name__ == '__main__':

6
testdata/ruby/basic_testcore.rb vendored
View File

@ -2743,6 +2743,9 @@ class Basic_TestClass < TestBase
assert_equal(RBA::A::qba_ref_to_ia(qba), [ 17, 42, 0, 8 ])
assert_equal(RBA::A::qba_ptr_to_ia(qba), [ 17, 42, 0, 8 ])
qba = RBA::A::ia_cref_to_qba_cref([ 17, 42, 0, 8 ])
assert_equal(qba.inspect, "\"\\x11*\\x00\\b\"")
assert_equal(RBA::A::qba_to_ia("\x00\x01\x02"), [ 0, 1, 2 ])
ba = RBA::A::ia_cref_to_ba([ 17, 42, 0, 8 ])
@ -2753,6 +2756,9 @@ class Basic_TestClass < TestBase
assert_equal(RBA::A::ba_ref_to_ia(ba), [ 17, 42, 0, 8 ])
assert_equal(RBA::A::ba_ptr_to_ia(ba), [ 17, 42, 0, 8 ])
ba = RBA::A::ia_cref_to_ba_cref([ 17, 42, 0, 8 ])
assert_equal(ba.inspect, "\"\\x11*\\x00\\b\"")
assert_equal(RBA::A::ba_to_ia("\x00\x01\x02"), [ 0, 1, 2 ])
end

43
testdata/ruby/qtbinding.rb vendored
View File

@ -701,6 +701,49 @@ class QtBinding_TestClass < TestBase
end
def test_51
# issue #707 (QJsonValue constructor ambiguous)
if RBA.const_defined?("QJsonValue")
v = RBA::QJsonValue::new("hello")
assert_equal(v.toString, "hello")
assert_equal(v.toVariant, "hello")
assert_equal(v.toInt, 0)
v = RBA::QJsonValue::new(17)
assert_equal(v.toString, "")
assert_equal(v.toVariant, 17)
assert_equal(v.toInt, 17)
v = RBA::QJsonValue::new(2.5)
assert_equal(v.toString, "")
assert_equal(v.toVariant, 2.5)
assert_equal(v.toDouble, 2.5)
v = RBA::QJsonValue::new(true)
assert_equal(v.toString, "")
assert_equal(v.toVariant, true)
assert_equal(v.toBool, true)
end
end
def test_52
# issue #708 (Image serialization to QByteArray)
img = RBA::QImage::new(10, 10, RBA::QImage::Format_Mono)
img.fill(0)
buf = RBA::QBuffer::new
img.save(buf, "PNG")
assert_equal(buf.data.size > 100, true)
assert_equal(buf.data[0..7].inspect, "\"\\x89PNG\\r\\n\\x1A\\n\"")
end
end
load("test_epilogue.rb")