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

WIP: refactoring of GSI structure for separated modules.

This commit is contained in:
Matthias Koefferlein 2018-05-30 00:39:58 +02:00
parent 0b0393ce56
commit 6468bb7ab9
604 changed files with 9120 additions and 7232 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

148
scripts/mkqtdecl.sh
View File

@ -47,12 +47,14 @@ inst_dir_common=`pwd`/scripts/mkqtdecl_common
inst_dir4=`pwd`/scripts/mkqtdecl4
inst_dir5=`pwd`/scripts/mkqtdecl5
src_dir=`pwd`/src
src_name4=gsiqt4
src_name5=gsiqt5
src_name4=gsiqt/qt4
src_name5=gsiqt/qt5
src_name=$src_name4
inst_dir=$inst_dir4
work_dir="mkqtdecl.tmp"
while [ "$1" != "" ]; do
a="$1"
@ -92,6 +94,7 @@ while [ "$1" != "" ]; do
;;
-qt5)
qt="$qt5"
work_dir="mkqtdecl5.tmp"
inst_dir="$inst_dir5"
src_name="$src_name5"
;;
@ -144,8 +147,6 @@ if ! ruby -e "require 'treetop'" 2>&1; then
exit 1
fi
work_dir="./mkqtdecl.tmp"
if [ $update != 0 ]; then
if [ -e $work_dir ] && [ $reuse == 0 ]; then
@ -155,71 +156,116 @@ if [ $update != 0 ]; then
mkdir -p $work_dir
cd $work_dir
cp $inst_dir/{allofqt.cpp,mkqtdecl.conf,mkqtdecl.properties,mkqtdecl.events} .
cp $inst_dir_common/{cpp_parser_classes.rb,cpp_classes.rb,c++.treetop,parse.rb,reader_ext.rb,produce.rb} .
cp -R $inst_dir/Qt* .
for d in Qt*; do
cd $d
cp $inst_dir/{mkqtdecl.conf,mkqtdecl.properties,mkqtdecl.events} .
cp $inst_dir_common/{cpp_parser_classes.rb,cpp_classes.rb,c++.treetop,parse.rb,reader_ext.rb,produce.rb} .
cd ..
done
if [ $reuse == 0 ]; then
echo "Running gcc preprocessor .."
# By using -D_GCC_LIMITS_H_ we make the gcc not include constants such as ULONG_MAX which will
# remain as such. This way the generated code is more generic.
gcc -I$qt -fPIC -D_GCC_LIMITS_H_ -E -o allofqt.x allofqt.cpp
for d in Qt*; do
echo "Stripping hash lines .."
egrep -v '^#' <allofqt.x >allofqt.e
rm allofqt.x
echo "--------------------------------------------------------"
echo "Parsing $d ..."
echo ""
echo "Parsing and producing db .."
./parse.rb -i allofqt.e -o allofqt.db
cd $d
echo "Running gcc preprocessor .."
# By using -D_GCC_LIMITS_H_ we make the gcc not include constants such as ULONG_MAX which will
# remain as such. This way the generated code is more generic.
gcc -I$qt -fPIC -D_GCC_LIMITS_H_ -E -o allofqt.x allofqt.cpp
echo "Stripping hash lines .."
egrep -v '^#' <allofqt.x >allofqt.e
rm allofqt.x
echo "Parsing and producing db .."
./parse.rb -i allofqt.e -o allofqt.db
cd ..
done
fi
mkdir -p generated
rm -f produced.txt
touch produced.txt
echo "Producing code .."
./produce.rb -i allofqt.db
# Note the order of the modules is important: first modules get the
# classes first
for d in QtCore QtGui QtDesigner QtNetwork QtSql QtXml; do
cd $d
mkdir -p generated
echo "Producing code .."
./produce.rb -x ../produced.txt -i allofqt.db -m $d
# mark classes produced here as done
cat class_list.txt >>../produced.txt
cd ..
done
else
cd $work_dir
fi
if [ ! -e generated ]; then
echo "*** ERROR: production output ("`pwd`"/generated) does not exist - production failed?"
exit 1
fi
for d in Qt*; do
cd generated
echo "--------------------------------------------------------"
echo "Processing $d ..."
echo ""
if [ $dry != 0 ]; then
echo "Synchronizing dry run .."
else
echo "Synchronizing .."
fi
cd $d
count=0
for f in {*.cc,*.h} qtdecl.pri; do
needs_update=0
if ! [ -e $src_dir/$src_name/$f ]; then
echo "# INFO: creating new file $src_dir/$src_name/$f"
needs_update=1
elif ! cmp -s $f $src_dir/$src_name/$f; then
echo "# INFO: out of date: syncing file $src_dir/$src_name/$f"
needs_update=1
if [ ! -e generated ]; then
echo "*** ERROR: production output ("`pwd`"/generated) does not exist - production failed?"
exit 1
fi
if [ $needs_update != 0 ]; then
count=`expr $count + 1`
if [ $dry != 0 ]; then
echo cp $f $src_dir/$src_name/$f
else
echo === cp $f $src_dir/$src_name/$f
cp $f $src_dir/$src_name/$f
cd generated
if [ $dry != 0 ]; then
echo "Synchronizing dry run .."
else
echo "Synchronizing .."
fi
count=0
for f in {*.cc,*.h} $d.pri; do
needs_update=0
if ! [ -e $src_dir/$src_name/$d/$f ]; then
echo "# INFO: creating new file $src_dir/$src_name/$f"
needs_update=1
elif ! cmp -s $f $src_dir/$src_name/$d/$f; then
echo "# INFO: out of date: syncing file $src_dir/$src_name/$f"
needs_update=1
fi
if [ $needs_update != 0 ]; then
count=`expr $count + 1`
if [ $dry != 0 ]; then
echo cp $f $src_dir/$src_name/$d/$f
else
echo === cp $f $src_dir/$src_name/$d/$f
cp $f $src_dir/$src_name/$d/$f
fi
fi
done
if [ $dry != 0 ]; then
echo "# INFO: $count files to synchronize"
else
echo "# INFO: $count files synchronized"
fi
cd ..
cd ..
done
if [ $dry != 0 ]; then
echo "# INFO: $count files to synchronize"
else
echo "# INFO: $count files synchronized"
fi

76
scripts/mkqtdecl4/QtCore/allofqt.cpp Normal file
View File

@ -0,0 +1,76 @@
#include "QtCore/QTextStream"
#include "QtCore/QAbstractItemModel"
#include "QtCore/QAbstractListModel"
#include "QtCore/QAbstractTableModel"
#include "QtCore/QBasicTimer"
#include "QtCore/QByteArrayMatcher"
#include "QtCore/QChildEvent"
#include "QtCore/QCoreApplication"
#include "QtCore/QCryptographicHash"
#include "QtCore/QCustomEvent"
#include "QtCore/QDataStream"
#include "QtCore/QDate"
#include "QtCore/QDateTime"
#include "QtCore/QDir"
#include "QtCore/QDynamicPropertyChangeEvent"
#include "QtCore/QEasingCurve"
#include "QtCore/QEvent"
#include "QtCore/QEventLoop"
#include "QtCore/QFactoryInterface"
#include "QtCore/QFile"
#include "QtCore/QFileInfo"
#include "QtCore/QFileSystemWatcher"
#include "QtCore/QIODevice"
#include "QtCore/QLibrary"
#include "QtCore/QLibraryInfo"
#include "QtCore/QLine"
#include "QtCore/QLineF"
#include "QtCore/QLocale"
#include "QtCore/QMargins"
#include "QtCore/QMetaClassInfo"
#include "QtCore/QMetaEnum"
#include "QtCore/QMetaMethod"
#include "QtCore/QMetaObject"
#include "QtCore/QMetaProperty"
#include "QtCore/QMetaType"
#include "QtCore/QMimeData"
#include "QtCore/QModelIndex"
#include "QtCore/QMutex"
#include "QtCore/QObject"
#include "QtCore/QPersistentModelIndex"
#include "QtCore/QPluginLoader"
#include "QtCore/QPoint"
#include "QtCore/QPointF"
#include "QtCore/QProcess"
#include "QtCore/QProcessEnvironment"
#include "QtCore/QReadLocker"
#include "QtCore/QReadWriteLock"
#include "QtCore/QRect"
#include "QtCore/QRectF"
#include "QtCore/QRegExp"
#include "QtCore/QResource"
#include "QtCore/QSemaphore"
#include "QtCore/QSettings"
#include "QtCore/QSignalMapper"
#include "QtCore/QSize"
#include "QtCore/QSizeF"
#include "QtCore/QSocketNotifier"
#include "QtCore/QStringMatcher"
#include "QtCore/QSysInfo"
#include "QtCore/QSystemLocale"
#include "QtCore/QTemporaryFile"
#include "QtCore/QThread"
#include "QtCore/QTime"
#include "QtCore/QTimeLine"
#include "QtCore/QTimer"
#include "QtCore/QTimerEvent"
#include "QtCore/QTranslator"
#include "QtCore/QUrl"
#include "QtCore/QVariant"
#include "QtCore/QWaitCondition"
#include "QtCore/QWriteLocker"
#include "QtCore/QTextCodec"
#include "QtCore/QTextDecoder"
#include "QtCore/QTextEncoder"
#include "QtCore/QBuffer"
#include "QtCore/Qt"

2
scripts/mkqtdecl4/QtDesigner/allofqt.cpp Normal file
View File

@ -0,0 +1,2 @@
#include "QtDesigner/QAbstractFormBuilder"
#include "QtDesigner/QFormBuilder"

153
scripts/mkqtdecl4/allofqt.cpp → scripts/mkqtdecl4/QtGui/allofqt.cpp
View File

@ -349,156 +349,3 @@
#include "QtGui/QWizardPage"
#include "QtGui/QPrinter"
#include "QtGui/QAccessible"
#include "QtCore/QTextStream"
#include "QtCore/QAbstractItemModel"
#include "QtCore/QAbstractListModel"
#include "QtCore/QAbstractTableModel"
#include "QtCore/QBasicTimer"
#include "QtCore/QByteArrayMatcher"
#include "QtCore/QChildEvent"
#include "QtCore/QCoreApplication"
#include "QtCore/QCryptographicHash"
#include "QtCore/QCustomEvent"
#include "QtCore/QDataStream"
#include "QtCore/QDate"
#include "QtCore/QDateTime"
#include "QtCore/QDir"
#include "QtCore/QDynamicPropertyChangeEvent"
#include "QtCore/QEasingCurve"
#include "QtCore/QEvent"
#include "QtCore/QEventLoop"
#include "QtCore/QFactoryInterface"
#include "QtCore/QFile"
#include "QtCore/QFileInfo"
#include "QtCore/QFileSystemWatcher"
#include "QtCore/QIODevice"
#include "QtCore/QLibrary"
#include "QtCore/QLibraryInfo"
#include "QtCore/QLine"
#include "QtCore/QLineF"
#include "QtCore/QLocale"
#include "QtCore/QMargins"
#include "QtCore/QMetaClassInfo"
#include "QtCore/QMetaEnum"
#include "QtCore/QMetaMethod"
#include "QtCore/QMetaObject"
#include "QtCore/QMetaProperty"
#include "QtCore/QMetaType"
#include "QtCore/QMimeData"
#include "QtCore/QModelIndex"
#include "QtCore/QMutex"
#include "QtCore/QObject"
#include "QtCore/QPersistentModelIndex"
#include "QtCore/QPluginLoader"
#include "QtCore/QPoint"
#include "QtCore/QPointF"
#include "QtCore/QProcess"
#include "QtCore/QProcessEnvironment"
#include "QtCore/QReadLocker"
#include "QtCore/QReadWriteLock"
#include "QtCore/QRect"
#include "QtCore/QRectF"
#include "QtCore/QRegExp"
#include "QtCore/QResource"
#include "QtCore/QSemaphore"
#include "QtCore/QSettings"
#include "QtCore/QSignalMapper"
#include "QtCore/QSize"
#include "QtCore/QSizeF"
#include "QtCore/QSocketNotifier"
#include "QtCore/QStringMatcher"
#include "QtCore/QSysInfo"
#include "QtCore/QSystemLocale"
#include "QtCore/QTemporaryFile"
#include "QtCore/QThread"
#include "QtCore/QTime"
#include "QtCore/QTimeLine"
#include "QtCore/QTimer"
#include "QtCore/QTimerEvent"
#include "QtCore/QTranslator"
#include "QtCore/QUrl"
#include "QtCore/QVariant"
#include "QtCore/QWaitCondition"
#include "QtCore/QWriteLocker"
#include "QtCore/QTextCodec"
#include "QtCore/QTextDecoder"
#include "QtCore/QTextEncoder"
#include "QtCore/QBuffer"
#include "QtXml/QDomNode"
#include "QtXml/QDomNodeList"
#include "QtXml/QDomCharacterData"
#include "QtXml/QDomText"
#include "QtXml/QDomAttr"
#include "QtXml/QDomCDATASection"
#include "QtXml/QDomComment"
#include "QtXml/QDomDocument"
#include "QtXml/QDomDocumentFragment"
#include "QtXml/QDomDocumentType"
#include "QtXml/QDomElement"
#include "QtXml/QDomEntity"
#include "QtXml/QDomEntityReference"
#include "QtXml/QDomImplementation"
#include "QtXml/QDomNamedNodeMap"
#include "QtXml/QDomNotation"
#include "QtXml/QDomProcessingInstruction"
#include "QtXml/QXmlAttributes"
#include "QtXml/QXmlContentHandler"
#include "QtXml/QXmlDeclHandler"
#include "QtXml/QXmlDefaultHandler"
#include "QtXml/QXmlDTDHandler"
#include "QtXml/QXmlEntityResolver"
#include "QtXml/QXmlErrorHandler"
#include "QtXml/QXmlInputSource"
#include "QtXml/QXmlLexicalHandler"
#include "QtXml/QXmlLocator"
#include "QtXml/QXmlNamespaceSupport"
#include "QtXml/QXmlParseException"
#include "QtXml/QXmlReader"
#include "QtXml/QXmlSimpleReader"
#include "QtNetwork/QAbstractNetworkCache"
#include "QtNetwork/QAuthenticator"
#include "QtNetwork/QFtp"
#include "QtNetwork/QHostAddress"
#include "QtNetwork/QHostInfo"
#include "QtNetwork/QLocalServer"
#include "QtNetwork/QLocalSocket"
#include "QtNetwork/QNetworkAccessManager"
#include "QtNetwork/QNetworkAddressEntry"
#include "QtNetwork/QNetworkCacheMetaData"
#include "QtNetwork/QNetworkCookie"
#include "QtNetwork/QNetworkCookieJar"
#include "QtNetwork/QNetworkDiskCache"
#include "QtNetwork/QNetworkInterface"
#include "QtNetwork/QNetworkProxy"
#include "QtNetwork/QNetworkProxyFactory"
#include "QtNetwork/QNetworkProxyQuery"
#include "QtNetwork/QNetworkReply"
#include "QtNetwork/QNetworkRequest"
#include "QtNetwork/QSslCertificate"
#include "QtNetwork/QSslCipher"
#include "QtNetwork/QSslConfiguration"
#include "QtNetwork/QSslError"
#include "QtNetwork/QSslKey"
#include "QtNetwork/QSslSocket"
#include "QtNetwork/QTcpServer"
#include "QtNetwork/QTcpSocket"
#include "QtNetwork/QUdpSocket"
#include "QtNetwork/QUrlInfo"
#include "QtNetwork/QAbstractSocket"
#include "QtSql/QSqlDatabase"
#include "QtSql/QSqlDriver"
#include "QtSql/QSqlDriverCreatorBase"
#include "QtSql/QSqlError"
#include "QtSql/QSqlField"
#include "QtSql/QSqlIndex"
#include "QtSql/QSqlQuery"
#include "QtSql/QSqlQueryModel"
#include "QtSql/QSqlRecord"
#include "QtSql/QSqlRelation"
#include "QtSql/QSqlRelationalDelegate"
#include "QtSql/QSqlRelationalTableModel"
#include "QtSql/QSqlResult"
#include "QtSql/QSqlTableModel"
#include "QtDesigner/QAbstractFormBuilder"
#include "QtDesigner/QFormBuilder"
#include "QtCore/Qt"

30
scripts/mkqtdecl4/QtNetwork/allofqt.cpp Normal file
View File

@ -0,0 +1,30 @@
#include "QtNetwork/QAbstractNetworkCache"
#include "QtNetwork/QAuthenticator"
#include "QtNetwork/QFtp"
#include "QtNetwork/QHostAddress"
#include "QtNetwork/QHostInfo"
#include "QtNetwork/QLocalServer"
#include "QtNetwork/QLocalSocket"
#include "QtNetwork/QNetworkAccessManager"
#include "QtNetwork/QNetworkAddressEntry"
#include "QtNetwork/QNetworkCacheMetaData"
#include "QtNetwork/QNetworkCookie"
#include "QtNetwork/QNetworkCookieJar"
#include "QtNetwork/QNetworkDiskCache"
#include "QtNetwork/QNetworkInterface"
#include "QtNetwork/QNetworkProxy"
#include "QtNetwork/QNetworkProxyFactory"
#include "QtNetwork/QNetworkProxyQuery"
#include "QtNetwork/QNetworkReply"
#include "QtNetwork/QNetworkRequest"
#include "QtNetwork/QSslCertificate"
#include "QtNetwork/QSslCipher"
#include "QtNetwork/QSslConfiguration"
#include "QtNetwork/QSslError"
#include "QtNetwork/QSslKey"
#include "QtNetwork/QSslSocket"
#include "QtNetwork/QTcpServer"
#include "QtNetwork/QTcpSocket"
#include "QtNetwork/QUdpSocket"
#include "QtNetwork/QUrlInfo"
#include "QtNetwork/QAbstractSocket"

14
scripts/mkqtdecl4/QtSql/allofqt.cpp Normal file
View File

@ -0,0 +1,14 @@
#include "QtSql/QSqlDatabase"
#include "QtSql/QSqlDriver"
#include "QtSql/QSqlDriverCreatorBase"
#include "QtSql/QSqlError"
#include "QtSql/QSqlField"
#include "QtSql/QSqlIndex"
#include "QtSql/QSqlQuery"
#include "QtSql/QSqlQueryModel"
#include "QtSql/QSqlRecord"
#include "QtSql/QSqlRelation"
#include "QtSql/QSqlRelationalDelegate"
#include "QtSql/QSqlRelationalTableModel"
#include "QtSql/QSqlResult"
#include "QtSql/QSqlTableModel"

31
scripts/mkqtdecl4/QtXml/allofqt.cpp Normal file
View File

@ -0,0 +1,31 @@
#include "QtXml/QDomNode"
#include "QtXml/QDomNodeList"
#include "QtXml/QDomCharacterData"
#include "QtXml/QDomText"
#include "QtXml/QDomAttr"
#include "QtXml/QDomCDATASection"
#include "QtXml/QDomComment"
#include "QtXml/QDomDocument"
#include "QtXml/QDomDocumentFragment"
#include "QtXml/QDomDocumentType"
#include "QtXml/QDomElement"
#include "QtXml/QDomEntity"
#include "QtXml/QDomEntityReference"
#include "QtXml/QDomImplementation"
#include "QtXml/QDomNamedNodeMap"
#include "QtXml/QDomNotation"
#include "QtXml/QDomProcessingInstruction"
#include "QtXml/QXmlAttributes"
#include "QtXml/QXmlContentHandler"
#include "QtXml/QXmlDeclHandler"
#include "QtXml/QXmlDefaultHandler"
#include "QtXml/QXmlDTDHandler"
#include "QtXml/QXmlEntityResolver"
#include "QtXml/QXmlErrorHandler"
#include "QtXml/QXmlInputSource"
#include "QtXml/QXmlLexicalHandler"
#include "QtXml/QXmlLocator"
#include "QtXml/QXmlNamespaceSupport"
#include "QtXml/QXmlParseException"
#include "QtXml/QXmlReader"
#include "QtXml/QXmlSimpleReader"

2
scripts/mkqtdecl4/mkqtdecl.conf
View File

@ -295,7 +295,7 @@ add_native_impl("QChildEvent", <<'CODE', <<'DECL')
{
public:
RawQObjectClass ()
: gsi::Class<QObject> (gsi::qtdecl_QObject (), "QObject_Raw", gsi::Methods (), "@hide")
: gsi::Class<QObject> (gsi::qtdecl_QObject (), "Qt", "QObject_Raw", gsi::Methods (), "@hide")
{
}

78
scripts/mkqtdecl_common/produce.rb
View File

@ -27,6 +27,8 @@ require 'reader_ext.rb'
input_file = "all.db"
conf_file = "mkqtdecl.conf"
cls_list = nil
excl_list = {}
modn = "Qt"
$gen_dir = "generated"
while ARGV.size > 0
@ -35,8 +37,15 @@ while ARGV.size > 0
input_file = ARGV.shift
elsif o == "-c"
cls_list = ARGV.shift
elsif o == "-x"
excl_file = ARGV.shift
File.open(excl_file, "r") do |file|
file.each_line { |l| excl_list[l.chop] = true }
end
elsif o == "-s"
conf_file = ARGV.shift
elsif o == "-m"
modn = ARGV.shift
else
raise("Invalid option #{o} - usage is 'produce.rb -s mkqtdecl.conf -i all.db -c QWidget,QSizePolicy'")
end
@ -363,6 +372,9 @@ class CPPStruct
if bd.is_a?(CPPDeclaration) && ! bd.template_decl
# only public ctors are considered - currently protected ones are not used
bd.visibility == :public || next
func = bd.type.func
if func
@ -1285,6 +1297,8 @@ end
class BindingProducer
attr_accessor :modn
# @brief Read the input file (JSON)
#
# This method will set up the binding producer for generating
@ -1293,6 +1307,7 @@ class BindingProducer
def read(input_file)
@source_files = nil
@classes = nil
@ext_decls = []
File.open(input_file, "r") do |file|
@ -1386,6 +1401,8 @@ class BindingProducer
while cont
(cls, clsn) = make_cls_names(decl_obj)
@classes ||= []
@classes << clsn
if index > 0
ofile_name = "gsiDecl#{clsn}_#{index}.cc"
@ -1495,6 +1512,7 @@ END
methods = {}
struct.collect_all_methods(methods, conf)
methods[cls] = struct.collect_ctors
needs_adaptor = struct.needs_adaptor(conf)
used_classes = {}
@ -1503,7 +1521,7 @@ END
m.each do |bd|
vis = bd.visibility
if vis == :public || vis == :protected
if vis == :public || (vis == :protected && needs_adaptor)
# don't consider dropped methods
conf.target_name(cls, bd, mn) || next
@ -1520,7 +1538,7 @@ END
end
used_classes.values.map { |uc| uc.myself }.select { |uc| !conf.is_class_dropped?(uc) && uc != cls }.sort.each do |uc|
used_classes.values.map { |uc| uc.myself || uc.myself_weak }.select { |uc| !conf.is_class_dropped?(uc) && uc != cls }.sort.each do |uc|
ofile.puts("#include <#{uc}>")
end
@ -1535,8 +1553,8 @@ END
end
ofile.puts("#include \"gsiQt.h\"")
ofile.puts("#include \"gsiQtCommon.h\"")
ofile.puts("#include \"gsiDeclQtTypeTraits.h\"")
ofile.puts("#include \"gsi#{modn}Common.h\"")
ofile.puts("#include \"gsiDecl#{modn}TypeTraits.h\"")
end
@ -1561,7 +1579,7 @@ END
if index == 0
ofile.puts("namespace gsi")
ofile.puts("{")
ofile.puts("gsi::Class<#{cls}_Namespace> decl_#{cls}_Namespace (\"#{clsn}\",")
ofile.puts("gsi::Class<#{cls}_Namespace> decl_#{cls}_Namespace (\"#{modn}\", \"#{clsn}\",")
ofile.puts(" gsi::Methods(),")
ofile.puts(" \"@qt\\n@brief This class represents the #{cls} namespace\");")
ofile.puts("}")
@ -1597,7 +1615,7 @@ END
ofile.puts("namespace qt_gsi")
ofile.puts("{")
ofile.puts("")
ofile.puts("static gsi::Enum<#{cls}::#{en}> decl_#{clsn}_#{en}_Enum (\"#{clsn}_#{en}\",")
ofile.puts("static gsi::Enum<#{cls}::#{en}> decl_#{clsn}_#{en}_Enum (\"#{modn}\", \"#{clsn}_#{en}\",")
edecl = []
@ -1618,7 +1636,7 @@ END
ofile.puts(" \"@qt\\n@brief This class represents the #{cls}::#{en} enum\");")
ofile.puts("")
ofile.puts("static gsi::QFlagsClass<#{cls}::#{en} > decl_#{clsn}_#{en}_Enums (\"#{clsn}_QFlags_#{en}\",")
ofile.puts("static gsi::QFlagsClass<#{cls}::#{en} > decl_#{clsn}_#{en}_Enums (\"#{modn}\", \"#{clsn}_QFlags_#{en}\",")
ofile.puts(" \"@qt\\n@brief This class represents the QFlags<#{cls}::#{en}> flag set\");")
ofile.puts("")
@ -1640,8 +1658,8 @@ END
end
ofile.puts("static gsi::ClassExt<#{pname}> inject_#{clsn}_#{en}_Enum_in_parent (decl_#{clsn}_#{en}_Enum.defs ());")
ofile.puts("static gsi::ClassExt<#{pname}> decl_#{clsn}_#{en}_Enum_as_child (decl_#{clsn}_#{en}_Enum, \"#{en}\");")
ofile.puts("static gsi::ClassExt<#{pname}> decl_#{clsn}_#{en}_Enums_as_child (decl_#{clsn}_#{en}_Enums, \"QFlags_#{en}\");")
ofile.puts("static gsi::ClassExt<#{pname}> decl_#{clsn}_#{en}_Enum_as_child (decl_#{clsn}_#{en}_Enum, \"#{modn}\", \"#{en}\");")
ofile.puts("static gsi::ClassExt<#{pname}> decl_#{clsn}_#{en}_Enums_as_child (decl_#{clsn}_#{en}_Enums, \"#{modn}\", \"QFlags_#{en}\");")
ofile.puts("")
ofile.puts("}")
@ -2249,9 +2267,9 @@ END
if base_cls
ofile.puts("gsi::Class<#{base_cls}> &qtdecl_#{base_clsn} ();")
ofile.puts("")
ofile.puts("#{decl_type} decl_#{clsn} (" + "qtdecl_#{base_clsn} (), \"#{clsn}" + (needs_adaptor ? "_Native" : "") + "\",")
ofile.puts("#{decl_type} decl_#{clsn} (" + "qtdecl_#{base_clsn} (), \"#{modn}\", \"#{clsn}" + (needs_adaptor ? "_Native" : "") + "\",")
else
ofile.puts("#{decl_type} decl_#{clsn} (" + "\"#{clsn}" + (needs_adaptor ? "_Native" : "") + "\",")
ofile.puts("#{decl_type} decl_#{clsn} (\"#{modn}\", \"#{clsn}" + (needs_adaptor ? "_Native" : "") + "\",")
end
if native_impl
native_impl.each { |n| n[1] && ofile.puts(n[1] + "+") }
@ -2279,7 +2297,7 @@ END
pcls = o.myself + "::" + pcls
end
ofile.puts("gsi::ClassExt<#{pcls}> decl_#{clsn}_as_child (decl_#{clsn}, \"#{cclsn}\");")
ofile.puts("gsi::ClassExt<#{pcls}> decl_#{clsn}_as_child (decl_#{clsn}, \"#{modn}\", \"#{cclsn}\");")
end
@ -2287,11 +2305,11 @@ END
if !is_child_class
# only for top-level classes external declarations are produced currently
@ext_decls << "#{struct.kind.to_s} #{cls};\nnamespace gsi { GSIQT_PUBLIC gsi::Class<#{cls}> &qtdecl_#{clsn} (); }\n\n"
@ext_decls << "#{struct.kind.to_s} #{cls};\nnamespace gsi { GSI_#{modn.upcase}_PUBLIC gsi::Class<#{cls}> &qtdecl_#{clsn} (); }\n\n"
end
ofile.puts("")
ofile.puts("GSIQT_PUBLIC gsi::Class<#{cls}> &qtdecl_#{clsn} () { return decl_#{clsn}; }")
ofile.puts("GSI_#{modn.upcase}_PUBLIC gsi::Class<#{cls}> &qtdecl_#{clsn} () { return decl_#{clsn}; }")
ofile.puts("")
ofile.puts("}")
@ -2772,7 +2790,7 @@ END
ofile.puts(" return methods;")
ofile.puts("}")
ofile.puts("")
ofile.puts("gsi::Class<#{clsn}_Adaptor> decl_#{clsn}_Adaptor (qtdecl_#{clsn} (), \"#{clsn}\",")
ofile.puts("gsi::Class<#{clsn}_Adaptor> decl_#{clsn}_Adaptor (qtdecl_#{clsn} (), \"#{modn}\", \"#{clsn}\",")
if native_impl
native_impl.each { |n| n[1] && ofile.puts(n[1] + "+") }
end
@ -2792,7 +2810,7 @@ END
pcls = o.myself + "::" + pcls
end
ofile.puts("gsi::ClassExt<#{pcls}> decl_#{clsn}_as_child (decl_#{clsn}_Adaptor, \"#{cclsn}\");")
ofile.puts("gsi::ClassExt<#{pcls}> decl_#{clsn}_as_child (decl_#{clsn}_Adaptor, \"#{modn}\", \"#{cclsn}\");")
end
@ -2882,7 +2900,7 @@ END
def produce_ttfile(conf)
ttfile_name = "gsiDeclQtTypeTraits.h"
ttfile_name = "gsiDecl#{modn}TypeTraits.h"
ttfile_path = $gen_dir + "/" + ttfile_name
ttfile_path && File.open(ttfile_path, "w") do |ttfile|
@ -2920,8 +2938,8 @@ END
ttfile.puts("* This file has been created automatically")
ttfile.puts("*/")
ttfile.puts("")
ttfile.puts("#ifndef _HDR_gsiDeclQtTypeTraits")
ttfile.puts("#define _HDR_gsiDeclQtTypeTraits")
ttfile.puts("#ifndef _HDR_gsiDecl#{modn}TypeTraits")
ttfile.puts("#define _HDR_gsiDecl#{modn}TypeTraits")
ttfile.puts("")
ttfile.puts("#include \"gsiTypes.h\"")
ttfile.puts("")
@ -2932,7 +2950,7 @@ END
if decl_obj.is_a?(CPPStructDeclaration)
produce_ttfile_traits(ttfile, conf, decl_obj)
decl_obj.myself && produce_ttfile_traits(ttfile, conf, decl_obj)
elsif decl_obj.is_a?(CPPNamespace)
@ -3004,7 +3022,7 @@ END
extfile.puts("")
extfile.puts("#include \"gsiClassBase.h\"")
extfile.puts("#include \"gsiQtCommon.h\"")
extfile.puts("#include \"gsi#{modn}Common.h\"")
extfile.puts("")
@ext_decls.each do |ed|
@ -3023,7 +3041,7 @@ END
def produce_makefile
makefile_name = "qtdecl.pri"
makefile_name = modn + ".pri"
makefile_path = $gen_dir + "/" + makefile_name
File.open(makefile_path, "w") do |makefile|
@ -3047,6 +3065,16 @@ END
end
def produce_class_list
File.open("class_list.txt", "w") do |list|
(@classes || []).each do |c|
list.puts(c)
end
end
end
end
# ---------------------------------------------------------------------
@ -3058,6 +3086,7 @@ File.open(conf_file, "r") do |file|
end
bp = BindingProducer::new
bp.modn = modn
bp.read(input_file)
puts("Collecting used enums ..")
@ -3074,9 +3103,12 @@ if cls_list
end
else
bp.prod_list(conf).each do |decl_obj|
bp.produce_cpp_from_decl(conf, decl_obj)
if decl_obj.myself && !excl_list[decl_obj.myself]
bp.produce_cpp_from_decl(conf, decl_obj)
end
end
end
bp.produce_class_list
puts("Producing type traits file ..")
bp.produce_ttfile(conf)

23
scripts/mkqtdecl_common/reader_ext.rb
View File

@ -35,6 +35,12 @@ class CPPObject
nil
end
# delivers a string representation of the "weak" name or nil if the object does not have a name
# to contribute. "weak names" are such of second order - e.g. forward declarations.
def myself_weak
nil
end
# delivers a CPPQualifiedId representation of the object's location or nil if the object
# does not have a location to contribute
def myid
@ -155,8 +161,13 @@ module QualifiedNameResolver
@id2obj = {}
self.children.each do |d|
d.myself && (@id2obj[d.myself] = d)
d.set_parent(self)
end
self.children.each do |d|
d.myself_weak && (@id2obj[d.myself_weak] ||= d)
end
self.children.each do |d|
d.set_parent(self)
end
# Add other children, for example contributed by base classes
if self.respond_to?(:other_children)
self.other_children.each do |d|
@ -171,6 +182,11 @@ module QualifiedNameResolver
end
end
# by default the objects don't have a weak identity
def myself_weak
nil
end
# returns a list of names of child objects
def ids
(@id2obj || {}).keys.sort
@ -390,6 +406,11 @@ class CPPStructDeclaration
end
def myself_weak
# the weak identity will also include forward declarations
self.struct.id.to_s
end
def myself
# forward declarations (struct.body_decl == nil and no base classes) don't produce a name and
# will therefore not contribute

4
src/ant/ant/gsiDeclAnt.cc
View File

@ -421,9 +421,9 @@ static void register_annotation_template (const ant::Object &a, const std::strin
}
// NOTE: ant::Object is available as "BasicAnnotation" to allow binding for other methods.
gsi::Class<ant::Object> decl_BasicAnnotation ("BasicAnnotation", gsi::Methods (), "@hide\n@alias Annotation");
gsi::Class<ant::Object> decl_BasicAnnotation ("lay", "BasicAnnotation", gsi::Methods (), "@hide\n@alias Annotation");
gsi::Class<AnnotationRef> decl_Annotation (decl_BasicAnnotation, "Annotation",
gsi::Class<AnnotationRef> decl_Annotation (decl_BasicAnnotation, "lay", "Annotation",
gsi::method ("register_template", &gsi::register_annotation_template,
gsi::arg ("annotation"), gsi::arg ("title"), gsi::arg ("mode", ruler_mode_normal (), "\\RulerModeNormal"),
"@brief Registers the given annotation as a template\n"

2
src/edt/edt/gsiDeclEdt.cc
View File

@ -94,7 +94,7 @@ static db::DCplxTrans dtrans (const lay::ObjectInstPath *p)
}
}
gsi::Class<lay::ObjectInstPath> decl_ObjectInstPath ("ObjectInstPath",
gsi::Class<lay::ObjectInstPath> decl_ObjectInstPath ("lay", "ObjectInstPath",
gsi::method ("<", &lay::ObjectInstPath::operator<,
"@brief Provides an order criterion for two ObjectInstPath objects\n"
"@args b\n"

2
src/ext/ext/extLEFDEFPlugin.cc
View File

@ -351,7 +351,7 @@ static void set_net_property_name (LEFDEFReaderOptions *config, const tl::Varian
}
static
gsi::Class<LEFDEFReaderOptions> decl_lefdef_config ("LEFDEFReaderConfiguration",
gsi::Class<LEFDEFReaderOptions> decl_lefdef_config ("lay", "LEFDEFReaderConfiguration",
gsi::method ("layer_map", (db::LayerMap &(LEFDEFReaderOptions::*) ()) &LEFDEFReaderOptions::layer_map,
"@brief Gets the layer map to be used for the LEF/DEF reader\n"
"@return A reference to the layer map\n"

6
src/ext/ext/extNetTracerPlugin.cc
View File

@ -169,7 +169,7 @@ static void def_symbol (ext::NetTracerTechnologyComponent *tech, const std::stri
gsi::Class<lay::TechnologyComponent> &decl_layTechnologyComponent ();
gsi::Class<ext::NetTracerTechnologyComponent> decl_NetTracerTechnology (decl_layTechnologyComponent (), "NetTracerTechnology",
gsi::Class<ext::NetTracerTechnologyComponent> decl_NetTracerTechnology (decl_layTechnologyComponent (), "lay", "NetTracerTechnology",
gsi::method_ext ("connection", &def_connection2, gsi::arg("a"), gsi::arg("b"),
"@brief Defines a connection between two materials\n"
"See the class description for details about this method."
@ -259,7 +259,7 @@ static void trace2_tn (ext::NetTracer *net_tracer, const std::string &tech, cons
net_tracer->trace (layout, cell, start_point, start_layer, stop_point, stop_layer, tracer_data);
}
gsi::Class<ext::NetTracerShape> decl_NetElement ("NetElement",
gsi::Class<ext::NetTracerShape> decl_NetElement ("lay", "NetElement",
gsi::method ("trans", &ext::NetTracerShape::trans,
"@brief Gets the transformation to apply for rendering the shape in the original top cell\n"
"See the class description for more details about this attribute."
@ -304,7 +304,7 @@ gsi::Class<ext::NetTracerShape> decl_NetElement ("NetElement",
"This class has been introduced in version 0.25.\n"
);
gsi::Class<ext::NetTracer> decl_NetTracer ("NetTracer",
gsi::Class<ext::NetTracer> decl_NetTracer ("lay", "NetTracer",
gsi::method_ext ("trace", &trace1, gsi::arg ("tech"), gsi::arg ("layout"), gsi::arg ("cell"), gsi::arg ("start_point"), gsi::arg ("start_layer"),
"@brief Runs a net extraction\n"
"\n"

2
src/gsi/gsi/gsiClass.cc
View File

@ -35,7 +35,7 @@ namespace gsi
// The dummy class is just provided to avoid some assertions.
struct EmptyClass { };
static gsi::Class<EmptyClass> default_cls ("EmptyClass", gsi::Methods ());
static gsi::Class<EmptyClass> default_cls ("tl", "EmptyClass", gsi::Methods ());
const ClassBase *fallback_cls_decl (const std::type_info &ti)
{

39
src/gsi/gsi/gsiClass.h
View File

@ -578,9 +578,10 @@ public:
* This feature is not quite useful usually and is reserved for special use cases
* such as including enums into a declaration namespace.
*/
ClassExt (const ClassBase &import, const std::string &name, const std::string &doc = std::string ())
ClassExt (const ClassBase &import, const std::string &module, const std::string &name, const std::string &doc = std::string ())
: ClassBase (doc, Methods ()), mp_declaration (&import)
{
set_module (module);
set_name (name);
}
@ -716,30 +717,34 @@ public:
typedef typename tl::type_traits<X>::has_default_constructor has_default_ctor;
typedef typename tl::type_traits<X>::has_public_destructor has_public_dtor;
Class (const std::string &name, const Methods &mm, const std::string &doc = std::string (), bool do_register = true)
Class (const std::string &module, const std::string &name, const Methods &mm, const std::string &doc = std::string (), bool do_register = true)
: ClassBase (doc, mm, do_register)
{
set_module (module);
set_name (name);
}
template <class B>
Class (const Class<B> &base, const std::string &name, const Methods &mm, const std::string &doc = std::string (), bool do_register = true)
Class (const Class<B> &base, const std::string &module, const std::string &name, const Methods &mm, const std::string &doc = std::string (), bool do_register = true)
: ClassBase (doc, mm, do_register), m_subclass_tester (new SubClassTester<X, B, typename is_polymorphic<B>::value> ())
{
set_module (module);
set_name (name);
set_base (&base);
}
Class (const std::string &name, const std::string &doc = std::string (), bool do_register = true)
Class (const std::string &module, const std::string &name, const std::string &doc = std::string (), bool do_register = true)
: ClassBase (doc, Methods (), do_register)
{
set_module (module);
set_name (name);
}
template <class B>
Class (const Class<B> &base, const std::string &name, const std::string &doc = std::string (), bool do_register = true)
Class (const Class<B> &base, const std::string &module, const std::string &name, const std::string &doc = std::string (), bool do_register = true)
: ClassBase (doc, Methods (), do_register), m_subclass_tester (new SubClassTester<X, B, typename is_polymorphic<B>::value> ())
{
set_module (module);
set_name (name);
set_base (&base);
}
@ -909,14 +914,14 @@ class SubClass
: public Class<X, Adapted>
{
public:
SubClass (const std::string &name, const Methods &mm, const std::string &doc = std::string ())
: Class<X, Adapted> (name, mm, doc)
SubClass (const std::string &module, const std::string &name, const Methods &mm, const std::string &doc = std::string ())
: Class<X, Adapted> (module, name, mm, doc)
{
// .. nothing yet ..
}
SubClass (const std::string &name, const std::string &doc = std::string ())
: Class<X, Adapted> (name, doc)
SubClass (const std::string &module, const std::string &name, const std::string &doc = std::string ())
: Class<X, Adapted> (module, name, doc)
{
// .. nothing yet ..
}
@ -941,14 +946,14 @@ class GSI_PUBLIC_TEMPLATE ChildClass
: public Class<X, Adapted>
{
public:
ChildClass (const std::string &name, const Methods &mm, const std::string &doc = std::string ())
: Class<X, Adapted> (name, mm, doc)
ChildClass (const std::string &module, const std::string &name, const Methods &mm, const std::string &doc = std::string ())
: Class<X, Adapted> (module, name, mm, doc)
{
// .. nothing yet ..
}
ChildClass (const std::string &name, const std::string &doc = std::string ())
: Class<X, Adapted> (name, doc)
ChildClass (const std::string &module, const std::string &name, const std::string &doc = std::string ())
: Class<X, Adapted> (module, name, doc)
{
// .. nothing yet ..
}
@ -974,14 +979,14 @@ class GSI_PUBLIC_TEMPLATE ChildSubClass
: public SubClass<X, B, Adapted>
{
public:
ChildSubClass (const std::string &name, const Methods &mm, const std::string &doc = std::string ())
: SubClass<X, B, Adapted> (name, mm, doc)
ChildSubClass (const std::string &module, const std::string &name, const Methods &mm, const std::string &doc = std::string ())
: SubClass<X, B, Adapted> (module, name, mm, doc)
{
// .. nothing yet ..
}
ChildSubClass (const std::string &name, const std::string &doc = std::string ())
: SubClass<X, B, Adapted> (name, doc)
ChildSubClass (const std::string &module, const std::string &name, const std::string &doc = std::string ())
: SubClass<X, B, Adapted> (module, name, doc)
{
// .. nothing yet ..
}

14
src/gsi/gsi/gsiClassBase.h
View File

@ -144,6 +144,14 @@ public:
return m_name;
}
/**
* @brief Gets the module name
*/
const std::string &module () const
{
return m_module;
}
/**
* @brief Gets the documentation string
*/
@ -559,6 +567,11 @@ protected:
m_name = n;
}
void set_module (const std::string &m)
{
m_module = m;
}
void set_parent (const ClassBase *parent);
void set_base (const ClassBase *base);
@ -568,6 +581,7 @@ private:
Methods m_methods;
std::vector<MethodBase *> m_callbacks, m_constructors;
std::string m_name;
std::string m_module;
tl::weak_collection<ClassBase> m_child_classes, m_subclasses;
mutable std::auto_ptr<PerClassClientSpecificData> mp_data[ClientIndex::MaxClientIndex];

32
src/gsi/gsi/gsiCommon.h
View File

@ -20,32 +20,22 @@
*/
#include "tlDefs.h"
#if !defined(HDR_gsiCommon_h)
# define HDR_gsiCommon_h
# if defined _WIN32 || defined __CYGWIN__
# ifdef MAKE_GSI_LIBRARY
# define GSI_PUBLIC __declspec(dllexport)
# else
# define GSI_PUBLIC __declspec(dllimport)
# endif
# define GSI_LOCAL
# define GSI_PUBLIC_TEMPLATE
// NOTE: this is required because we have some forward declarations to
// gsi::Class and gsi::ClassBase in tlVariant.h.
// TODO: there should not be any dependency of tl on gsi.
# ifdef MAKE_GSI_LIBRARY
# define GSI_PUBLIC DEF_INSIDE_PUBLIC
# define GSI_PUBLIC_TEMPLATE DEF_INSIDE_PUBLIC_TEMPLATE
# define GSI_LOCAL DEF_INSIDE_LOCAL
# else
# if __GNUC__ >= 4 || defined(__clang__)
# define GSI_PUBLIC __attribute__ ((visibility ("default")))
# define GSI_PUBLIC_TEMPLATE __attribute__ ((visibility ("default")))
# define GSI_LOCAL __attribute__ ((visibility ("hidden")))
# else
# define GSI_PUBLIC
# define GSI_PUBLIC_TEMPLATE
# define GSI_LOCAL
# endif
# define GSI_PUBLIC DEF_OUTSIDE_PUBLIC
# define GSI_PUBLIC_TEMPLATE DEF_OUTSIDE_PUBLIC_TEMPLATE
# define GSI_LOCAL DEF_OUTSIDE_LOCAL
# endif
#endif

2
src/gsi/gsi/gsiDeclBasic.cc
View File

@ -41,7 +41,7 @@ static gsi::Value *new_vv0 ()
return new gsi::Value ();
}
Class<Value> decl_Value ("Value",
Class<Value> decl_Value ("tl", "Value",
gsi::constructor ("new", &new_vv0,
"@brief Constructs a nil object.\n"
) +

8
src/gsi/gsi/gsiDeclInternal.cc
View File

@ -91,7 +91,7 @@ static tl::Variant default_value (const ArgType *t)
return t->spec () ? t->spec ()->default_value () : empty;
}
Class<ArgType> decl_ArgType ("ArgType",
Class<ArgType> decl_ArgType ("tl", "ArgType",
gsi::method ("TypeVoid|#t_void", &t_void) +
gsi::method ("TypeBool|#t_bool", &t_bool) +
gsi::method ("TypeChar|#t_char", &t_char) +
@ -201,7 +201,7 @@ static bool _syn_is_setter (const gsi::MethodBase::MethodSynonym *syn)
return syn->is_setter;
}
Class<MethodBase::MethodSynonym> decl_MethodOverload ("MethodOverload",
Class<MethodBase::MethodSynonym> decl_MethodOverload ("tl", "MethodOverload",
gsi::method_ext ("name", &_syn_name,
"@brief The name of this overload\n"
"This is the raw, unadorned name. I.e. no question mark suffix for predicates, no "
@ -222,7 +222,7 @@ Class<MethodBase::MethodSynonym> decl_MethodOverload ("MethodOverload",
"@hide"
);
Class<MethodBase> decl_Method ("Method",
Class<MethodBase> decl_Method ("tl", "Method",
gsi::iterator ("each_argument", &MethodBase::begin_arguments, &MethodBase::end_arguments,
"@brief Iterate over all arguments of this method\n"
) +
@ -291,7 +291,7 @@ Class<MethodBase> decl_Method ("Method",
"@hide"
);
Class<ClassBase> decl_Class ("Class",
Class<ClassBase> decl_Class ("tl", "Class",
gsi::iterator ("each_class", &ClassBase::begin_classes, &ClassBase::end_classes,
"@brief Iterate over all classes\n"
) +

12
src/gsi/gsi/gsiDeclTl.cc
View File

@ -87,7 +87,7 @@ namespace tl {
namespace gsi
{
Class<Logger> decl_Logger ("Logger",
Class<Logger> decl_Logger ("tl", "Logger",
gsi::method ("info", &Logger::info,
"@brief Writes the given string to the info channel\n"
"@args msg\n"
@ -155,7 +155,7 @@ static std::string timer_to_s (const tl::Timer *timer)
return tl::sprintf ("%.12gs (user), %.12gs (kernel)", timer->sec_user (), timer->sec_sys ());
}
Class<tl::Timer> decl_Timer ("Timer",
Class<tl::Timer> decl_Timer ("tl", "Timer",
gsi::method ("user", &tl::Timer::sec_user,
"@brief Returns the elapsed CPU time in user mode from start to stop in seconds\n"
) +
@ -217,7 +217,7 @@ namespace tl {
namespace gsi
{
Class<tl::Progress> decl_Progress ("Progress",
Class<tl::Progress> decl_Progress ("tl", "Progress",
gsi::method ("desc=", &tl::Progress::set_desc,
"@brief Sets the description text of the progress object\n"
"@args desc\n"
@ -263,7 +263,7 @@ static void rel_progress_set_2 (tl::RelativeProgress *progress, size_t value, bo
progress->set (value, force_yield);
}
Class<tl::RelativeProgress> decl_RelativeProgress (decl_Progress, "RelativeProgress",
Class<tl::RelativeProgress> decl_RelativeProgress (decl_Progress, "tl", "RelativeProgress",
gsi::constructor ("new", &rel_progress_2,
"@brief Creates a relative progress reporter with the given description and maximum value\n"
"@args desc, max_value\n"
@ -345,7 +345,7 @@ static void abs_progress_set_2 (tl::AbsoluteProgress *progress, size_t value, bo
progress->set (value, force_yield);
}
Class<tl::AbsoluteProgress> decl_AbsoluteProgress (decl_Progress, "AbsoluteProgress",
Class<tl::AbsoluteProgress> decl_AbsoluteProgress (decl_Progress, "tl", "AbsoluteProgress",
gsi::constructor ("new", &abs_progress_1,
"@brief Creates an absolute progress reporter with the given description\n"
"@args desc, max_value\n"
@ -518,7 +518,7 @@ namespace tl {
namespace gsi
{
Class<ExpressionWrapper> decl_ExpressionWrapper ("Expression",
Class<ExpressionWrapper> decl_ExpressionWrapper ("tl", "Expression",
gsi::constructor ("new", &new_expr1, gsi::arg ("expr"),
"@brief Creates an expression evaluator\n"
) +

8
src/gsi/gsi/gsiEnums.h
View File

@ -295,8 +295,8 @@ class Enum
: public Class<EnumAdaptor<E>, E>
{
public:
Enum (const std::string &name, const EnumSpecs<E> &specs, const std::string &doc = std::string ())
: Class<EnumAdaptor<E>, E> (name, specs.methods (), doc), m_specs (specs)
Enum (const std::string &module, const std::string &name, const EnumSpecs<E> &specs, const std::string &doc = std::string ())
: Class<EnumAdaptor<E>, E> (module, name, specs.methods (), doc), m_specs (specs)
{
}
@ -389,8 +389,8 @@ public:
typedef int int_repr;
#endif
QFlagsClass (const std::string &name, const std::string &doc = std::string ())
: Class<QFlagsAdaptor<E>, QFlags<E> > (name, methods (), doc),
QFlagsClass (const std::string &module, const std::string &name, const std::string &doc = std::string ())
: Class<QFlagsAdaptor<E>, QFlags<E> > (module, name, methods (), doc),
m_enum_ext (ext_methods ())
{
}

38
src/gsi/unit_tests/gsiTest.cc
View File

@ -757,7 +757,7 @@ static gsi::Enum<Enum> decl_enum ("Enum",
static gsi::QFlagsClass<Enum> decl_qflags_enum ("Enums");
static gsi::Class<A> decl_a ("A",
static gsi::Class<A> decl_a ("", A",
gsi::constructor ("new_a|new", &a_ctor) +
gsi::method ("br", &A::br) +
gsi::method ("get_e", &A::get_e) +
@ -859,9 +859,9 @@ static gsi::Class<A> decl_a ("A",
gsi::iterator ("a8", &A::a8b, &A::a8e)
);
static gsi::Class<A_NC> decl_a_nc (decl_a, "A_NC");
static gsi::Class<A_NC> decl_a_nc (decl_a, "", "A_NC");
static gsi::Class<B> decl_b ("B",
static gsi::Class<B> decl_b ("", "B",
gsi::method ("inst", &B::inst) +
gsi::method ("has_inst", &B::has_inst) +
gsi::method ("set_inst", &B::set_inst) +
@ -1028,7 +1028,7 @@ static gsi::ClassExt<B> b_ext (
);
static gsi::Class<C_P> decl_c ("C",
static gsi::Class<C_P> decl_c ("", "C",
gsi::callback ("f", &C_P::f, &C_P::f_cb) +
gsi::method ("g", &C_P::g) +
gsi::method ("s1", &C::s1) +
@ -1040,7 +1040,7 @@ static gsi::Class<C_P> decl_c ("C",
tl::event<E *> &ev1_ext (E *e) { return e->ev1; }
static gsi::Class<E> decl_e ("E",
static gsi::Class<E> decl_e ("", "E",
gsi::event ("e0", &E::ev0) +
gsi::event_ext ("e1", &ev1_ext) +
gsi::event ("e2", &E::ev2) +
@ -1062,7 +1062,7 @@ static gsi::Class<E> decl_e ("E",
gsi::method ("reset_inst", &E::reset_inst)
);
static gsi::Class<F> decl_f ("F",
static gsi::Class<F> decl_f ("", "F",
gsi::method ("ic", &F::ic) +
gsi::method ("inc", &F::inc) +
gsi::method ("icref", &F::icref) +
@ -1071,7 +1071,7 @@ static gsi::Class<F> decl_f ("F",
gsi::method ("x", &F::get_x)
);
static gsi::Class<G> decl_g ("G",
static gsi::Class<G> decl_g ("", "G",
gsi::method ("iv", &G::iv) +
gsi::method ("sv", &G::sv) +
gsi::method ("set_iva", &G::set_iv, gsi::arg ()) +
@ -1085,7 +1085,7 @@ static gsi::Class<G> decl_g ("G",
gsi::method ("set_vvc", &G::set_vv, gsi::arg ("", 1), gsi::arg ("", "value"))
);
static gsi::Class<X> decl_x ("X",
static gsi::Class<X> decl_x ("", "X",
gsi::constructor ("new", &make_x) +
gsi::method ("instances", &X::instances) +
gsi::method ("x1", &X::x1) +
@ -1102,7 +1102,7 @@ static gsi::Class<X> decl_x ("X",
gsi::method ("s=", &X::set_si)
);
static gsi::Class<Y> decl_y (decl_x, "Y",
static gsi::Class<Y> decl_y (decl_x, "", "Y",
gsi::constructor ("new", &make_y) +
gsi::method ("x1", &Y::x1) +
gsi::method ("y1", &Y::y1) +
@ -1121,19 +1121,19 @@ static gsi::Class<Y> decl_y (decl_x, "Y",
gsi::method ("vx_dyn", &Y::vx_dyn)
);
static gsi::SubClass<Y2, X> decl_y2 ("Y2",
static gsi::SubClass<Y2, X> decl_y2 ("", "Y2",
gsi::method ("x1", &Y2::x1)
);
static gsi::ChildSubClass<Z_P, Y3, X> decl_y3 ("Y3",
static gsi::ChildSubClass<Z_P, Y3, X> decl_y3 ("", "Y3",
gsi::method ("x1", &Y3::x1)
);
static gsi::ChildClass<Z_P, Y4> decl_y4 ("Y4",
static gsi::ChildClass<Z_P, Y4> decl_y4 ("", "Y4",
gsi::method ("x1", &Y4::x1)
);
gsi::Class<Z_P> decl_z ("Z",
gsi::Class<Z_P> decl_z ("", "Z",
gsi::method ("f", &Z_P::f_org) +
gsi::callback ("f", &Z_P::f, &Z_P::f_cb) +
gsi::method ("f_with_x", &Z_P::f_with_x) +
@ -1144,7 +1144,7 @@ gsi::Class<Z_P> decl_z ("Z",
gsi::method ("set_x_keep", &Z_P::set_x_keep)
);
gsi::Class<SQ> decl_sq ("SQ",
gsi::Class<SQ> decl_sq ("", "SQ",
gsi::method ("trigger_s0", &SQ::trigger_s0) +
gsi::method ("trigger_s1", &SQ::trigger_s1) +
gsi::method ("trigger_s2", &SQ::trigger_s2) +
@ -1155,7 +1155,7 @@ gsi::Class<SQ> decl_sq ("SQ",
gsi::qt_signal<const QString &, SQ *> ("s2(const QString &, SQ *)", "s2")
);
gsi::Class<SE> decl_se ("SE",
gsi::Class<SE> decl_se ("", "SE",
gsi::method ("trigger_s0", &SE::trigger_s0) +
gsi::method ("trigger_s1", &SE::trigger_s1) +
gsi::method ("trigger_s2", &SE::trigger_s2) +
@ -1222,12 +1222,12 @@ int g_virtual (GObject *go)
return go->g ();
}
static gsi::Class<GObject> decl_gobject_base ("GObjectBase",
static gsi::Class<GObject> decl_gobject_base ("", "GObjectBase",
gsi::method_ext ("g_virtual", &g_virtual) +
gsi::Methods()
);
static gsi::Class<GObject_P> decl_gobject (decl_gobject_base, "GObject",
static gsi::Class<GObject_P> decl_gobject (decl_gobject_base, "", "GObject",
gsi::method_ext ("g_org", &g_org) +
gsi::callback ("g", &GObject_P::g, &GObject_P::g_cb) +
gsi::method ("g_inst_count", &GObject::g_inst_count)
@ -1238,11 +1238,11 @@ GObject *f_org (GFactory_P *fo, int z)
return fo->GFactory::f (z);
}
static gsi::Class<GFactory> decl_gfactory_base ("GFactoryBase",
static gsi::Class<GFactory> decl_gfactory_base ("", "GFactoryBase",
gsi::factory ("create_f", &GFactory::create_f)
);
static gsi::Class<GFactory_P> decl_gfactory (decl_gfactory_base, "GFactory",
static gsi::Class<GFactory_P> decl_gfactory (decl_gfactory_base, "", "GFactory",
gsi::method_ext ("f", &f_org) +
gsi::factory_callback ("f", &GFactory_P::f, &GFactory_P::f_cb)
);

35
src/gsiqt/gsiqt.pro
View File

@ -1,35 +1,12 @@
DESTDIR = $$OUT_PWD/..
TARGET = klayout_gsiqt
include($$PWD/../lib.pri)
DEFINES += MAKE_GSIQT_LIBRARY
# NOTE: db is required since some bridges to db are provided (i.e db::Polygon)
INCLUDEPATH += $$TL_INC $$GSI_INC $$DB_INC $$GSIQT_INC
DEPENDPATH += $$TL_INC $$GSI_INC $$DB_INC $$GSIQT_INC
LIBS += -L$$DESTDIR -lklayout_tl -lklayout_gsi -lklayout_db
SOURCES += \
gsiQt.cc \
gsiDeclQtBasic.cc \
gsiDeclQt5Basic.cc \
gsiQtHelper.cc
HEADERS += \
gsiQt.h \
gsiQtCommon.h \
gsiQtHelper.h
TEMPLATE = subdirs
SUBDIRS = qtbasic
equals(HAVE_QT5, "1") {
include($$PWD/../gsiqt5/qtdecl.pri)
SUBDIRS += qt5
qt5.depends += qtbasic
} else {
include($$PWD/../gsiqt4/qtdecl.pri)
SUBDIRS += qt4
qt4.depends += qtbasic
}
gsiqt.depends += gsi
laybasic.depends += gsiqt
lay.depends += gsiqt

86
src/gsiqt/qt4/QtCore/QtCore.pri Normal file
View File

@ -0,0 +1,86 @@
#
# Partial QMAKE project file for Qt bindings
#
# DO NOT EDIT THIS FILE.
# This file has been created automatically
#
SOURCES += \
$$PWD/gsiDeclQAbstractItemModel.cc \
$$PWD/gsiDeclQAbstractListModel.cc \
$$PWD/gsiDeclQAbstractTableModel.cc \
$$PWD/gsiDeclQBasicTimer.cc \
$$PWD/gsiDeclQBuffer.cc \
$$PWD/gsiDeclQByteArrayMatcher.cc \
$$PWD/gsiDeclQChildEvent.cc \
$$PWD/gsiDeclQCoreApplication.cc \
$$PWD/gsiDeclQCryptographicHash.cc \
$$PWD/gsiDeclQDataStream.cc \
$$PWD/gsiDeclQDate.cc \
$$PWD/gsiDeclQDateTime.cc \
$$PWD/gsiDeclQDir.cc \
$$PWD/gsiDeclQDynamicPropertyChangeEvent.cc \
$$PWD/gsiDeclQEasingCurve.cc \
$$PWD/gsiDeclQEvent.cc \
$$PWD/gsiDeclQEventLoop.cc \
$$PWD/gsiDeclQFactoryInterface.cc \
$$PWD/gsiDeclQFile.cc \
$$PWD/gsiDeclQFileInfo.cc \
$$PWD/gsiDeclQFileSystemWatcher.cc \
$$PWD/gsiDeclQIODevice.cc \
$$PWD/gsiDeclQLibrary.cc \
$$PWD/gsiDeclQLibraryInfo.cc \
$$PWD/gsiDeclQLine.cc \
$$PWD/gsiDeclQLineF.cc \
$$PWD/gsiDeclQLocale.cc \
$$PWD/gsiDeclQMargins.cc \
$$PWD/gsiDeclQMetaClassInfo.cc \
$$PWD/gsiDeclQMetaEnum.cc \
$$PWD/gsiDeclQMetaMethod.cc \
$$PWD/gsiDeclQMetaObject.cc \
$$PWD/gsiDeclQMetaProperty.cc \
$$PWD/gsiDeclQMetaType.cc \
$$PWD/gsiDeclQMimeData.cc \
$$PWD/gsiDeclQModelIndex.cc \
$$PWD/gsiDeclQMutex.cc \
$$PWD/gsiDeclQObject.cc \
$$PWD/gsiDeclQPersistentModelIndex.cc \
$$PWD/gsiDeclQPluginLoader.cc \
$$PWD/gsiDeclQPoint.cc \
$$PWD/gsiDeclQPointF.cc \
$$PWD/gsiDeclQProcess.cc \
$$PWD/gsiDeclQProcessEnvironment.cc \
$$PWD/gsiDeclQReadLocker.cc \
$$PWD/gsiDeclQReadWriteLock.cc \
$$PWD/gsiDeclQRect.cc \
$$PWD/gsiDeclQRectF.cc \
$$PWD/gsiDeclQRegExp.cc \
$$PWD/gsiDeclQResource.cc \
$$PWD/gsiDeclQSemaphore.cc \
$$PWD/gsiDeclQSettings.cc \
$$PWD/gsiDeclQSignalMapper.cc \
$$PWD/gsiDeclQSize.cc \
$$PWD/gsiDeclQSizeF.cc \
$$PWD/gsiDeclQSocketNotifier.cc \
$$PWD/gsiDeclQStringMatcher.cc \
$$PWD/gsiDeclQSysInfo.cc \
$$PWD/gsiDeclQSystemLocale.cc \
$$PWD/gsiDeclQTemporaryFile.cc \
$$PWD/gsiDeclQTextCodec.cc \
$$PWD/gsiDeclQTextCodec_ConverterState.cc \
$$PWD/gsiDeclQTextDecoder.cc \
$$PWD/gsiDeclQTextEncoder.cc \
$$PWD/gsiDeclQTextStream.cc \
$$PWD/gsiDeclQThread.cc \
$$PWD/gsiDeclQTime.cc \
$$PWD/gsiDeclQTimeLine.cc \
$$PWD/gsiDeclQTimer.cc \
$$PWD/gsiDeclQTimerEvent.cc \
$$PWD/gsiDeclQTranslator.cc \
$$PWD/gsiDeclQUrl.cc \
$$PWD/gsiDeclQWaitCondition.cc \
$$PWD/gsiDeclQWriteLocker.cc \
$$PWD/gsiDeclQt.cc \
$$PWD/gsiDeclQt_1.cc \
$$PWD/gsiDeclQt_2.cc \
$$PWD/gsiDeclQt_3.cc

21
src/gsiqt/qt4/QtCore/QtCore.pro Normal file
View File

@ -0,0 +1,21 @@
DESTDIR = $$OUT_PWD/../../..
TARGET = klayout_QtCore
include($$PWD/../../../lib.pri)
DEFINES += MAKE_GSI_QTCORE_LIBRARY
# NOTE: db is required since some bridges to db are provided (i.e db::Polygon)
INCLUDEPATH += $$TL_INC $$GSI_INC $$DB_INC $$QTBASIC_INC
DEPENDPATH += $$TL_INC $$GSI_INC $$DB_INC $$QTBASIC_INC
LIBS += -L$$DESTDIR -lklayout_tl -lklayout_gsi -lklayout_qtbasic
SOURCES += \
HEADERS += \
include(QtCore.pri)

10
src/gsiqt4/gsiDeclQAbstractItemModel.cc → src/gsiqt/qt4/QtCore/gsiDeclQAbstractItemModel.cc
View File

@ -38,8 +38,8 @@
#include <QThread>
#include <QTimerEvent>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -1016,11 +1016,11 @@ static gsi::Methods methods_QAbstractItemModel () {
gsi::Class<QObject> &qtdecl_QObject ();
qt_gsi::QtNativeClass<QAbstractItemModel> decl_QAbstractItemModel (qtdecl_QObject (), "QAbstractItemModel_Native",
qt_gsi::QtNativeClass<QAbstractItemModel> decl_QAbstractItemModel (qtdecl_QObject (), "QtCore", "QAbstractItemModel_Native",
methods_QAbstractItemModel (),
"@hide\n@alias QAbstractItemModel");
GSIQT_PUBLIC gsi::Class<QAbstractItemModel> &qtdecl_QAbstractItemModel () { return decl_QAbstractItemModel; }
GSI_QTCORE_PUBLIC gsi::Class<QAbstractItemModel> &qtdecl_QAbstractItemModel () { return decl_QAbstractItemModel; }
}
@ -3363,7 +3363,7 @@ static gsi::Methods methods_QAbstractItemModel_Adaptor () {
return methods;
}
gsi::Class<QAbstractItemModel_Adaptor> decl_QAbstractItemModel_Adaptor (qtdecl_QAbstractItemModel (), "QAbstractItemModel",
gsi::Class<QAbstractItemModel_Adaptor> decl_QAbstractItemModel_Adaptor (qtdecl_QAbstractItemModel (), "QtCore", "QAbstractItemModel",
methods_QAbstractItemModel_Adaptor (),
"@qt\n@brief Binding of QAbstractItemModel");

10
src/gsiqt4/gsiDeclQAbstractListModel.cc → src/gsiqt/qt4/QtCore/gsiDeclQAbstractListModel.cc
View File

@ -38,8 +38,8 @@
#include <QThread>
#include <QTimerEvent>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -230,11 +230,11 @@ static gsi::Methods methods_QAbstractListModel () {
gsi::Class<QAbstractItemModel> &qtdecl_QAbstractItemModel ();
qt_gsi::QtNativeClass<QAbstractListModel> decl_QAbstractListModel (qtdecl_QAbstractItemModel (), "QAbstractListModel_Native",
qt_gsi::QtNativeClass<QAbstractListModel> decl_QAbstractListModel (qtdecl_QAbstractItemModel (), "QtCore", "QAbstractListModel_Native",
methods_QAbstractListModel (),
"@hide\n@alias QAbstractListModel");
GSIQT_PUBLIC gsi::Class<QAbstractListModel> &qtdecl_QAbstractListModel () { return decl_QAbstractListModel; }
GSI_QTCORE_PUBLIC gsi::Class<QAbstractListModel> &qtdecl_QAbstractListModel () { return decl_QAbstractListModel; }
}
@ -2449,7 +2449,7 @@ static gsi::Methods methods_QAbstractListModel_Adaptor () {
return methods;
}
gsi::Class<QAbstractListModel_Adaptor> decl_QAbstractListModel_Adaptor (qtdecl_QAbstractListModel (), "QAbstractListModel",
gsi::Class<QAbstractListModel_Adaptor> decl_QAbstractListModel_Adaptor (qtdecl_QAbstractListModel (), "QtCore", "QAbstractListModel",
methods_QAbstractListModel_Adaptor (),
"@qt\n@brief Binding of QAbstractListModel");

10
src/gsiqt4/gsiDeclQAbstractTableModel.cc → src/gsiqt/qt4/QtCore/gsiDeclQAbstractTableModel.cc
View File

@ -38,8 +38,8 @@
#include <QThread>
#include <QTimerEvent>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -230,11 +230,11 @@ static gsi::Methods methods_QAbstractTableModel () {
gsi::Class<QAbstractItemModel> &qtdecl_QAbstractItemModel ();
qt_gsi::QtNativeClass<QAbstractTableModel> decl_QAbstractTableModel (qtdecl_QAbstractItemModel (), "QAbstractTableModel_Native",
qt_gsi::QtNativeClass<QAbstractTableModel> decl_QAbstractTableModel (qtdecl_QAbstractItemModel (), "QtCore", "QAbstractTableModel_Native",
methods_QAbstractTableModel (),
"@hide\n@alias QAbstractTableModel");
GSIQT_PUBLIC gsi::Class<QAbstractTableModel> &qtdecl_QAbstractTableModel () { return decl_QAbstractTableModel; }
GSI_QTCORE_PUBLIC gsi::Class<QAbstractTableModel> &qtdecl_QAbstractTableModel () { return decl_QAbstractTableModel; }
}
@ -2491,7 +2491,7 @@ static gsi::Methods methods_QAbstractTableModel_Adaptor () {
return methods;
}
gsi::Class<QAbstractTableModel_Adaptor> decl_QAbstractTableModel_Adaptor (qtdecl_QAbstractTableModel (), "QAbstractTableModel",
gsi::Class<QAbstractTableModel_Adaptor> decl_QAbstractTableModel_Adaptor (qtdecl_QAbstractTableModel (), "QtCore", "QAbstractTableModel",
methods_QAbstractTableModel_Adaptor (),
"@qt\n@brief Binding of QAbstractTableModel");

8
src/gsiqt4/gsiDeclQBasicTimer.cc → src/gsiqt/qt4/QtCore/gsiDeclQBasicTimer.cc
View File

@ -30,8 +30,8 @@
#include <QBasicTimer>
#include <QObject>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -135,12 +135,12 @@ static gsi::Methods methods_QBasicTimer () {
return methods;
}
gsi::Class<QBasicTimer> decl_QBasicTimer ("QBasicTimer",
gsi::Class<QBasicTimer> decl_QBasicTimer ("QtCore", "QBasicTimer",
methods_QBasicTimer (),
"@qt\n@brief Binding of QBasicTimer");
GSIQT_PUBLIC gsi::Class<QBasicTimer> &qtdecl_QBasicTimer () { return decl_QBasicTimer; }
GSI_QTCORE_PUBLIC gsi::Class<QBasicTimer> &qtdecl_QBasicTimer () { return decl_QBasicTimer; }
}

8
src/gsiqt4/gsiDeclQBuffer.cc → src/gsiqt/qt4/QtCore/gsiDeclQBuffer.cc
View File

@ -34,8 +34,8 @@
#include <QThread>
#include <QTimerEvent>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -447,12 +447,12 @@ static gsi::Methods methods_QBuffer () {
gsi::Class<QIODevice> &qtdecl_QIODevice ();
qt_gsi::QtNativeClass<QBuffer> decl_QBuffer (qtdecl_QIODevice (), "QBuffer",
qt_gsi::QtNativeClass<QBuffer> decl_QBuffer (qtdecl_QIODevice (), "QtCore", "QBuffer",
methods_QBuffer (),
"@qt\n@brief Binding of QBuffer");
GSIQT_PUBLIC gsi::Class<QBuffer> &qtdecl_QBuffer () { return decl_QBuffer; }
GSI_QTCORE_PUBLIC gsi::Class<QBuffer> &qtdecl_QBuffer () { return decl_QBuffer; }
}

8
src/gsiqt4/gsiDeclQByteArrayMatcher.cc → src/gsiqt/qt4/QtCore/gsiDeclQByteArrayMatcher.cc
View File

@ -29,8 +29,8 @@
#include <QByteArrayMatcher>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -207,12 +207,12 @@ static gsi::Methods methods_QByteArrayMatcher () {
return methods;
}
gsi::Class<QByteArrayMatcher> decl_QByteArrayMatcher ("QByteArrayMatcher",
gsi::Class<QByteArrayMatcher> decl_QByteArrayMatcher ("QtCore", "QByteArrayMatcher",
methods_QByteArrayMatcher (),
"@qt\n@brief Binding of QByteArrayMatcher");
GSIQT_PUBLIC gsi::Class<QByteArrayMatcher> &qtdecl_QByteArrayMatcher () { return decl_QByteArrayMatcher; }
GSI_QTCORE_PUBLIC gsi::Class<QByteArrayMatcher> &qtdecl_QByteArrayMatcher () { return decl_QByteArrayMatcher; }
}

12
src/gsiqt4/gsiDeclQChildEvent.cc → src/gsiqt/qt4/QtCore/gsiDeclQChildEvent.cc
View File

@ -30,8 +30,8 @@
#include <QChildEvent>
#include <QObject>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -51,7 +51,7 @@
{
public:
RawQObjectClass ()
: gsi::Class<QObject> (gsi::qtdecl_QObject (), "QObject_Raw", gsi::Methods (), "@hide")
: gsi::Class<QObject> (gsi::qtdecl_QObject (), "Qt", "QObject_Raw", gsi::Methods (), "@hide")
{
}
@ -138,7 +138,7 @@ static gsi::Methods methods_QChildEvent () {
gsi::Class<QEvent> &qtdecl_QEvent ();
gsi::Class<QChildEvent> decl_QChildEvent (qtdecl_QEvent (), "QChildEvent_Native",
gsi::Class<QChildEvent> decl_QChildEvent (qtdecl_QEvent (), "QtCore", "QChildEvent_Native",
gsi::Methods(new qt_gsi::GenericMethod ("child",
"@brief Method QObject *QChildEvent::child()\n"
"NOTE: the object returned by this method is not memory managed. It may be destroyed internally without notice. \n"
@ -150,7 +150,7 @@ gsi::Class<QChildEvent> decl_QChildEvent (qtdecl_QEvent (), "QChildEvent_Native"
methods_QChildEvent (),
"@hide\n@alias QChildEvent");
GSIQT_PUBLIC gsi::Class<QChildEvent> &qtdecl_QChildEvent () { return decl_QChildEvent; }
GSI_QTCORE_PUBLIC gsi::Class<QChildEvent> &qtdecl_QChildEvent () { return decl_QChildEvent; }
}
@ -204,7 +204,7 @@ static gsi::Methods methods_QChildEvent_Adaptor () {
return methods;
}
gsi::Class<QChildEvent_Adaptor> decl_QChildEvent_Adaptor (qtdecl_QChildEvent (), "QChildEvent",
gsi::Class<QChildEvent_Adaptor> decl_QChildEvent_Adaptor (qtdecl_QChildEvent (), "QtCore", "QChildEvent",
methods_QChildEvent_Adaptor (),
"@qt\n@brief Binding of QChildEvent");

18
src/gsiqt4/gsiDeclQCoreApplication.cc → src/gsiqt/qt4/QtCore/gsiDeclQCoreApplication.cc
View File

@ -35,8 +35,8 @@
#include <QTimerEvent>
#include <QTranslator>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -993,11 +993,11 @@ static gsi::Methods methods_QCoreApplication () {
gsi::Class<QObject> &qtdecl_QObject ();
qt_gsi::QtNativeClass<QCoreApplication> decl_QCoreApplication (qtdecl_QObject (), "QCoreApplication_Native",
qt_gsi::QtNativeClass<QCoreApplication> decl_QCoreApplication (qtdecl_QObject (), "QtCore", "QCoreApplication_Native",
methods_QCoreApplication (),
"@hide\n@alias QCoreApplication");
GSIQT_PUBLIC gsi::Class<QCoreApplication> &qtdecl_QCoreApplication () { return decl_QCoreApplication; }
GSI_QTCORE_PUBLIC gsi::Class<QCoreApplication> &qtdecl_QCoreApplication () { return decl_QCoreApplication; }
}
@ -1434,7 +1434,7 @@ static gsi::Methods methods_QCoreApplication_Adaptor () {
return methods;
}
gsi::Class<QCoreApplication_Adaptor> decl_QCoreApplication_Adaptor (qtdecl_QCoreApplication (), "QCoreApplication",
gsi::Class<QCoreApplication_Adaptor> decl_QCoreApplication_Adaptor (qtdecl_QCoreApplication (), "QtCore", "QCoreApplication",
methods_QCoreApplication_Adaptor (),
"@qt\n@brief Binding of QCoreApplication");
@ -1445,19 +1445,19 @@ gsi::Class<QCoreApplication_Adaptor> decl_QCoreApplication_Adaptor (qtdecl_QCore
namespace qt_gsi
{
static gsi::Enum<QCoreApplication::Encoding> decl_QCoreApplication_Encoding_Enum ("QCoreApplication_Encoding",
static gsi::Enum<QCoreApplication::Encoding> decl_QCoreApplication_Encoding_Enum ("QtCore", "QCoreApplication_Encoding",
gsi::enum_const ("CodecForTr", QCoreApplication::CodecForTr, "@brief Enum constant QCoreApplication::CodecForTr") +
gsi::enum_const ("UnicodeUTF8", QCoreApplication::UnicodeUTF8, "@brief Enum constant QCoreApplication::UnicodeUTF8") +
gsi::enum_const ("DefaultCodec", QCoreApplication::DefaultCodec, "@brief Enum constant QCoreApplication::DefaultCodec"),
"@qt\n@brief This class represents the QCoreApplication::Encoding enum");
static gsi::QFlagsClass<QCoreApplication::Encoding > decl_QCoreApplication_Encoding_Enums ("QCoreApplication_QFlags_Encoding",
static gsi::QFlagsClass<QCoreApplication::Encoding > decl_QCoreApplication_Encoding_Enums ("QtCore", "QCoreApplication_QFlags_Encoding",
"@qt\n@brief This class represents the QFlags<QCoreApplication::Encoding> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QCoreApplication> inject_QCoreApplication_Encoding_Enum_in_parent (decl_QCoreApplication_Encoding_Enum.defs ());
static gsi::ClassExt<QCoreApplication> decl_QCoreApplication_Encoding_Enum_as_child (decl_QCoreApplication_Encoding_Enum, "Encoding");
static gsi::ClassExt<QCoreApplication> decl_QCoreApplication_Encoding_Enums_as_child (decl_QCoreApplication_Encoding_Enums, "QFlags_Encoding");
static gsi::ClassExt<QCoreApplication> decl_QCoreApplication_Encoding_Enum_as_child (decl_QCoreApplication_Encoding_Enum, "QtCore", "Encoding");
static gsi::ClassExt<QCoreApplication> decl_QCoreApplication_Encoding_Enums_as_child (decl_QCoreApplication_Encoding_Enums, "QtCore", "QFlags_Encoding");
}

16
src/gsiqt4/gsiDeclQCryptographicHash.cc → src/gsiqt/qt4/QtCore/gsiDeclQCryptographicHash.cc
View File

@ -29,8 +29,8 @@
#include <QCryptographicHash>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -166,12 +166,12 @@ static gsi::Methods methods_QCryptographicHash () {
return methods;
}
gsi::Class<QCryptographicHash> decl_QCryptographicHash ("QCryptographicHash",
gsi::Class<QCryptographicHash> decl_QCryptographicHash ("QtCore", "QCryptographicHash",
methods_QCryptographicHash (),
"@qt\n@brief Binding of QCryptographicHash");
GSIQT_PUBLIC gsi::Class<QCryptographicHash> &qtdecl_QCryptographicHash () { return decl_QCryptographicHash; }
GSI_QTCORE_PUBLIC gsi::Class<QCryptographicHash> &qtdecl_QCryptographicHash () { return decl_QCryptographicHash; }
}
@ -180,19 +180,19 @@ GSIQT_PUBLIC gsi::Class<QCryptographicHash> &qtdecl_QCryptographicHash () { retu
namespace qt_gsi
{
static gsi::Enum<QCryptographicHash::Algorithm> decl_QCryptographicHash_Algorithm_Enum ("QCryptographicHash_Algorithm",
static gsi::Enum<QCryptographicHash::Algorithm> decl_QCryptographicHash_Algorithm_Enum ("QtCore", "QCryptographicHash_Algorithm",
gsi::enum_const ("Md4", QCryptographicHash::Md4, "@brief Enum constant QCryptographicHash::Md4") +
gsi::enum_const ("Md5", QCryptographicHash::Md5, "@brief Enum constant QCryptographicHash::Md5") +
gsi::enum_const ("Sha1", QCryptographicHash::Sha1, "@brief Enum constant QCryptographicHash::Sha1"),
"@qt\n@brief This class represents the QCryptographicHash::Algorithm enum");
static gsi::QFlagsClass<QCryptographicHash::Algorithm > decl_QCryptographicHash_Algorithm_Enums ("QCryptographicHash_QFlags_Algorithm",
static gsi::QFlagsClass<QCryptographicHash::Algorithm > decl_QCryptographicHash_Algorithm_Enums ("QtCore", "QCryptographicHash_QFlags_Algorithm",
"@qt\n@brief This class represents the QFlags<QCryptographicHash::Algorithm> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QCryptographicHash> inject_QCryptographicHash_Algorithm_Enum_in_parent (decl_QCryptographicHash_Algorithm_Enum.defs ());
static gsi::ClassExt<QCryptographicHash> decl_QCryptographicHash_Algorithm_Enum_as_child (decl_QCryptographicHash_Algorithm_Enum, "Algorithm");
static gsi::ClassExt<QCryptographicHash> decl_QCryptographicHash_Algorithm_Enums_as_child (decl_QCryptographicHash_Algorithm_Enums, "QFlags_Algorithm");
static gsi::ClassExt<QCryptographicHash> decl_QCryptographicHash_Algorithm_Enum_as_child (decl_QCryptographicHash_Algorithm_Enum, "QtCore", "Algorithm");
static gsi::ClassExt<QCryptographicHash> decl_QCryptographicHash_Algorithm_Enums_as_child (decl_QCryptographicHash_Algorithm_Enums, "QtCore", "QFlags_Algorithm");
}

34
src/gsiqt4/gsiDeclQDataStream.cc → src/gsiqt/qt4/QtCore/gsiDeclQDataStream.cc
View File

@ -30,8 +30,8 @@
#include <QDataStream>
#include <QIODevice>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -554,7 +554,7 @@ static gsi::Methods methods_QDataStream () {
return methods;
}
gsi::Class<QDataStream> decl_QDataStream ("QDataStream_Native",
gsi::Class<QDataStream> decl_QDataStream ("QtCore", "QDataStream_Native",
gsi::method_ext("read_i8", &f_QDataStream_read_qint8, "@brief Non-ambiguous adaptation of the corresponding operator>>") +
gsi::method_ext("read_ui8", &f_QDataStream_read_quint8, "@brief Non-ambiguous adaptation of the corresponding operator>>") +
gsi::method_ext("read_i16", &f_QDataStream_read_qint16, "@brief Non-ambiguous adaptation of the corresponding operator>>") +
@ -591,7 +591,7 @@ gsi::Class<QDataStream> decl_QDataStream ("QDataStream_Native",
methods_QDataStream (),
"@hide\n@alias QDataStream");
GSIQT_PUBLIC gsi::Class<QDataStream> &qtdecl_QDataStream () { return decl_QDataStream; }
GSI_QTCORE_PUBLIC gsi::Class<QDataStream> &qtdecl_QDataStream () { return decl_QDataStream; }
}
@ -716,7 +716,7 @@ static gsi::Methods methods_QDataStream_Adaptor () {
return methods;
}
gsi::Class<QDataStream_Adaptor> decl_QDataStream_Adaptor (qtdecl_QDataStream (), "QDataStream",
gsi::Class<QDataStream_Adaptor> decl_QDataStream_Adaptor (qtdecl_QDataStream (), "QtCore", "QDataStream",
methods_QDataStream_Adaptor (),
"@qt\n@brief Binding of QDataStream");
@ -727,18 +727,18 @@ gsi::Class<QDataStream_Adaptor> decl_QDataStream_Adaptor (qtdecl_QDataStream (),
namespace qt_gsi
{
static gsi::Enum<QDataStream::ByteOrder> decl_QDataStream_ByteOrder_Enum ("QDataStream_ByteOrder",
static gsi::Enum<QDataStream::ByteOrder> decl_QDataStream_ByteOrder_Enum ("QtCore", "QDataStream_ByteOrder",
gsi::enum_const ("BigEndian", QDataStream::BigEndian, "@brief Enum constant QDataStream::BigEndian") +
gsi::enum_const ("LittleEndian", QDataStream::LittleEndian, "@brief Enum constant QDataStream::LittleEndian"),
"@qt\n@brief This class represents the QDataStream::ByteOrder enum");
static gsi::QFlagsClass<QDataStream::ByteOrder > decl_QDataStream_ByteOrder_Enums ("QDataStream_QFlags_ByteOrder",
static gsi::QFlagsClass<QDataStream::ByteOrder > decl_QDataStream_ByteOrder_Enums ("QtCore", "QDataStream_QFlags_ByteOrder",
"@qt\n@brief This class represents the QFlags<QDataStream::ByteOrder> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QDataStream> inject_QDataStream_ByteOrder_Enum_in_parent (decl_QDataStream_ByteOrder_Enum.defs ());
static gsi::ClassExt<QDataStream> decl_QDataStream_ByteOrder_Enum_as_child (decl_QDataStream_ByteOrder_Enum, "ByteOrder");
static gsi::ClassExt<QDataStream> decl_QDataStream_ByteOrder_Enums_as_child (decl_QDataStream_ByteOrder_Enums, "QFlags_ByteOrder");
static gsi::ClassExt<QDataStream> decl_QDataStream_ByteOrder_Enum_as_child (decl_QDataStream_ByteOrder_Enum, "QtCore", "ByteOrder");
static gsi::ClassExt<QDataStream> decl_QDataStream_ByteOrder_Enums_as_child (decl_QDataStream_ByteOrder_Enums, "QtCore", "QFlags_ByteOrder");
}
@ -747,18 +747,18 @@ static gsi::ClassExt<QDataStream> decl_QDataStream_ByteOrder_Enums_as_child (dec
namespace qt_gsi
{
static gsi::Enum<QDataStream::FloatingPointPrecision> decl_QDataStream_FloatingPointPrecision_Enum ("QDataStream_FloatingPointPrecision",
static gsi::Enum<QDataStream::FloatingPointPrecision> decl_QDataStream_FloatingPointPrecision_Enum ("QtCore", "QDataStream_FloatingPointPrecision",
gsi::enum_const ("SinglePrecision", QDataStream::SinglePrecision, "@brief Enum constant QDataStream::SinglePrecision") +
gsi::enum_const ("DoublePrecision", QDataStream::DoublePrecision, "@brief Enum constant QDataStream::DoublePrecision"),
"@qt\n@brief This class represents the QDataStream::FloatingPointPrecision enum");
static gsi::QFlagsClass<QDataStream::FloatingPointPrecision > decl_QDataStream_FloatingPointPrecision_Enums ("QDataStream_QFlags_FloatingPointPrecision",
static gsi::QFlagsClass<QDataStream::FloatingPointPrecision > decl_QDataStream_FloatingPointPrecision_Enums ("QtCore", "QDataStream_QFlags_FloatingPointPrecision",
"@qt\n@brief This class represents the QFlags<QDataStream::FloatingPointPrecision> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QDataStream> inject_QDataStream_FloatingPointPrecision_Enum_in_parent (decl_QDataStream_FloatingPointPrecision_Enum.defs ());
static gsi::ClassExt<QDataStream> decl_QDataStream_FloatingPointPrecision_Enum_as_child (decl_QDataStream_FloatingPointPrecision_Enum, "FloatingPointPrecision");
static gsi::ClassExt<QDataStream> decl_QDataStream_FloatingPointPrecision_Enums_as_child (decl_QDataStream_FloatingPointPrecision_Enums, "QFlags_FloatingPointPrecision");
static gsi::ClassExt<QDataStream> decl_QDataStream_FloatingPointPrecision_Enum_as_child (decl_QDataStream_FloatingPointPrecision_Enum, "QtCore", "FloatingPointPrecision");
static gsi::ClassExt<QDataStream> decl_QDataStream_FloatingPointPrecision_Enums_as_child (decl_QDataStream_FloatingPointPrecision_Enums, "QtCore", "QFlags_FloatingPointPrecision");
}
@ -767,19 +767,19 @@ static gsi::ClassExt<QDataStream> decl_QDataStream_FloatingPointPrecision_Enums_
namespace qt_gsi
{
static gsi::Enum<QDataStream::Status> decl_QDataStream_Status_Enum ("QDataStream_Status",
static gsi::Enum<QDataStream::Status> decl_QDataStream_Status_Enum ("QtCore", "QDataStream_Status",
gsi::enum_const ("Ok", QDataStream::Ok, "@brief Enum constant QDataStream::Ok") +
gsi::enum_const ("ReadPastEnd", QDataStream::ReadPastEnd, "@brief Enum constant QDataStream::ReadPastEnd") +
gsi::enum_const ("ReadCorruptData", QDataStream::ReadCorruptData, "@brief Enum constant QDataStream::ReadCorruptData"),
"@qt\n@brief This class represents the QDataStream::Status enum");
static gsi::QFlagsClass<QDataStream::Status > decl_QDataStream_Status_Enums ("QDataStream_QFlags_Status",
static gsi::QFlagsClass<QDataStream::Status > decl_QDataStream_Status_Enums ("QtCore", "QDataStream_QFlags_Status",
"@qt\n@brief This class represents the QFlags<QDataStream::Status> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QDataStream> inject_QDataStream_Status_Enum_in_parent (decl_QDataStream_Status_Enum.defs ());
static gsi::ClassExt<QDataStream> decl_QDataStream_Status_Enum_as_child (decl_QDataStream_Status_Enum, "Status");
static gsi::ClassExt<QDataStream> decl_QDataStream_Status_Enums_as_child (decl_QDataStream_Status_Enums, "QFlags_Status");
static gsi::ClassExt<QDataStream> decl_QDataStream_Status_Enum_as_child (decl_QDataStream_Status_Enum, "QtCore", "Status");
static gsi::ClassExt<QDataStream> decl_QDataStream_Status_Enums_as_child (decl_QDataStream_Status_Enums, "QtCore", "QFlags_Status");
}

16
src/gsiqt4/gsiDeclQDate.cc → src/gsiqt/qt4/QtCore/gsiDeclQDate.cc
View File

@ -29,8 +29,8 @@
#include <QDate>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -942,12 +942,12 @@ static gsi::Methods methods_QDate () {
return methods;
}
gsi::Class<QDate> decl_QDate ("QDate",
gsi::Class<QDate> decl_QDate ("QtCore", "QDate",
methods_QDate (),
"@qt\n@brief Binding of QDate");
GSIQT_PUBLIC gsi::Class<QDate> &qtdecl_QDate () { return decl_QDate; }
GSI_QTCORE_PUBLIC gsi::Class<QDate> &qtdecl_QDate () { return decl_QDate; }
}
@ -956,18 +956,18 @@ GSIQT_PUBLIC gsi::Class<QDate> &qtdecl_QDate () { return decl_QDate; }
namespace qt_gsi
{
static gsi::Enum<QDate::MonthNameType> decl_QDate_MonthNameType_Enum ("QDate_MonthNameType",
static gsi::Enum<QDate::MonthNameType> decl_QDate_MonthNameType_Enum ("QtCore", "QDate_MonthNameType",
gsi::enum_const ("DateFormat", QDate::DateFormat, "@brief Enum constant QDate::DateFormat") +
gsi::enum_const ("StandaloneFormat", QDate::StandaloneFormat, "@brief Enum constant QDate::StandaloneFormat"),
"@qt\n@brief This class represents the QDate::MonthNameType enum");
static gsi::QFlagsClass<QDate::MonthNameType > decl_QDate_MonthNameType_Enums ("QDate_QFlags_MonthNameType",
static gsi::QFlagsClass<QDate::MonthNameType > decl_QDate_MonthNameType_Enums ("QtCore", "QDate_QFlags_MonthNameType",
"@qt\n@brief This class represents the QFlags<QDate::MonthNameType> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QDate> inject_QDate_MonthNameType_Enum_in_parent (decl_QDate_MonthNameType_Enum.defs ());
static gsi::ClassExt<QDate> decl_QDate_MonthNameType_Enum_as_child (decl_QDate_MonthNameType_Enum, "MonthNameType");
static gsi::ClassExt<QDate> decl_QDate_MonthNameType_Enums_as_child (decl_QDate_MonthNameType_Enums, "QFlags_MonthNameType");
static gsi::ClassExt<QDate> decl_QDate_MonthNameType_Enum_as_child (decl_QDate_MonthNameType_Enum, "QtCore", "MonthNameType");
static gsi::ClassExt<QDate> decl_QDate_MonthNameType_Enums_as_child (decl_QDate_MonthNameType_Enums, "QtCore", "QFlags_MonthNameType");
}

8
src/gsiqt4/gsiDeclQDateTime.cc → src/gsiqt/qt4/QtCore/gsiDeclQDateTime.cc
View File

@ -31,8 +31,8 @@
#include <QDate>
#include <QTime>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -800,12 +800,12 @@ static gsi::Methods methods_QDateTime () {
return methods;
}
gsi::Class<QDateTime> decl_QDateTime ("QDateTime",
gsi::Class<QDateTime> decl_QDateTime ("QtCore", "QDateTime",
methods_QDateTime (),
"@qt\n@brief Binding of QDateTime");
GSIQT_PUBLIC gsi::Class<QDateTime> &qtdecl_QDateTime () { return decl_QDateTime; }
GSI_QTCORE_PUBLIC gsi::Class<QDateTime> &qtdecl_QDateTime () { return decl_QDateTime; }
}

24
src/gsiqt4/gsiDeclQDir.cc → src/gsiqt/qt4/QtCore/gsiDeclQDir.cc
View File

@ -30,8 +30,8 @@
#include <QDir>
#include <QFileInfo>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -1332,12 +1332,12 @@ static gsi::Methods methods_QDir () {
return methods;
}
gsi::Class<QDir> decl_QDir ("QDir",
gsi::Class<QDir> decl_QDir ("QtCore", "QDir",
methods_QDir (),
"@qt\n@brief Binding of QDir");
GSIQT_PUBLIC gsi::Class<QDir> &qtdecl_QDir () { return decl_QDir; }
GSI_QTCORE_PUBLIC gsi::Class<QDir> &qtdecl_QDir () { return decl_QDir; }
}
@ -1346,7 +1346,7 @@ GSIQT_PUBLIC gsi::Class<QDir> &qtdecl_QDir () { return decl_QDir; }
namespace qt_gsi
{
static gsi::Enum<QDir::Filter> decl_QDir_Filter_Enum ("QDir_Filter",
static gsi::Enum<QDir::Filter> decl_QDir_Filter_Enum ("QtCore", "QDir_Filter",
gsi::enum_const ("Dirs", QDir::Dirs, "@brief Enum constant QDir::Dirs") +
gsi::enum_const ("Files", QDir::Files, "@brief Enum constant QDir::Files") +
gsi::enum_const ("Drives", QDir::Drives, "@brief Enum constant QDir::Drives") +
@ -1367,13 +1367,13 @@ static gsi::Enum<QDir::Filter> decl_QDir_Filter_Enum ("QDir_Filter",
gsi::enum_const ("NoFilter", QDir::NoFilter, "@brief Enum constant QDir::NoFilter"),
"@qt\n@brief This class represents the QDir::Filter enum");
static gsi::QFlagsClass<QDir::Filter > decl_QDir_Filter_Enums ("QDir_QFlags_Filter",
static gsi::QFlagsClass<QDir::Filter > decl_QDir_Filter_Enums ("QtCore", "QDir_QFlags_Filter",
"@qt\n@brief This class represents the QFlags<QDir::Filter> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QDir> inject_QDir_Filter_Enum_in_parent (decl_QDir_Filter_Enum.defs ());
static gsi::ClassExt<QDir> decl_QDir_Filter_Enum_as_child (decl_QDir_Filter_Enum, "Filter");
static gsi::ClassExt<QDir> decl_QDir_Filter_Enums_as_child (decl_QDir_Filter_Enums, "QFlags_Filter");
static gsi::ClassExt<QDir> decl_QDir_Filter_Enum_as_child (decl_QDir_Filter_Enum, "QtCore", "Filter");
static gsi::ClassExt<QDir> decl_QDir_Filter_Enums_as_child (decl_QDir_Filter_Enums, "QtCore", "QFlags_Filter");
}
@ -1382,7 +1382,7 @@ static gsi::ClassExt<QDir> decl_QDir_Filter_Enums_as_child (decl_QDir_Filter_Enu
namespace qt_gsi
{
static gsi::Enum<QDir::SortFlag> decl_QDir_SortFlag_Enum ("QDir_SortFlag",
static gsi::Enum<QDir::SortFlag> decl_QDir_SortFlag_Enum ("QtCore", "QDir_SortFlag",
gsi::enum_const ("Name", QDir::Name, "@brief Enum constant QDir::Name") +
gsi::enum_const ("Time", QDir::Time, "@brief Enum constant QDir::Time") +
gsi::enum_const ("Size", QDir::Size, "@brief Enum constant QDir::Size") +
@ -1397,13 +1397,13 @@ static gsi::Enum<QDir::SortFlag> decl_QDir_SortFlag_Enum ("QDir_SortFlag",
gsi::enum_const ("NoSort", QDir::NoSort, "@brief Enum constant QDir::NoSort"),
"@qt\n@brief This class represents the QDir::SortFlag enum");
static gsi::QFlagsClass<QDir::SortFlag > decl_QDir_SortFlag_Enums ("QDir_QFlags_SortFlag",
static gsi::QFlagsClass<QDir::SortFlag > decl_QDir_SortFlag_Enums ("QtCore", "QDir_QFlags_SortFlag",
"@qt\n@brief This class represents the QFlags<QDir::SortFlag> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QDir> inject_QDir_SortFlag_Enum_in_parent (decl_QDir_SortFlag_Enum.defs ());
static gsi::ClassExt<QDir> decl_QDir_SortFlag_Enum_as_child (decl_QDir_SortFlag_Enum, "SortFlag");
static gsi::ClassExt<QDir> decl_QDir_SortFlag_Enums_as_child (decl_QDir_SortFlag_Enums, "QFlags_SortFlag");
static gsi::ClassExt<QDir> decl_QDir_SortFlag_Enum_as_child (decl_QDir_SortFlag_Enum, "QtCore", "SortFlag");
static gsi::ClassExt<QDir> decl_QDir_SortFlag_Enums_as_child (decl_QDir_SortFlag_Enums, "QtCore", "QFlags_SortFlag");
}

10
src/gsiqt4/gsiDeclQDynamicPropertyChangeEvent.cc → src/gsiqt/qt4/QtCore/gsiDeclQDynamicPropertyChangeEvent.cc
View File

@ -29,8 +29,8 @@
#include <QDynamicPropertyChangeEvent>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -62,11 +62,11 @@ static gsi::Methods methods_QDynamicPropertyChangeEvent () {
gsi::Class<QEvent> &qtdecl_QEvent ();
gsi::Class<QDynamicPropertyChangeEvent> decl_QDynamicPropertyChangeEvent (qtdecl_QEvent (), "QDynamicPropertyChangeEvent_Native",
gsi::Class<QDynamicPropertyChangeEvent> decl_QDynamicPropertyChangeEvent (qtdecl_QEvent (), "QtCore", "QDynamicPropertyChangeEvent_Native",
methods_QDynamicPropertyChangeEvent (),
"@hide\n@alias QDynamicPropertyChangeEvent");
GSIQT_PUBLIC gsi::Class<QDynamicPropertyChangeEvent> &qtdecl_QDynamicPropertyChangeEvent () { return decl_QDynamicPropertyChangeEvent; }
GSI_QTCORE_PUBLIC gsi::Class<QDynamicPropertyChangeEvent> &qtdecl_QDynamicPropertyChangeEvent () { return decl_QDynamicPropertyChangeEvent; }
}
@ -117,7 +117,7 @@ static gsi::Methods methods_QDynamicPropertyChangeEvent_Adaptor () {
return methods;
}
gsi::Class<QDynamicPropertyChangeEvent_Adaptor> decl_QDynamicPropertyChangeEvent_Adaptor (qtdecl_QDynamicPropertyChangeEvent (), "QDynamicPropertyChangeEvent",
gsi::Class<QDynamicPropertyChangeEvent_Adaptor> decl_QDynamicPropertyChangeEvent_Adaptor (qtdecl_QDynamicPropertyChangeEvent (), "QtCore", "QDynamicPropertyChangeEvent",
methods_QDynamicPropertyChangeEvent_Adaptor (),
"@qt\n@brief Binding of QDynamicPropertyChangeEvent");

16
src/gsiqt4/gsiDeclQEasingCurve.cc → src/gsiqt/qt4/QtCore/gsiDeclQEasingCurve.cc
View File

@ -29,8 +29,8 @@
#include <QEasingCurve>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -313,12 +313,12 @@ static gsi::Methods methods_QEasingCurve () {
return methods;
}
gsi::Class<QEasingCurve> decl_QEasingCurve ("QEasingCurve",
gsi::Class<QEasingCurve> decl_QEasingCurve ("QtCore", "QEasingCurve",
methods_QEasingCurve (),
"@qt\n@brief Binding of QEasingCurve");
GSIQT_PUBLIC gsi::Class<QEasingCurve> &qtdecl_QEasingCurve () { return decl_QEasingCurve; }
GSI_QTCORE_PUBLIC gsi::Class<QEasingCurve> &qtdecl_QEasingCurve () { return decl_QEasingCurve; }
}
@ -327,7 +327,7 @@ GSIQT_PUBLIC gsi::Class<QEasingCurve> &qtdecl_QEasingCurve () { return decl_QEas
namespace qt_gsi
{
static gsi::Enum<QEasingCurve::Type> decl_QEasingCurve_Type_Enum ("QEasingCurve_Type",
static gsi::Enum<QEasingCurve::Type> decl_QEasingCurve_Type_Enum ("QtCore", "QEasingCurve_Type",
gsi::enum_const ("Linear", QEasingCurve::Linear, "@brief Enum constant QEasingCurve::Linear") +
gsi::enum_const ("InQuad", QEasingCurve::InQuad, "@brief Enum constant QEasingCurve::InQuad") +
gsi::enum_const ("OutQuad", QEasingCurve::OutQuad, "@brief Enum constant QEasingCurve::OutQuad") +
@ -377,13 +377,13 @@ static gsi::Enum<QEasingCurve::Type> decl_QEasingCurve_Type_Enum ("QEasingCurve_
gsi::enum_const ("NCurveTypes", QEasingCurve::NCurveTypes, "@brief Enum constant QEasingCurve::NCurveTypes"),
"@qt\n@brief This class represents the QEasingCurve::Type enum");
static gsi::QFlagsClass<QEasingCurve::Type > decl_QEasingCurve_Type_Enums ("QEasingCurve_QFlags_Type",
static gsi::QFlagsClass<QEasingCurve::Type > decl_QEasingCurve_Type_Enums ("QtCore", "QEasingCurve_QFlags_Type",
"@qt\n@brief This class represents the QFlags<QEasingCurve::Type> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QEasingCurve> inject_QEasingCurve_Type_Enum_in_parent (decl_QEasingCurve_Type_Enum.defs ());
static gsi::ClassExt<QEasingCurve> decl_QEasingCurve_Type_Enum_as_child (decl_QEasingCurve_Type_Enum, "Type");
static gsi::ClassExt<QEasingCurve> decl_QEasingCurve_Type_Enums_as_child (decl_QEasingCurve_Type_Enums, "QFlags_Type");
static gsi::ClassExt<QEasingCurve> decl_QEasingCurve_Type_Enum_as_child (decl_QEasingCurve_Type_Enum, "QtCore", "Type");
static gsi::ClassExt<QEasingCurve> decl_QEasingCurve_Type_Enums_as_child (decl_QEasingCurve_Type_Enums, "QtCore", "QFlags_Type");
}

18
src/gsiqt4/gsiDeclQEvent.cc → src/gsiqt/qt4/QtCore/gsiDeclQEvent.cc
View File

@ -29,8 +29,8 @@
#include <QEvent>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -167,11 +167,11 @@ static gsi::Methods methods_QEvent () {
return methods;
}
gsi::Class<QEvent> decl_QEvent ("QEvent_Native",
gsi::Class<QEvent> decl_QEvent ("QtCore", "QEvent_Native",
methods_QEvent (),
"@hide\n@alias QEvent");
GSIQT_PUBLIC gsi::Class<QEvent> &qtdecl_QEvent () { return decl_QEvent; }
GSI_QTCORE_PUBLIC gsi::Class<QEvent> &qtdecl_QEvent () { return decl_QEvent; }
}
@ -222,7 +222,7 @@ static gsi::Methods methods_QEvent_Adaptor () {
return methods;
}
gsi::Class<QEvent_Adaptor> decl_QEvent_Adaptor (qtdecl_QEvent (), "QEvent",
gsi::Class<QEvent_Adaptor> decl_QEvent_Adaptor (qtdecl_QEvent (), "QtCore", "QEvent",
methods_QEvent_Adaptor (),
"@qt\n@brief Binding of QEvent");
@ -233,7 +233,7 @@ gsi::Class<QEvent_Adaptor> decl_QEvent_Adaptor (qtdecl_QEvent (), "QEvent",
namespace qt_gsi
{
static gsi::Enum<QEvent::Type> decl_QEvent_Type_Enum ("QEvent_Type",
static gsi::Enum<QEvent::Type> decl_QEvent_Type_Enum ("QtCore", "QEvent_Type",
gsi::enum_const ("None", QEvent::None, "@brief Enum constant QEvent::None") +
gsi::enum_const ("Timer", QEvent::Timer, "@brief Enum constant QEvent::Timer") +
gsi::enum_const ("MouseButtonPress", QEvent::MouseButtonPress, "@brief Enum constant QEvent::MouseButtonPress") +
@ -395,13 +395,13 @@ static gsi::Enum<QEvent::Type> decl_QEvent_Type_Enum ("QEvent_Type",
gsi::enum_const ("MaxUser", QEvent::MaxUser, "@brief Enum constant QEvent::MaxUser"),
"@qt\n@brief This class represents the QEvent::Type enum");
static gsi::QFlagsClass<QEvent::Type > decl_QEvent_Type_Enums ("QEvent_QFlags_Type",
static gsi::QFlagsClass<QEvent::Type > decl_QEvent_Type_Enums ("QtCore", "QEvent_QFlags_Type",
"@qt\n@brief This class represents the QFlags<QEvent::Type> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QEvent> inject_QEvent_Type_Enum_in_parent (decl_QEvent_Type_Enum.defs ());
static gsi::ClassExt<QEvent> decl_QEvent_Type_Enum_as_child (decl_QEvent_Type_Enum, "Type");
static gsi::ClassExt<QEvent> decl_QEvent_Type_Enums_as_child (decl_QEvent_Type_Enums, "QFlags_Type");
static gsi::ClassExt<QEvent> decl_QEvent_Type_Enum_as_child (decl_QEvent_Type_Enum, "QtCore", "Type");
static gsi::ClassExt<QEvent> decl_QEvent_Type_Enums_as_child (decl_QEvent_Type_Enums, "QtCore", "QFlags_Type");
}

18
src/gsiqt4/gsiDeclQEventLoop.cc → src/gsiqt/qt4/QtCore/gsiDeclQEventLoop.cc
View File

@ -34,8 +34,8 @@
#include <QThread>
#include <QTimerEvent>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -299,11 +299,11 @@ static gsi::Methods methods_QEventLoop () {
gsi::Class<QObject> &qtdecl_QObject ();
qt_gsi::QtNativeClass<QEventLoop> decl_QEventLoop (qtdecl_QObject (), "QEventLoop_Native",
qt_gsi::QtNativeClass<QEventLoop> decl_QEventLoop (qtdecl_QObject (), "QtCore", "QEventLoop_Native",
methods_QEventLoop (),
"@hide\n@alias QEventLoop");
GSIQT_PUBLIC gsi::Class<QEventLoop> &qtdecl_QEventLoop () { return decl_QEventLoop; }
GSI_QTCORE_PUBLIC gsi::Class<QEventLoop> &qtdecl_QEventLoop () { return decl_QEventLoop; }
}
@ -681,7 +681,7 @@ static gsi::Methods methods_QEventLoop_Adaptor () {
return methods;
}
gsi::Class<QEventLoop_Adaptor> decl_QEventLoop_Adaptor (qtdecl_QEventLoop (), "QEventLoop",
gsi::Class<QEventLoop_Adaptor> decl_QEventLoop_Adaptor (qtdecl_QEventLoop (), "QtCore", "QEventLoop",
methods_QEventLoop_Adaptor (),
"@qt\n@brief Binding of QEventLoop");
@ -692,7 +692,7 @@ gsi::Class<QEventLoop_Adaptor> decl_QEventLoop_Adaptor (qtdecl_QEventLoop (), "Q
namespace qt_gsi
{
static gsi::Enum<QEventLoop::ProcessEventsFlag> decl_QEventLoop_ProcessEventsFlag_Enum ("QEventLoop_ProcessEventsFlag",
static gsi::Enum<QEventLoop::ProcessEventsFlag> decl_QEventLoop_ProcessEventsFlag_Enum ("QtCore", "QEventLoop_ProcessEventsFlag",
gsi::enum_const ("AllEvents", QEventLoop::AllEvents, "@brief Enum constant QEventLoop::AllEvents") +
gsi::enum_const ("ExcludeUserInputEvents", QEventLoop::ExcludeUserInputEvents, "@brief Enum constant QEventLoop::ExcludeUserInputEvents") +
gsi::enum_const ("ExcludeSocketNotifiers", QEventLoop::ExcludeSocketNotifiers, "@brief Enum constant QEventLoop::ExcludeSocketNotifiers") +
@ -703,13 +703,13 @@ static gsi::Enum<QEventLoop::ProcessEventsFlag> decl_QEventLoop_ProcessEventsFla
gsi::enum_const ("DialogExec", QEventLoop::DialogExec, "@brief Enum constant QEventLoop::DialogExec"),
"@qt\n@brief This class represents the QEventLoop::ProcessEventsFlag enum");
static gsi::QFlagsClass<QEventLoop::ProcessEventsFlag > decl_QEventLoop_ProcessEventsFlag_Enums ("QEventLoop_QFlags_ProcessEventsFlag",
static gsi::QFlagsClass<QEventLoop::ProcessEventsFlag > decl_QEventLoop_ProcessEventsFlag_Enums ("QtCore", "QEventLoop_QFlags_ProcessEventsFlag",
"@qt\n@brief This class represents the QFlags<QEventLoop::ProcessEventsFlag> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QEventLoop> inject_QEventLoop_ProcessEventsFlag_Enum_in_parent (decl_QEventLoop_ProcessEventsFlag_Enum.defs ());
static gsi::ClassExt<QEventLoop> decl_QEventLoop_ProcessEventsFlag_Enum_as_child (decl_QEventLoop_ProcessEventsFlag_Enum, "ProcessEventsFlag");
static gsi::ClassExt<QEventLoop> decl_QEventLoop_ProcessEventsFlag_Enums_as_child (decl_QEventLoop_ProcessEventsFlag_Enums, "QFlags_ProcessEventsFlag");
static gsi::ClassExt<QEventLoop> decl_QEventLoop_ProcessEventsFlag_Enum_as_child (decl_QEventLoop_ProcessEventsFlag_Enum, "QtCore", "ProcessEventsFlag");
static gsi::ClassExt<QEventLoop> decl_QEventLoop_ProcessEventsFlag_Enums_as_child (decl_QEventLoop_ProcessEventsFlag_Enums, "QtCore", "QFlags_ProcessEventsFlag");
}

10
src/gsiqt4/gsiDeclQFactoryInterface.cc → src/gsiqt/qt4/QtCore/gsiDeclQFactoryInterface.cc
View File

@ -29,8 +29,8 @@
#include <QFactoryInterface>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -60,11 +60,11 @@ static gsi::Methods methods_QFactoryInterface () {
return methods;
}
gsi::Class<QFactoryInterface> decl_QFactoryInterface ("QFactoryInterface_Native",
gsi::Class<QFactoryInterface> decl_QFactoryInterface ("QtCore", "QFactoryInterface_Native",
methods_QFactoryInterface (),
"@hide\n@alias QFactoryInterface");
GSIQT_PUBLIC gsi::Class<QFactoryInterface> &qtdecl_QFactoryInterface () { return decl_QFactoryInterface; }
GSI_QTCORE_PUBLIC gsi::Class<QFactoryInterface> &qtdecl_QFactoryInterface () { return decl_QFactoryInterface; }
}
@ -147,7 +147,7 @@ static gsi::Methods methods_QFactoryInterface_Adaptor () {
return methods;
}
gsi::Class<QFactoryInterface_Adaptor> decl_QFactoryInterface_Adaptor (qtdecl_QFactoryInterface (), "QFactoryInterface",
gsi::Class<QFactoryInterface_Adaptor> decl_QFactoryInterface_Adaptor (qtdecl_QFactoryInterface (), "QtCore", "QFactoryInterface",
methods_QFactoryInterface_Adaptor (),
"@qt\n@brief Binding of QFactoryInterface");

24
src/gsiqt4/gsiDeclQFile.cc → src/gsiqt/qt4/QtCore/gsiDeclQFile.cc
View File

@ -34,8 +34,8 @@
#include <QThread>
#include <QTimerEvent>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -906,12 +906,12 @@ static gsi::Methods methods_QFile () {
gsi::Class<QIODevice> &qtdecl_QIODevice ();
qt_gsi::QtNativeClass<QFile> decl_QFile (qtdecl_QIODevice (), "QFile",
qt_gsi::QtNativeClass<QFile> decl_QFile (qtdecl_QIODevice (), "QtCore", "QFile",
methods_QFile (),
"@qt\n@brief Binding of QFile");
GSIQT_PUBLIC gsi::Class<QFile> &qtdecl_QFile () { return decl_QFile; }
GSI_QTCORE_PUBLIC gsi::Class<QFile> &qtdecl_QFile () { return decl_QFile; }
}
@ -920,7 +920,7 @@ GSIQT_PUBLIC gsi::Class<QFile> &qtdecl_QFile () { return decl_QFile; }
namespace qt_gsi
{
static gsi::Enum<QFile::FileError> decl_QFile_FileError_Enum ("QFile_FileError",
static gsi::Enum<QFile::FileError> decl_QFile_FileError_Enum ("QtCore", "QFile_FileError",
gsi::enum_const ("NoError", QFile::NoError, "@brief Enum constant QFile::NoError") +
gsi::enum_const ("ReadError", QFile::ReadError, "@brief Enum constant QFile::ReadError") +
gsi::enum_const ("WriteError", QFile::WriteError, "@brief Enum constant QFile::WriteError") +
@ -938,13 +938,13 @@ static gsi::Enum<QFile::FileError> decl_QFile_FileError_Enum ("QFile_FileError",
gsi::enum_const ("CopyError", QFile::CopyError, "@brief Enum constant QFile::CopyError"),
"@qt\n@brief This class represents the QFile::FileError enum");
static gsi::QFlagsClass<QFile::FileError > decl_QFile_FileError_Enums ("QFile_QFlags_FileError",
static gsi::QFlagsClass<QFile::FileError > decl_QFile_FileError_Enums ("QtCore", "QFile_QFlags_FileError",
"@qt\n@brief This class represents the QFlags<QFile::FileError> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QFile> inject_QFile_FileError_Enum_in_parent (decl_QFile_FileError_Enum.defs ());
static gsi::ClassExt<QFile> decl_QFile_FileError_Enum_as_child (decl_QFile_FileError_Enum, "FileError");
static gsi::ClassExt<QFile> decl_QFile_FileError_Enums_as_child (decl_QFile_FileError_Enums, "QFlags_FileError");
static gsi::ClassExt<QFile> decl_QFile_FileError_Enum_as_child (decl_QFile_FileError_Enum, "QtCore", "FileError");
static gsi::ClassExt<QFile> decl_QFile_FileError_Enums_as_child (decl_QFile_FileError_Enums, "QtCore", "QFlags_FileError");
}
@ -953,7 +953,7 @@ static gsi::ClassExt<QFile> decl_QFile_FileError_Enums_as_child (decl_QFile_File
namespace qt_gsi
{
static gsi::Enum<QFile::Permission> decl_QFile_Permission_Enum ("QFile_Permission",
static gsi::Enum<QFile::Permission> decl_QFile_Permission_Enum ("QtCore", "QFile_Permission",
gsi::enum_const ("ReadOwner", QFile::ReadOwner, "@brief Enum constant QFile::ReadOwner") +
gsi::enum_const ("WriteOwner", QFile::WriteOwner, "@brief Enum constant QFile::WriteOwner") +
gsi::enum_const ("ExeOwner", QFile::ExeOwner, "@brief Enum constant QFile::ExeOwner") +
@ -968,13 +968,13 @@ static gsi::Enum<QFile::Permission> decl_QFile_Permission_Enum ("QFile_Permissio
gsi::enum_const ("ExeOther", QFile::ExeOther, "@brief Enum constant QFile::ExeOther"),
"@qt\n@brief This class represents the QFile::Permission enum");
static gsi::QFlagsClass<QFile::Permission > decl_QFile_Permission_Enums ("QFile_QFlags_Permission",
static gsi::QFlagsClass<QFile::Permission > decl_QFile_Permission_Enums ("QtCore", "QFile_QFlags_Permission",
"@qt\n@brief This class represents the QFlags<QFile::Permission> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QFile> inject_QFile_Permission_Enum_in_parent (decl_QFile_Permission_Enum.defs ());
static gsi::ClassExt<QFile> decl_QFile_Permission_Enum_as_child (decl_QFile_Permission_Enum, "Permission");
static gsi::ClassExt<QFile> decl_QFile_Permission_Enums_as_child (decl_QFile_Permission_Enums, "QFlags_Permission");
static gsi::ClassExt<QFile> decl_QFile_Permission_Enum_as_child (decl_QFile_Permission_Enum, "QtCore", "Permission");
static gsi::ClassExt<QFile> decl_QFile_Permission_Enums_as_child (decl_QFile_Permission_Enums, "QtCore", "QFlags_Permission");
}

8
src/gsiqt4/gsiDeclQFileInfo.cc → src/gsiqt/qt4/QtCore/gsiDeclQFileInfo.cc
View File

@ -32,8 +32,8 @@
#include <QDir>
#include <QFile>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -1012,12 +1012,12 @@ static gsi::Methods methods_QFileInfo () {
return methods;
}
gsi::Class<QFileInfo> decl_QFileInfo ("QFileInfo",
gsi::Class<QFileInfo> decl_QFileInfo ("QtCore", "QFileInfo",
methods_QFileInfo (),
"@qt\n@brief Binding of QFileInfo");
GSIQT_PUBLIC gsi::Class<QFileInfo> &qtdecl_QFileInfo () { return decl_QFileInfo; }
GSI_QTCORE_PUBLIC gsi::Class<QFileInfo> &qtdecl_QFileInfo () { return decl_QFileInfo; }
}

10
src/gsiqt4/gsiDeclQFileSystemWatcher.cc → src/gsiqt/qt4/QtCore/gsiDeclQFileSystemWatcher.cc
View File

@ -34,8 +34,8 @@
#include <QThread>
#include <QTimerEvent>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -282,11 +282,11 @@ static gsi::Methods methods_QFileSystemWatcher () {
gsi::Class<QObject> &qtdecl_QObject ();
qt_gsi::QtNativeClass<QFileSystemWatcher> decl_QFileSystemWatcher (qtdecl_QObject (), "QFileSystemWatcher_Native",
qt_gsi::QtNativeClass<QFileSystemWatcher> decl_QFileSystemWatcher (qtdecl_QObject (), "QtCore", "QFileSystemWatcher_Native",
methods_QFileSystemWatcher (),
"@hide\n@alias QFileSystemWatcher");
GSIQT_PUBLIC gsi::Class<QFileSystemWatcher> &qtdecl_QFileSystemWatcher () { return decl_QFileSystemWatcher; }
GSI_QTCORE_PUBLIC gsi::Class<QFileSystemWatcher> &qtdecl_QFileSystemWatcher () { return decl_QFileSystemWatcher; }
}
@ -748,7 +748,7 @@ static gsi::Methods methods_QFileSystemWatcher_Adaptor () {
return methods;
}
gsi::Class<QFileSystemWatcher_Adaptor> decl_QFileSystemWatcher_Adaptor (qtdecl_QFileSystemWatcher (), "QFileSystemWatcher",
gsi::Class<QFileSystemWatcher_Adaptor> decl_QFileSystemWatcher_Adaptor (qtdecl_QFileSystemWatcher (), "QtCore", "QFileSystemWatcher",
methods_QFileSystemWatcher_Adaptor (),
"@qt\n@brief Binding of QFileSystemWatcher");

16
src/gsiqt4/gsiDeclQIODevice.cc → src/gsiqt/qt4/QtCore/gsiDeclQIODevice.cc
View File

@ -34,8 +34,8 @@
#include <QThread>
#include <QTimerEvent>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -671,12 +671,12 @@ static gsi::Methods methods_QIODevice () {
gsi::Class<QObject> &qtdecl_QObject ();
qt_gsi::QtNativeClass<QIODevice> decl_QIODevice (qtdecl_QObject (), "QIODevice",
qt_gsi::QtNativeClass<QIODevice> decl_QIODevice (qtdecl_QObject (), "QtCore", "QIODevice",
methods_QIODevice (),
"@qt\n@brief Binding of QIODevice");
GSIQT_PUBLIC gsi::Class<QIODevice> &qtdecl_QIODevice () { return decl_QIODevice; }
GSI_QTCORE_PUBLIC gsi::Class<QIODevice> &qtdecl_QIODevice () { return decl_QIODevice; }
}
@ -685,7 +685,7 @@ GSIQT_PUBLIC gsi::Class<QIODevice> &qtdecl_QIODevice () { return decl_QIODevice;
namespace qt_gsi
{
static gsi::Enum<QIODevice::OpenModeFlag> decl_QIODevice_OpenModeFlag_Enum ("QIODevice_OpenModeFlag",
static gsi::Enum<QIODevice::OpenModeFlag> decl_QIODevice_OpenModeFlag_Enum ("QtCore", "QIODevice_OpenModeFlag",
gsi::enum_const ("NotOpen", QIODevice::NotOpen, "@brief Enum constant QIODevice::NotOpen") +
gsi::enum_const ("ReadOnly", QIODevice::ReadOnly, "@brief Enum constant QIODevice::ReadOnly") +
gsi::enum_const ("WriteOnly", QIODevice::WriteOnly, "@brief Enum constant QIODevice::WriteOnly") +
@ -696,13 +696,13 @@ static gsi::Enum<QIODevice::OpenModeFlag> decl_QIODevice_OpenModeFlag_Enum ("QIO
gsi::enum_const ("Unbuffered", QIODevice::Unbuffered, "@brief Enum constant QIODevice::Unbuffered"),
"@qt\n@brief This class represents the QIODevice::OpenModeFlag enum");
static gsi::QFlagsClass<QIODevice::OpenModeFlag > decl_QIODevice_OpenModeFlag_Enums ("QIODevice_QFlags_OpenModeFlag",
static gsi::QFlagsClass<QIODevice::OpenModeFlag > decl_QIODevice_OpenModeFlag_Enums ("QtCore", "QIODevice_QFlags_OpenModeFlag",
"@qt\n@brief This class represents the QFlags<QIODevice::OpenModeFlag> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QIODevice> inject_QIODevice_OpenModeFlag_Enum_in_parent (decl_QIODevice_OpenModeFlag_Enum.defs ());
static gsi::ClassExt<QIODevice> decl_QIODevice_OpenModeFlag_Enum_as_child (decl_QIODevice_OpenModeFlag_Enum, "OpenModeFlag");
static gsi::ClassExt<QIODevice> decl_QIODevice_OpenModeFlag_Enums_as_child (decl_QIODevice_OpenModeFlag_Enums, "QFlags_OpenModeFlag");
static gsi::ClassExt<QIODevice> decl_QIODevice_OpenModeFlag_Enum_as_child (decl_QIODevice_OpenModeFlag_Enum, "QtCore", "OpenModeFlag");
static gsi::ClassExt<QIODevice> decl_QIODevice_OpenModeFlag_Enums_as_child (decl_QIODevice_OpenModeFlag_Enums, "QtCore", "QFlags_OpenModeFlag");
}

18
src/gsiqt4/gsiDeclQLibrary.cc → src/gsiqt/qt4/QtCore/gsiDeclQLibrary.cc
View File

@ -34,8 +34,8 @@
#include <QThread>
#include <QTimerEvent>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -465,11 +465,11 @@ static gsi::Methods methods_QLibrary () {
gsi::Class<QObject> &qtdecl_QObject ();
qt_gsi::QtNativeClass<QLibrary> decl_QLibrary (qtdecl_QObject (), "QLibrary_Native",
qt_gsi::QtNativeClass<QLibrary> decl_QLibrary (qtdecl_QObject (), "QtCore", "QLibrary_Native",
methods_QLibrary (),
"@hide\n@alias QLibrary");
GSIQT_PUBLIC gsi::Class<QLibrary> &qtdecl_QLibrary () { return decl_QLibrary; }
GSI_QTCORE_PUBLIC gsi::Class<QLibrary> &qtdecl_QLibrary () { return decl_QLibrary; }
}
@ -955,7 +955,7 @@ static gsi::Methods methods_QLibrary_Adaptor () {
return methods;
}
gsi::Class<QLibrary_Adaptor> decl_QLibrary_Adaptor (qtdecl_QLibrary (), "QLibrary",
gsi::Class<QLibrary_Adaptor> decl_QLibrary_Adaptor (qtdecl_QLibrary (), "QtCore", "QLibrary",
methods_QLibrary_Adaptor (),
"@qt\n@brief Binding of QLibrary");
@ -966,19 +966,19 @@ gsi::Class<QLibrary_Adaptor> decl_QLibrary_Adaptor (qtdecl_QLibrary (), "QLibrar
namespace qt_gsi
{
static gsi::Enum<QLibrary::LoadHint> decl_QLibrary_LoadHint_Enum ("QLibrary_LoadHint",
static gsi::Enum<QLibrary::LoadHint> decl_QLibrary_LoadHint_Enum ("QtCore", "QLibrary_LoadHint",
gsi::enum_const ("ResolveAllSymbolsHint", QLibrary::ResolveAllSymbolsHint, "@brief Enum constant QLibrary::ResolveAllSymbolsHint") +
gsi::enum_const ("ExportExternalSymbolsHint", QLibrary::ExportExternalSymbolsHint, "@brief Enum constant QLibrary::ExportExternalSymbolsHint") +
gsi::enum_const ("LoadArchiveMemberHint", QLibrary::LoadArchiveMemberHint, "@brief Enum constant QLibrary::LoadArchiveMemberHint"),
"@qt\n@brief This class represents the QLibrary::LoadHint enum");
static gsi::QFlagsClass<QLibrary::LoadHint > decl_QLibrary_LoadHint_Enums ("QLibrary_QFlags_LoadHint",
static gsi::QFlagsClass<QLibrary::LoadHint > decl_QLibrary_LoadHint_Enums ("QtCore", "QLibrary_QFlags_LoadHint",
"@qt\n@brief This class represents the QFlags<QLibrary::LoadHint> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QLibrary> inject_QLibrary_LoadHint_Enum_in_parent (decl_QLibrary_LoadHint_Enum.defs ());
static gsi::ClassExt<QLibrary> decl_QLibrary_LoadHint_Enum_as_child (decl_QLibrary_LoadHint_Enum, "LoadHint");
static gsi::ClassExt<QLibrary> decl_QLibrary_LoadHint_Enums_as_child (decl_QLibrary_LoadHint_Enums, "QFlags_LoadHint");
static gsi::ClassExt<QLibrary> decl_QLibrary_LoadHint_Enum_as_child (decl_QLibrary_LoadHint_Enum, "QtCore", "LoadHint");
static gsi::ClassExt<QLibrary> decl_QLibrary_LoadHint_Enums_as_child (decl_QLibrary_LoadHint_Enums, "QtCore", "QFlags_LoadHint");
}

16
src/gsiqt4/gsiDeclQLibraryInfo.cc → src/gsiqt/qt4/QtCore/gsiDeclQLibraryInfo.cc
View File

@ -30,8 +30,8 @@
#include <QLibraryInfo>
#include <QDate>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -130,12 +130,12 @@ static gsi::Methods methods_QLibraryInfo () {
return methods;
}
gsi::Class<QLibraryInfo> decl_QLibraryInfo ("QLibraryInfo",
gsi::Class<QLibraryInfo> decl_QLibraryInfo ("QtCore", "QLibraryInfo",
methods_QLibraryInfo (),
"@qt\n@brief Binding of QLibraryInfo");
GSIQT_PUBLIC gsi::Class<QLibraryInfo> &qtdecl_QLibraryInfo () { return decl_QLibraryInfo; }
GSI_QTCORE_PUBLIC gsi::Class<QLibraryInfo> &qtdecl_QLibraryInfo () { return decl_QLibraryInfo; }
}
@ -144,7 +144,7 @@ GSIQT_PUBLIC gsi::Class<QLibraryInfo> &qtdecl_QLibraryInfo () { return decl_QLib
namespace qt_gsi
{
static gsi::Enum<QLibraryInfo::LibraryLocation> decl_QLibraryInfo_LibraryLocation_Enum ("QLibraryInfo_LibraryLocation",
static gsi::Enum<QLibraryInfo::LibraryLocation> decl_QLibraryInfo_LibraryLocation_Enum ("QtCore", "QLibraryInfo_LibraryLocation",
gsi::enum_const ("PrefixPath", QLibraryInfo::PrefixPath, "@brief Enum constant QLibraryInfo::PrefixPath") +
gsi::enum_const ("DocumentationPath", QLibraryInfo::DocumentationPath, "@brief Enum constant QLibraryInfo::DocumentationPath") +
gsi::enum_const ("HeadersPath", QLibraryInfo::HeadersPath, "@brief Enum constant QLibraryInfo::HeadersPath") +
@ -158,13 +158,13 @@ static gsi::Enum<QLibraryInfo::LibraryLocation> decl_QLibraryInfo_LibraryLocatio
gsi::enum_const ("ExamplesPath", QLibraryInfo::ExamplesPath, "@brief Enum constant QLibraryInfo::ExamplesPath"),
"@qt\n@brief This class represents the QLibraryInfo::LibraryLocation enum");
static gsi::QFlagsClass<QLibraryInfo::LibraryLocation > decl_QLibraryInfo_LibraryLocation_Enums ("QLibraryInfo_QFlags_LibraryLocation",
static gsi::QFlagsClass<QLibraryInfo::LibraryLocation > decl_QLibraryInfo_LibraryLocation_Enums ("QtCore", "QLibraryInfo_QFlags_LibraryLocation",
"@qt\n@brief This class represents the QFlags<QLibraryInfo::LibraryLocation> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QLibraryInfo> inject_QLibraryInfo_LibraryLocation_Enum_in_parent (decl_QLibraryInfo_LibraryLocation_Enum.defs ());
static gsi::ClassExt<QLibraryInfo> decl_QLibraryInfo_LibraryLocation_Enum_as_child (decl_QLibraryInfo_LibraryLocation_Enum, "LibraryLocation");
static gsi::ClassExt<QLibraryInfo> decl_QLibraryInfo_LibraryLocation_Enums_as_child (decl_QLibraryInfo_LibraryLocation_Enums, "QFlags_LibraryLocation");
static gsi::ClassExt<QLibraryInfo> decl_QLibraryInfo_LibraryLocation_Enum_as_child (decl_QLibraryInfo_LibraryLocation_Enum, "QtCore", "LibraryLocation");
static gsi::ClassExt<QLibraryInfo> decl_QLibraryInfo_LibraryLocation_Enums_as_child (decl_QLibraryInfo_LibraryLocation_Enums, "QtCore", "QFlags_LibraryLocation");
}

20
src/gsiqt4/gsiDeclQLine.cc → src/gsiqt/qt4/QtCore/gsiDeclQLine.cc
View File

@ -30,8 +30,8 @@
#include <QLine>
#include <QPoint>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -451,16 +451,6 @@ static void _call_f_y2_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gs
}
// QLine ::operator*(const QLine &l, const QMatrix &m)
static QLine op_QLine_operator_star__3701(const QLine *_self, const QMatrix &m) {
return ::operator*(*_self, m);
}
// QLine ::operator*(const QLine &l, const QTransform &m)
static QLine op_QLine_operator_star__4028(const QLine *_self, const QTransform &m) {
return ::operator*(*_self, m);
}
namespace gsi
{
@ -489,17 +479,15 @@ static gsi::Methods methods_QLine () {
methods += new qt_gsi::GenericMethod ("x2", "@brief Method int QLine::x2()\n", true, &_init_f_x2_c0, &_call_f_x2_c0);
methods += new qt_gsi::GenericMethod ("y1", "@brief Method int QLine::y1()\n", true, &_init_f_y1_c0, &_call_f_y1_c0);
methods += new qt_gsi::GenericMethod ("y2", "@brief Method int QLine::y2()\n", true, &_init_f_y2_c0, &_call_f_y2_c0);
methods += gsi::method_ext("*", &::op_QLine_operator_star__3701, gsi::arg ("m"), "@brief Operator QLine ::operator*(const QLine &l, const QMatrix &m)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("*", &::op_QLine_operator_star__4028, gsi::arg ("m"), "@brief Operator QLine ::operator*(const QLine &l, const QTransform &m)\nThis is the mapping of the global operator to the instance method.");
return methods;
}
gsi::Class<QLine> decl_QLine ("QLine",
gsi::Class<QLine> decl_QLine ("QtCore", "QLine",
methods_QLine (),
"@qt\n@brief Binding of QLine");
GSIQT_PUBLIC gsi::Class<QLine> &qtdecl_QLine () { return decl_QLine; }
GSI_QTCORE_PUBLIC gsi::Class<QLine> &qtdecl_QLine () { return decl_QLine; }
}

28
src/gsiqt4/gsiDeclQLineF.cc → src/gsiqt/qt4/QtCore/gsiDeclQLineF.cc
View File

@ -31,8 +31,8 @@
#include <QLine>
#include <QPointF>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -687,16 +687,6 @@ static void _call_f_fromPolar_2034 (const qt_gsi::GenericStaticMethod * /*decl*/
}
// QLineF ::operator*(const QLineF &l, const QMatrix &m)
static QLineF op_QLineF_operator_star__3771(const QLineF *_self, const QMatrix &m) {
return ::operator*(*_self, m);
}
// QLineF ::operator*(const QLineF &l, const QTransform &m)
static QLineF op_QLineF_operator_star__4098(const QLineF *_self, const QTransform &m) {
return ::operator*(*_self, m);
}
namespace gsi
{
@ -738,17 +728,15 @@ static gsi::Methods methods_QLineF () {
methods += new qt_gsi::GenericMethod ("y1", "@brief Method double QLineF::y1()\n", true, &_init_f_y1_c0, &_call_f_y1_c0);
methods += new qt_gsi::GenericMethod ("y2", "@brief Method double QLineF::y2()\n", true, &_init_f_y2_c0, &_call_f_y2_c0);
methods += new qt_gsi::GenericStaticMethod ("fromPolar", "@brief Static method QLineF QLineF::fromPolar(double length, double angle)\nThis method is static and can be called without an instance.", &_init_f_fromPolar_2034, &_call_f_fromPolar_2034);
methods += gsi::method_ext("*", &::op_QLineF_operator_star__3771, gsi::arg ("m"), "@brief Operator QLineF ::operator*(const QLineF &l, const QMatrix &m)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("*", &::op_QLineF_operator_star__4098, gsi::arg ("m"), "@brief Operator QLineF ::operator*(const QLineF &l, const QTransform &m)\nThis is the mapping of the global operator to the instance method.");
return methods;
}
gsi::Class<QLineF> decl_QLineF ("QLineF",
gsi::Class<QLineF> decl_QLineF ("QtCore", "QLineF",
methods_QLineF (),
"@qt\n@brief Binding of QLineF");
GSIQT_PUBLIC gsi::Class<QLineF> &qtdecl_QLineF () { return decl_QLineF; }
GSI_QTCORE_PUBLIC gsi::Class<QLineF> &qtdecl_QLineF () { return decl_QLineF; }
}
@ -757,19 +745,19 @@ GSIQT_PUBLIC gsi::Class<QLineF> &qtdecl_QLineF () { return decl_QLineF; }
namespace qt_gsi
{
static gsi::Enum<QLineF::IntersectType> decl_QLineF_IntersectType_Enum ("QLineF_IntersectType",
static gsi::Enum<QLineF::IntersectType> decl_QLineF_IntersectType_Enum ("QtCore", "QLineF_IntersectType",
gsi::enum_const ("NoIntersection", QLineF::NoIntersection, "@brief Enum constant QLineF::NoIntersection") +
gsi::enum_const ("BoundedIntersection", QLineF::BoundedIntersection, "@brief Enum constant QLineF::BoundedIntersection") +
gsi::enum_const ("UnboundedIntersection", QLineF::UnboundedIntersection, "@brief Enum constant QLineF::UnboundedIntersection"),
"@qt\n@brief This class represents the QLineF::IntersectType enum");
static gsi::QFlagsClass<QLineF::IntersectType > decl_QLineF_IntersectType_Enums ("QLineF_QFlags_IntersectType",
static gsi::QFlagsClass<QLineF::IntersectType > decl_QLineF_IntersectType_Enums ("QtCore", "QLineF_QFlags_IntersectType",
"@qt\n@brief This class represents the QFlags<QLineF::IntersectType> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QLineF> inject_QLineF_IntersectType_Enum_in_parent (decl_QLineF_IntersectType_Enum.defs ());
static gsi::ClassExt<QLineF> decl_QLineF_IntersectType_Enum_as_child (decl_QLineF_IntersectType_Enum, "IntersectType");
static gsi::ClassExt<QLineF> decl_QLineF_IntersectType_Enums_as_child (decl_QLineF_IntersectType_Enums, "QFlags_IntersectType");
static gsi::ClassExt<QLineF> decl_QLineF_IntersectType_Enum_as_child (decl_QLineF_IntersectType_Enum, "QtCore", "IntersectType");
static gsi::ClassExt<QLineF> decl_QLineF_IntersectType_Enums_as_child (decl_QLineF_IntersectType_Enums, "QtCore", "QFlags_IntersectType");
}

48
src/gsiqt4/gsiDeclQLocale.cc → src/gsiqt/qt4/QtCore/gsiDeclQLocale.cc
View File

@ -32,8 +32,8 @@
#include <QDateTime>
#include <QTime>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -1347,12 +1347,12 @@ static gsi::Methods methods_QLocale () {
return methods;
}
gsi::Class<QLocale> decl_QLocale ("QLocale",
gsi::Class<QLocale> decl_QLocale ("QtCore", "QLocale",
methods_QLocale (),
"@qt\n@brief Binding of QLocale");
GSIQT_PUBLIC gsi::Class<QLocale> &qtdecl_QLocale () { return decl_QLocale; }
GSI_QTCORE_PUBLIC gsi::Class<QLocale> &qtdecl_QLocale () { return decl_QLocale; }
}
@ -1361,7 +1361,7 @@ GSIQT_PUBLIC gsi::Class<QLocale> &qtdecl_QLocale () { return decl_QLocale; }
namespace qt_gsi
{
static gsi::Enum<QLocale::Country> decl_QLocale_Country_Enum ("QLocale_Country",
static gsi::Enum<QLocale::Country> decl_QLocale_Country_Enum ("QtCore", "QLocale_Country",
gsi::enum_const ("AnyCountry", QLocale::AnyCountry, "@brief Enum constant QLocale::AnyCountry") +
gsi::enum_const ("Afghanistan", QLocale::Afghanistan, "@brief Enum constant QLocale::Afghanistan") +
gsi::enum_const ("Albania", QLocale::Albania, "@brief Enum constant QLocale::Albania") +
@ -1607,13 +1607,13 @@ static gsi::Enum<QLocale::Country> decl_QLocale_Country_Enum ("QLocale_Country",
gsi::enum_const ("LastCountry", QLocale::LastCountry, "@brief Enum constant QLocale::LastCountry"),
"@qt\n@brief This class represents the QLocale::Country enum");
static gsi::QFlagsClass<QLocale::Country > decl_QLocale_Country_Enums ("QLocale_QFlags_Country",
static gsi::QFlagsClass<QLocale::Country > decl_QLocale_Country_Enums ("QtCore", "QLocale_QFlags_Country",
"@qt\n@brief This class represents the QFlags<QLocale::Country> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QLocale> inject_QLocale_Country_Enum_in_parent (decl_QLocale_Country_Enum.defs ());
static gsi::ClassExt<QLocale> decl_QLocale_Country_Enum_as_child (decl_QLocale_Country_Enum, "Country");
static gsi::ClassExt<QLocale> decl_QLocale_Country_Enums_as_child (decl_QLocale_Country_Enums, "QFlags_Country");
static gsi::ClassExt<QLocale> decl_QLocale_Country_Enum_as_child (decl_QLocale_Country_Enum, "QtCore", "Country");
static gsi::ClassExt<QLocale> decl_QLocale_Country_Enums_as_child (decl_QLocale_Country_Enums, "QtCore", "QFlags_Country");
}
@ -1622,19 +1622,19 @@ static gsi::ClassExt<QLocale> decl_QLocale_Country_Enums_as_child (decl_QLocale_
namespace qt_gsi
{
static gsi::Enum<QLocale::FormatType> decl_QLocale_FormatType_Enum ("QLocale_FormatType",
static gsi::Enum<QLocale::FormatType> decl_QLocale_FormatType_Enum ("QtCore", "QLocale_FormatType",
gsi::enum_const ("LongFormat", QLocale::LongFormat, "@brief Enum constant QLocale::LongFormat") +
gsi::enum_const ("ShortFormat", QLocale::ShortFormat, "@brief Enum constant QLocale::ShortFormat") +
gsi::enum_const ("NarrowFormat", QLocale::NarrowFormat, "@brief Enum constant QLocale::NarrowFormat"),
"@qt\n@brief This class represents the QLocale::FormatType enum");
static gsi::QFlagsClass<QLocale::FormatType > decl_QLocale_FormatType_Enums ("QLocale_QFlags_FormatType",
static gsi::QFlagsClass<QLocale::FormatType > decl_QLocale_FormatType_Enums ("QtCore", "QLocale_QFlags_FormatType",
"@qt\n@brief This class represents the QFlags<QLocale::FormatType> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QLocale> inject_QLocale_FormatType_Enum_in_parent (decl_QLocale_FormatType_Enum.defs ());
static gsi::ClassExt<QLocale> decl_QLocale_FormatType_Enum_as_child (decl_QLocale_FormatType_Enum, "FormatType");
static gsi::ClassExt<QLocale> decl_QLocale_FormatType_Enums_as_child (decl_QLocale_FormatType_Enums, "QFlags_FormatType");
static gsi::ClassExt<QLocale> decl_QLocale_FormatType_Enum_as_child (decl_QLocale_FormatType_Enum, "QtCore", "FormatType");
static gsi::ClassExt<QLocale> decl_QLocale_FormatType_Enums_as_child (decl_QLocale_FormatType_Enums, "QtCore", "QFlags_FormatType");
}
@ -1643,7 +1643,7 @@ static gsi::ClassExt<QLocale> decl_QLocale_FormatType_Enums_as_child (decl_QLoca
namespace qt_gsi
{
static gsi::Enum<QLocale::Language> decl_QLocale_Language_Enum ("QLocale_Language",
static gsi::Enum<QLocale::Language> decl_QLocale_Language_Enum ("QtCore", "QLocale_Language",
gsi::enum_const ("C", QLocale::C, "@brief Enum constant QLocale::C") +
gsi::enum_const ("Abkhazian", QLocale::Abkhazian, "@brief Enum constant QLocale::Abkhazian") +
gsi::enum_const ("Afan", QLocale::Afan, "@brief Enum constant QLocale::Afan") +
@ -1814,13 +1814,13 @@ static gsi::Enum<QLocale::Language> decl_QLocale_Language_Enum ("QLocale_Languag
gsi::enum_const ("LastLanguage", QLocale::LastLanguage, "@brief Enum constant QLocale::LastLanguage"),
"@qt\n@brief This class represents the QLocale::Language enum");
static gsi::QFlagsClass<QLocale::Language > decl_QLocale_Language_Enums ("QLocale_QFlags_Language",
static gsi::QFlagsClass<QLocale::Language > decl_QLocale_Language_Enums ("QtCore", "QLocale_QFlags_Language",
"@qt\n@brief This class represents the QFlags<QLocale::Language> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QLocale> inject_QLocale_Language_Enum_in_parent (decl_QLocale_Language_Enum.defs ());
static gsi::ClassExt<QLocale> decl_QLocale_Language_Enum_as_child (decl_QLocale_Language_Enum, "Language");
static gsi::ClassExt<QLocale> decl_QLocale_Language_Enums_as_child (decl_QLocale_Language_Enums, "QFlags_Language");
static gsi::ClassExt<QLocale> decl_QLocale_Language_Enum_as_child (decl_QLocale_Language_Enum, "QtCore", "Language");
static gsi::ClassExt<QLocale> decl_QLocale_Language_Enums_as_child (decl_QLocale_Language_Enums, "QtCore", "QFlags_Language");
}
@ -1829,18 +1829,18 @@ static gsi::ClassExt<QLocale> decl_QLocale_Language_Enums_as_child (decl_QLocale
namespace qt_gsi
{
static gsi::Enum<QLocale::MeasurementSystem> decl_QLocale_MeasurementSystem_Enum ("QLocale_MeasurementSystem",
static gsi::Enum<QLocale::MeasurementSystem> decl_QLocale_MeasurementSystem_Enum ("QtCore", "QLocale_MeasurementSystem",
gsi::enum_const ("MetricSystem", QLocale::MetricSystem, "@brief Enum constant QLocale::MetricSystem") +
gsi::enum_const ("ImperialSystem", QLocale::ImperialSystem, "@brief Enum constant QLocale::ImperialSystem"),
"@qt\n@brief This class represents the QLocale::MeasurementSystem enum");
static gsi::QFlagsClass<QLocale::MeasurementSystem > decl_QLocale_MeasurementSystem_Enums ("QLocale_QFlags_MeasurementSystem",
static gsi::QFlagsClass<QLocale::MeasurementSystem > decl_QLocale_MeasurementSystem_Enums ("QtCore", "QLocale_QFlags_MeasurementSystem",
"@qt\n@brief This class represents the QFlags<QLocale::MeasurementSystem> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QLocale> inject_QLocale_MeasurementSystem_Enum_in_parent (decl_QLocale_MeasurementSystem_Enum.defs ());
static gsi::ClassExt<QLocale> decl_QLocale_MeasurementSystem_Enum_as_child (decl_QLocale_MeasurementSystem_Enum, "MeasurementSystem");
static gsi::ClassExt<QLocale> decl_QLocale_MeasurementSystem_Enums_as_child (decl_QLocale_MeasurementSystem_Enums, "QFlags_MeasurementSystem");
static gsi::ClassExt<QLocale> decl_QLocale_MeasurementSystem_Enum_as_child (decl_QLocale_MeasurementSystem_Enum, "QtCore", "MeasurementSystem");
static gsi::ClassExt<QLocale> decl_QLocale_MeasurementSystem_Enums_as_child (decl_QLocale_MeasurementSystem_Enums, "QtCore", "QFlags_MeasurementSystem");
}
@ -1849,18 +1849,18 @@ static gsi::ClassExt<QLocale> decl_QLocale_MeasurementSystem_Enums_as_child (dec
namespace qt_gsi
{
static gsi::Enum<QLocale::NumberOption> decl_QLocale_NumberOption_Enum ("QLocale_NumberOption",
static gsi::Enum<QLocale::NumberOption> decl_QLocale_NumberOption_Enum ("QtCore", "QLocale_NumberOption",
gsi::enum_const ("OmitGroupSeparator", QLocale::OmitGroupSeparator, "@brief Enum constant QLocale::OmitGroupSeparator") +
gsi::enum_const ("RejectGroupSeparator", QLocale::RejectGroupSeparator, "@brief Enum constant QLocale::RejectGroupSeparator"),
"@qt\n@brief This class represents the QLocale::NumberOption enum");
static gsi::QFlagsClass<QLocale::NumberOption > decl_QLocale_NumberOption_Enums ("QLocale_QFlags_NumberOption",
static gsi::QFlagsClass<QLocale::NumberOption > decl_QLocale_NumberOption_Enums ("QtCore", "QLocale_QFlags_NumberOption",
"@qt\n@brief This class represents the QFlags<QLocale::NumberOption> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QLocale> inject_QLocale_NumberOption_Enum_in_parent (decl_QLocale_NumberOption_Enum.defs ());
static gsi::ClassExt<QLocale> decl_QLocale_NumberOption_Enum_as_child (decl_QLocale_NumberOption_Enum, "NumberOption");
static gsi::ClassExt<QLocale> decl_QLocale_NumberOption_Enums_as_child (decl_QLocale_NumberOption_Enums, "QFlags_NumberOption");
static gsi::ClassExt<QLocale> decl_QLocale_NumberOption_Enum_as_child (decl_QLocale_NumberOption_Enum, "QtCore", "NumberOption");
static gsi::ClassExt<QLocale> decl_QLocale_NumberOption_Enums_as_child (decl_QLocale_NumberOption_Enums, "QtCore", "QFlags_NumberOption");
}

8
src/gsiqt4/gsiDeclQMargins.cc → src/gsiqt/qt4/QtCore/gsiDeclQMargins.cc
View File

@ -29,8 +29,8 @@
#include <QMargins>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -266,12 +266,12 @@ static gsi::Methods methods_QMargins () {
return methods;
}
gsi::Class<QMargins> decl_QMargins ("QMargins",
gsi::Class<QMargins> decl_QMargins ("QtCore", "QMargins",
methods_QMargins (),
"@qt\n@brief Binding of QMargins");
GSIQT_PUBLIC gsi::Class<QMargins> &qtdecl_QMargins () { return decl_QMargins; }
GSI_QTCORE_PUBLIC gsi::Class<QMargins> &qtdecl_QMargins () { return decl_QMargins; }
}

8
src/gsiqt4/gsiDeclQMetaClassInfo.cc → src/gsiqt/qt4/QtCore/gsiDeclQMetaClassInfo.cc
View File

@ -30,8 +30,8 @@
#include <QMetaClassInfo>
#include <QMetaObject>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -110,12 +110,12 @@ static gsi::Methods methods_QMetaClassInfo () {
return methods;
}
gsi::Class<QMetaClassInfo> decl_QMetaClassInfo ("QMetaClassInfo",
gsi::Class<QMetaClassInfo> decl_QMetaClassInfo ("QtCore", "QMetaClassInfo",
methods_QMetaClassInfo (),
"@qt\n@brief Binding of QMetaClassInfo");
GSIQT_PUBLIC gsi::Class<QMetaClassInfo> &qtdecl_QMetaClassInfo () { return decl_QMetaClassInfo; }
GSI_QTCORE_PUBLIC gsi::Class<QMetaClassInfo> &qtdecl_QMetaClassInfo () { return decl_QMetaClassInfo; }
}

8
src/gsiqt4/gsiDeclQMetaEnum.cc → src/gsiqt/qt4/QtCore/gsiDeclQMetaEnum.cc
View File

@ -30,8 +30,8 @@
#include <QMetaEnum>
#include <QMetaObject>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -278,12 +278,12 @@ static gsi::Methods methods_QMetaEnum () {
return methods;
}
gsi::Class<QMetaEnum> decl_QMetaEnum ("QMetaEnum",
gsi::Class<QMetaEnum> decl_QMetaEnum ("QtCore", "QMetaEnum",
methods_QMetaEnum (),
"@qt\n@brief Binding of QMetaEnum");
GSIQT_PUBLIC gsi::Class<QMetaEnum> &qtdecl_QMetaEnum () { return decl_QMetaEnum; }
GSI_QTCORE_PUBLIC gsi::Class<QMetaEnum> &qtdecl_QMetaEnum () { return decl_QMetaEnum; }
}

24
src/gsiqt4/gsiDeclQMetaMethod.cc → src/gsiqt/qt4/QtCore/gsiDeclQMetaMethod.cc
View File

@ -30,8 +30,8 @@
#include <QMetaMethod>
#include <QMetaObject>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -222,12 +222,12 @@ static gsi::Methods methods_QMetaMethod () {
return methods;
}
gsi::Class<QMetaMethod> decl_QMetaMethod ("QMetaMethod",
gsi::Class<QMetaMethod> decl_QMetaMethod ("QtCore", "QMetaMethod",
methods_QMetaMethod (),
"@qt\n@brief Binding of QMetaMethod");
GSIQT_PUBLIC gsi::Class<QMetaMethod> &qtdecl_QMetaMethod () { return decl_QMetaMethod; }
GSI_QTCORE_PUBLIC gsi::Class<QMetaMethod> &qtdecl_QMetaMethod () { return decl_QMetaMethod; }
}
@ -236,19 +236,19 @@ GSIQT_PUBLIC gsi::Class<QMetaMethod> &qtdecl_QMetaMethod () { return decl_QMetaM
namespace qt_gsi
{
static gsi::Enum<QMetaMethod::Access> decl_QMetaMethod_Access_Enum ("QMetaMethod_Access",
static gsi::Enum<QMetaMethod::Access> decl_QMetaMethod_Access_Enum ("QtCore", "QMetaMethod_Access",
gsi::enum_const ("Private", QMetaMethod::Private, "@brief Enum constant QMetaMethod::Private") +
gsi::enum_const ("Protected", QMetaMethod::Protected, "@brief Enum constant QMetaMethod::Protected") +
gsi::enum_const ("Public", QMetaMethod::Public, "@brief Enum constant QMetaMethod::Public"),
"@qt\n@brief This class represents the QMetaMethod::Access enum");
static gsi::QFlagsClass<QMetaMethod::Access > decl_QMetaMethod_Access_Enums ("QMetaMethod_QFlags_Access",
static gsi::QFlagsClass<QMetaMethod::Access > decl_QMetaMethod_Access_Enums ("QtCore", "QMetaMethod_QFlags_Access",
"@qt\n@brief This class represents the QFlags<QMetaMethod::Access> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QMetaMethod> inject_QMetaMethod_Access_Enum_in_parent (decl_QMetaMethod_Access_Enum.defs ());
static gsi::ClassExt<QMetaMethod> decl_QMetaMethod_Access_Enum_as_child (decl_QMetaMethod_Access_Enum, "Access");
static gsi::ClassExt<QMetaMethod> decl_QMetaMethod_Access_Enums_as_child (decl_QMetaMethod_Access_Enums, "QFlags_Access");
static gsi::ClassExt<QMetaMethod> decl_QMetaMethod_Access_Enum_as_child (decl_QMetaMethod_Access_Enum, "QtCore", "Access");
static gsi::ClassExt<QMetaMethod> decl_QMetaMethod_Access_Enums_as_child (decl_QMetaMethod_Access_Enums, "QtCore", "QFlags_Access");
}
@ -257,20 +257,20 @@ static gsi::ClassExt<QMetaMethod> decl_QMetaMethod_Access_Enums_as_child (decl_Q
namespace qt_gsi
{
static gsi::Enum<QMetaMethod::MethodType> decl_QMetaMethod_MethodType_Enum ("QMetaMethod_MethodType",
static gsi::Enum<QMetaMethod::MethodType> decl_QMetaMethod_MethodType_Enum ("QtCore", "QMetaMethod_MethodType",
gsi::enum_const ("Method", QMetaMethod::Method, "@brief Enum constant QMetaMethod::Method") +
gsi::enum_const ("Signal", QMetaMethod::Signal, "@brief Enum constant QMetaMethod::Signal") +
gsi::enum_const ("Slot", QMetaMethod::Slot, "@brief Enum constant QMetaMethod::Slot") +
gsi::enum_const ("Constructor", QMetaMethod::Constructor, "@brief Enum constant QMetaMethod::Constructor"),
"@qt\n@brief This class represents the QMetaMethod::MethodType enum");
static gsi::QFlagsClass<QMetaMethod::MethodType > decl_QMetaMethod_MethodType_Enums ("QMetaMethod_QFlags_MethodType",
static gsi::QFlagsClass<QMetaMethod::MethodType > decl_QMetaMethod_MethodType_Enums ("QtCore", "QMetaMethod_QFlags_MethodType",
"@qt\n@brief This class represents the QFlags<QMetaMethod::MethodType> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QMetaMethod> inject_QMetaMethod_MethodType_Enum_in_parent (decl_QMetaMethod_MethodType_Enum.defs ());
static gsi::ClassExt<QMetaMethod> decl_QMetaMethod_MethodType_Enum_as_child (decl_QMetaMethod_MethodType_Enum, "MethodType");
static gsi::ClassExt<QMetaMethod> decl_QMetaMethod_MethodType_Enums_as_child (decl_QMetaMethod_MethodType_Enums, "QFlags_MethodType");
static gsi::ClassExt<QMetaMethod> decl_QMetaMethod_MethodType_Enum_as_child (decl_QMetaMethod_MethodType_Enum, "QtCore", "MethodType");
static gsi::ClassExt<QMetaMethod> decl_QMetaMethod_MethodType_Enums_as_child (decl_QMetaMethod_MethodType_Enums, "QtCore", "QFlags_MethodType");
}

8
src/gsiqt4/gsiDeclQMetaObject.cc → src/gsiqt/qt4/QtCore/gsiDeclQMetaObject.cc
View File

@ -34,8 +34,8 @@
#include <QMetaProperty>
#include <QObject>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -793,12 +793,12 @@ static gsi::Methods methods_QMetaObject () {
return methods;
}
gsi::Class<QMetaObject> decl_QMetaObject ("QMetaObject",
gsi::Class<QMetaObject> decl_QMetaObject ("QtCore", "QMetaObject",
methods_QMetaObject (),
"@qt\n@brief Binding of QMetaObject");
GSIQT_PUBLIC gsi::Class<QMetaObject> &qtdecl_QMetaObject () { return decl_QMetaObject; }
GSI_QTCORE_PUBLIC gsi::Class<QMetaObject> &qtdecl_QMetaObject () { return decl_QMetaObject; }
}

8
src/gsiqt4/gsiDeclQMetaProperty.cc → src/gsiqt/qt4/QtCore/gsiDeclQMetaProperty.cc
View File

@ -33,8 +33,8 @@
#include <QMetaObject>
#include <QObject>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -532,12 +532,12 @@ static gsi::Methods methods_QMetaProperty () {
return methods;
}
gsi::Class<QMetaProperty> decl_QMetaProperty ("QMetaProperty",
gsi::Class<QMetaProperty> decl_QMetaProperty ("QtCore", "QMetaProperty",
methods_QMetaProperty (),
"@qt\n@brief Binding of QMetaProperty");
GSIQT_PUBLIC gsi::Class<QMetaProperty> &qtdecl_QMetaProperty () { return decl_QMetaProperty; }
GSI_QTCORE_PUBLIC gsi::Class<QMetaProperty> &qtdecl_QMetaProperty () { return decl_QMetaProperty; }
}

8
src/gsiqt4/gsiDeclQMetaType.cc → src/gsiqt/qt4/QtCore/gsiDeclQMetaType.cc
View File

@ -30,8 +30,8 @@
#include <QMetaType>
#include <QDataStream>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -242,12 +242,12 @@ static gsi::Methods methods_QMetaType () {
return methods;
}
gsi::Class<QMetaType> decl_QMetaType ("QMetaType",
gsi::Class<QMetaType> decl_QMetaType ("QtCore", "QMetaType",
methods_QMetaType (),
"@qt\n@brief Binding of QMetaType");
GSIQT_PUBLIC gsi::Class<QMetaType> &qtdecl_QMetaType () { return decl_QMetaType; }
GSI_QTCORE_PUBLIC gsi::Class<QMetaType> &qtdecl_QMetaType () { return decl_QMetaType; }
}

10
src/gsiqt4/gsiDeclQMimeData.cc → src/gsiqt/qt4/QtCore/gsiDeclQMimeData.cc
View File

@ -35,8 +35,8 @@
#include <QTimerEvent>
#include <QUrl>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -548,11 +548,11 @@ static gsi::Methods methods_QMimeData () {
gsi::Class<QObject> &qtdecl_QObject ();
qt_gsi::QtNativeClass<QMimeData> decl_QMimeData (qtdecl_QObject (), "QMimeData_Native",
qt_gsi::QtNativeClass<QMimeData> decl_QMimeData (qtdecl_QObject (), "QtCore", "QMimeData_Native",
methods_QMimeData (),
"@hide\n@alias QMimeData");
GSIQT_PUBLIC gsi::Class<QMimeData> &qtdecl_QMimeData () { return decl_QMimeData; }
GSI_QTCORE_PUBLIC gsi::Class<QMimeData> &qtdecl_QMimeData () { return decl_QMimeData; }
}
@ -1042,7 +1042,7 @@ static gsi::Methods methods_QMimeData_Adaptor () {
return methods;
}
gsi::Class<QMimeData_Adaptor> decl_QMimeData_Adaptor (qtdecl_QMimeData (), "QMimeData",
gsi::Class<QMimeData_Adaptor> decl_QMimeData_Adaptor (qtdecl_QMimeData (), "QtCore", "QMimeData",
methods_QMimeData_Adaptor (),
"@qt\n@brief Binding of QMimeData");

8
src/gsiqt4/gsiDeclQModelIndex.cc → src/gsiqt/qt4/QtCore/gsiDeclQModelIndex.cc
View File

@ -30,8 +30,8 @@
#include <QModelIndex>
#include <QAbstractItemModel>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -336,12 +336,12 @@ static gsi::Methods methods_QModelIndex () {
return methods;
}
gsi::Class<QModelIndex> decl_QModelIndex ("QModelIndex",
gsi::Class<QModelIndex> decl_QModelIndex ("QtCore", "QModelIndex",
methods_QModelIndex (),
"@qt\n@brief Binding of QModelIndex");
GSIQT_PUBLIC gsi::Class<QModelIndex> &qtdecl_QModelIndex () { return decl_QModelIndex; }
GSI_QTCORE_PUBLIC gsi::Class<QModelIndex> &qtdecl_QModelIndex () { return decl_QModelIndex; }
}

16
src/gsiqt4/gsiDeclQMutex.cc → src/gsiqt/qt4/QtCore/gsiDeclQMutex.cc
View File

@ -29,8 +29,8 @@
#include <QMutex>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -135,12 +135,12 @@ static gsi::Methods methods_QMutex () {
return methods;
}
gsi::Class<QMutex> decl_QMutex ("QMutex",
gsi::Class<QMutex> decl_QMutex ("QtCore", "QMutex",
methods_QMutex (),
"@qt\n@brief Binding of QMutex");
GSIQT_PUBLIC gsi::Class<QMutex> &qtdecl_QMutex () { return decl_QMutex; }
GSI_QTCORE_PUBLIC gsi::Class<QMutex> &qtdecl_QMutex () { return decl_QMutex; }
}
@ -149,18 +149,18 @@ GSIQT_PUBLIC gsi::Class<QMutex> &qtdecl_QMutex () { return decl_QMutex; }
namespace qt_gsi
{
static gsi::Enum<QMutex::RecursionMode> decl_QMutex_RecursionMode_Enum ("QMutex_RecursionMode",
static gsi::Enum<QMutex::RecursionMode> decl_QMutex_RecursionMode_Enum ("QtCore", "QMutex_RecursionMode",
gsi::enum_const ("NonRecursive", QMutex::NonRecursive, "@brief Enum constant QMutex::NonRecursive") +
gsi::enum_const ("Recursive", QMutex::Recursive, "@brief Enum constant QMutex::Recursive"),
"@qt\n@brief This class represents the QMutex::RecursionMode enum");
static gsi::QFlagsClass<QMutex::RecursionMode > decl_QMutex_RecursionMode_Enums ("QMutex_QFlags_RecursionMode",
static gsi::QFlagsClass<QMutex::RecursionMode > decl_QMutex_RecursionMode_Enums ("QtCore", "QMutex_QFlags_RecursionMode",
"@qt\n@brief This class represents the QFlags<QMutex::RecursionMode> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QMutex> inject_QMutex_RecursionMode_Enum_in_parent (decl_QMutex_RecursionMode_Enum.defs ());
static gsi::ClassExt<QMutex> decl_QMutex_RecursionMode_Enum_as_child (decl_QMutex_RecursionMode_Enum, "RecursionMode");
static gsi::ClassExt<QMutex> decl_QMutex_RecursionMode_Enums_as_child (decl_QMutex_RecursionMode_Enums, "QFlags_RecursionMode");
static gsi::ClassExt<QMutex> decl_QMutex_RecursionMode_Enum_as_child (decl_QMutex_RecursionMode_Enum, "QtCore", "RecursionMode");
static gsi::ClassExt<QMutex> decl_QMutex_RecursionMode_Enums_as_child (decl_QMutex_RecursionMode_Enums, "QtCore", "QFlags_RecursionMode");
}

10
src/gsiqt4/gsiDeclQObject.cc → src/gsiqt/qt4/QtCore/gsiDeclQObject.cc
View File

@ -33,8 +33,8 @@
#include <QThread>
#include <QTimerEvent>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -751,13 +751,13 @@ static gsi::Methods methods_QObject () {
return methods;
}
qt_gsi::QtNativeClass<QObject> decl_QObject ("QObject_Native",
qt_gsi::QtNativeClass<QObject> decl_QObject ("QtCore", "QObject_Native",
gsi::method_ext("findChild", &find_child_impl, "@brief Specialisation for findChild (uses QObject as T).")
+
methods_QObject (),
"@hide\n@alias QObject");
GSIQT_PUBLIC gsi::Class<QObject> &qtdecl_QObject () { return decl_QObject; }
GSI_QTCORE_PUBLIC gsi::Class<QObject> &qtdecl_QObject () { return decl_QObject; }
}
@ -1135,7 +1135,7 @@ static gsi::Methods methods_QObject_Adaptor () {
return methods;
}
gsi::Class<QObject_Adaptor> decl_QObject_Adaptor (qtdecl_QObject (), "QObject",
gsi::Class<QObject_Adaptor> decl_QObject_Adaptor (qtdecl_QObject (), "QtCore", "QObject",
methods_QObject_Adaptor (),
"@qt\n@brief Binding of QObject");

8
src/gsiqt4/gsiDeclQPersistentModelIndex.cc → src/gsiqt/qt4/QtCore/gsiDeclQPersistentModelIndex.cc
View File

@ -31,8 +31,8 @@
#include <QAbstractItemModel>
#include <QModelIndex>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -441,14 +441,14 @@ static gsi::Methods methods_QPersistentModelIndex () {
return methods;
}
gsi::Class<QPersistentModelIndex> decl_QPersistentModelIndex ("QPersistentModelIndex",
gsi::Class<QPersistentModelIndex> decl_QPersistentModelIndex ("QtCore", "QPersistentModelIndex",
gsi::method_ext("castToQModelIndex", &castToQModelIndex, "@brief Binding for \"operator const QModelIndex &\".")
+
methods_QPersistentModelIndex (),
"@qt\n@brief Binding of QPersistentModelIndex");
GSIQT_PUBLIC gsi::Class<QPersistentModelIndex> &qtdecl_QPersistentModelIndex () { return decl_QPersistentModelIndex; }
GSI_QTCORE_PUBLIC gsi::Class<QPersistentModelIndex> &qtdecl_QPersistentModelIndex () { return decl_QPersistentModelIndex; }
}

10
src/gsiqt4/gsiDeclQPluginLoader.cc → src/gsiqt/qt4/QtCore/gsiDeclQPluginLoader.cc
View File

@ -34,8 +34,8 @@
#include <QThread>
#include <QTimerEvent>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -334,11 +334,11 @@ static gsi::Methods methods_QPluginLoader () {
gsi::Class<QObject> &qtdecl_QObject ();
qt_gsi::QtNativeClass<QPluginLoader> decl_QPluginLoader (qtdecl_QObject (), "QPluginLoader_Native",
qt_gsi::QtNativeClass<QPluginLoader> decl_QPluginLoader (qtdecl_QObject (), "QtCore", "QPluginLoader_Native",
methods_QPluginLoader (),
"@hide\n@alias QPluginLoader");
GSIQT_PUBLIC gsi::Class<QPluginLoader> &qtdecl_QPluginLoader () { return decl_QPluginLoader; }
GSI_QTCORE_PUBLIC gsi::Class<QPluginLoader> &qtdecl_QPluginLoader () { return decl_QPluginLoader; }
}
@ -750,7 +750,7 @@ static gsi::Methods methods_QPluginLoader_Adaptor () {
return methods;
}
gsi::Class<QPluginLoader_Adaptor> decl_QPluginLoader_Adaptor (qtdecl_QPluginLoader (), "QPluginLoader",
gsi::Class<QPluginLoader_Adaptor> decl_QPluginLoader_Adaptor (qtdecl_QPluginLoader (), "QtCore", "QPluginLoader",
methods_QPluginLoader_Adaptor (),
"@qt\n@brief Binding of QPluginLoader");

26
src/gsiqt4/gsiDeclQPoint.cc → src/gsiqt/qt4/QtCore/gsiDeclQPoint.cc
View File

@ -31,8 +31,8 @@
#include <QMatrix>
#include <QMatrix4x4>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -316,21 +316,6 @@ static const QPoint op_QPoint_operator_slash__2777(const QPoint *_self, qreal c)
return ::operator/(*_self, c);
}
// QPoint ::operator*(const QPoint &p, const QMatrix &m)
static QPoint op_QPoint_operator_star__3831(const QPoint *_self, const QMatrix &m) {
return ::operator*(*_self, m);
}
// QPoint ::operator*(const QPoint &p, const QTransform &m)
static QPoint op_QPoint_operator_star__4158(const QPoint *_self, const QTransform &m) {
return ::operator*(*_self, m);
}
// QPoint ::operator*(const QPoint &point, const QMatrix4x4 &matrix)
static QPoint op_QPoint_operator_star__4055u1(const QPoint *_self, const QMatrix4x4 &matrix) {
return ::operator*(*_self, matrix);
}
namespace gsi
{
@ -358,18 +343,15 @@ static gsi::Methods methods_QPoint () {
methods += gsi::method_ext("*", &::op_QPoint_operator_star__2777, gsi::arg ("c"), "@brief Operator const QPoint ::operator*(const QPoint &p, qreal c)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("-", &::op_QPoint_operator_minus__1916, "@brief Operator const QPoint ::operator-(const QPoint &p)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("/", &::op_QPoint_operator_slash__2777, gsi::arg ("c"), "@brief Operator const QPoint ::operator/(const QPoint &p, qreal c)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("*", &::op_QPoint_operator_star__3831, gsi::arg ("m"), "@brief Operator QPoint ::operator*(const QPoint &p, const QMatrix &m)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("*", &::op_QPoint_operator_star__4158, gsi::arg ("m"), "@brief Operator QPoint ::operator*(const QPoint &p, const QTransform &m)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("*", &::op_QPoint_operator_star__4055u1, gsi::arg ("matrix"), "@brief Operator QPoint ::operator*(const QPoint &point, const QMatrix4x4 &matrix)\nThis is the mapping of the global operator to the instance method.");
return methods;
}
gsi::Class<QPoint> decl_QPoint ("QPoint",
gsi::Class<QPoint> decl_QPoint ("QtCore", "QPoint",
methods_QPoint (),
"@qt\n@brief Binding of QPoint");
GSIQT_PUBLIC gsi::Class<QPoint> &qtdecl_QPoint () { return decl_QPoint; }
GSI_QTCORE_PUBLIC gsi::Class<QPoint> &qtdecl_QPoint () { return decl_QPoint; }
}

26
src/gsiqt4/gsiDeclQPointF.cc → src/gsiqt/qt4/QtCore/gsiDeclQPointF.cc
View File

@ -31,8 +31,8 @@
#include <QMatrix>
#include <QMatrix4x4>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -350,21 +350,6 @@ static const QPointF op_QPointF_operator_slash__2847(const QPointF *_self, qreal
return ::operator/(*_self, c);
}
// QPointF ::operator*(const QPointF &p, const QMatrix &m)
static QPointF op_QPointF_operator_star__3901(const QPointF *_self, const QMatrix &m) {
return ::operator*(*_self, m);
}
// QPointF ::operator*(const QPointF &p, const QTransform &m)
static QPointF op_QPointF_operator_star__4228(const QPointF *_self, const QTransform &m) {
return ::operator*(*_self, m);
}
// QPointF ::operator*(const QPointF &point, const QMatrix4x4 &matrix)
static QPointF op_QPointF_operator_star__4125u1(const QPointF *_self, const QMatrix4x4 &matrix) {
return ::operator*(*_self, matrix);
}
namespace gsi
{
@ -394,18 +379,15 @@ static gsi::Methods methods_QPointF () {
methods += gsi::method_ext("*", &::op_QPointF_operator_star__2847, gsi::arg ("c"), "@brief Operator const QPointF ::operator*(const QPointF &p, qreal c)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("-", &::op_QPointF_operator_minus__1986, "@brief Operator const QPointF ::operator-(const QPointF &p)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("/", &::op_QPointF_operator_slash__2847, gsi::arg ("c"), "@brief Operator const QPointF ::operator/(const QPointF &p, qreal c)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("*", &::op_QPointF_operator_star__3901, gsi::arg ("m"), "@brief Operator QPointF ::operator*(const QPointF &p, const QMatrix &m)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("*", &::op_QPointF_operator_star__4228, gsi::arg ("m"), "@brief Operator QPointF ::operator*(const QPointF &p, const QTransform &m)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("*", &::op_QPointF_operator_star__4125u1, gsi::arg ("matrix"), "@brief Operator QPointF ::operator*(const QPointF &point, const QMatrix4x4 &matrix)\nThis is the mapping of the global operator to the instance method.");
return methods;
}
gsi::Class<QPointF> decl_QPointF ("QPointF",
gsi::Class<QPointF> decl_QPointF ("QtCore", "QPointF",
methods_QPointF (),
"@qt\n@brief Binding of QPointF");
GSIQT_PUBLIC gsi::Class<QPointF> &qtdecl_QPointF () { return decl_QPointF; }
GSI_QTCORE_PUBLIC gsi::Class<QPointF> &qtdecl_QPointF () { return decl_QPointF; }
}

48
src/gsiqt4/gsiDeclQProcess.cc → src/gsiqt/qt4/QtCore/gsiDeclQProcess.cc
View File

@ -35,8 +35,8 @@
#include <QThread>
#include <QTimerEvent>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -1052,12 +1052,12 @@ static gsi::Methods methods_QProcess () {
gsi::Class<QIODevice> &qtdecl_QIODevice ();
qt_gsi::QtNativeClass<QProcess> decl_QProcess (qtdecl_QIODevice (), "QProcess",
qt_gsi::QtNativeClass<QProcess> decl_QProcess (qtdecl_QIODevice (), "QtCore", "QProcess",
methods_QProcess (),
"@qt\n@brief Binding of QProcess");
GSIQT_PUBLIC gsi::Class<QProcess> &qtdecl_QProcess () { return decl_QProcess; }
GSI_QTCORE_PUBLIC gsi::Class<QProcess> &qtdecl_QProcess () { return decl_QProcess; }
}
@ -1066,18 +1066,18 @@ GSIQT_PUBLIC gsi::Class<QProcess> &qtdecl_QProcess () { return decl_QProcess; }
namespace qt_gsi
{
static gsi::Enum<QProcess::ExitStatus> decl_QProcess_ExitStatus_Enum ("QProcess_ExitStatus",
static gsi::Enum<QProcess::ExitStatus> decl_QProcess_ExitStatus_Enum ("QtCore", "QProcess_ExitStatus",
gsi::enum_const ("NormalExit", QProcess::NormalExit, "@brief Enum constant QProcess::NormalExit") +
gsi::enum_const ("CrashExit", QProcess::CrashExit, "@brief Enum constant QProcess::CrashExit"),
"@qt\n@brief This class represents the QProcess::ExitStatus enum");
static gsi::QFlagsClass<QProcess::ExitStatus > decl_QProcess_ExitStatus_Enums ("QProcess_QFlags_ExitStatus",
static gsi::QFlagsClass<QProcess::ExitStatus > decl_QProcess_ExitStatus_Enums ("QtCore", "QProcess_QFlags_ExitStatus",
"@qt\n@brief This class represents the QFlags<QProcess::ExitStatus> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QProcess> inject_QProcess_ExitStatus_Enum_in_parent (decl_QProcess_ExitStatus_Enum.defs ());
static gsi::ClassExt<QProcess> decl_QProcess_ExitStatus_Enum_as_child (decl_QProcess_ExitStatus_Enum, "ExitStatus");
static gsi::ClassExt<QProcess> decl_QProcess_ExitStatus_Enums_as_child (decl_QProcess_ExitStatus_Enums, "QFlags_ExitStatus");
static gsi::ClassExt<QProcess> decl_QProcess_ExitStatus_Enum_as_child (decl_QProcess_ExitStatus_Enum, "QtCore", "ExitStatus");
static gsi::ClassExt<QProcess> decl_QProcess_ExitStatus_Enums_as_child (decl_QProcess_ExitStatus_Enums, "QtCore", "QFlags_ExitStatus");
}
@ -1086,18 +1086,18 @@ static gsi::ClassExt<QProcess> decl_QProcess_ExitStatus_Enums_as_child (decl_QPr
namespace qt_gsi
{
static gsi::Enum<QProcess::ProcessChannel> decl_QProcess_ProcessChannel_Enum ("QProcess_ProcessChannel",
static gsi::Enum<QProcess::ProcessChannel> decl_QProcess_ProcessChannel_Enum ("QtCore", "QProcess_ProcessChannel",
gsi::enum_const ("StandardOutput", QProcess::StandardOutput, "@brief Enum constant QProcess::StandardOutput") +
gsi::enum_const ("StandardError", QProcess::StandardError, "@brief Enum constant QProcess::StandardError"),
"@qt\n@brief This class represents the QProcess::ProcessChannel enum");
static gsi::QFlagsClass<QProcess::ProcessChannel > decl_QProcess_ProcessChannel_Enums ("QProcess_QFlags_ProcessChannel",
static gsi::QFlagsClass<QProcess::ProcessChannel > decl_QProcess_ProcessChannel_Enums ("QtCore", "QProcess_QFlags_ProcessChannel",
"@qt\n@brief This class represents the QFlags<QProcess::ProcessChannel> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QProcess> inject_QProcess_ProcessChannel_Enum_in_parent (decl_QProcess_ProcessChannel_Enum.defs ());
static gsi::ClassExt<QProcess> decl_QProcess_ProcessChannel_Enum_as_child (decl_QProcess_ProcessChannel_Enum, "ProcessChannel");
static gsi::ClassExt<QProcess> decl_QProcess_ProcessChannel_Enums_as_child (decl_QProcess_ProcessChannel_Enums, "QFlags_ProcessChannel");
static gsi::ClassExt<QProcess> decl_QProcess_ProcessChannel_Enum_as_child (decl_QProcess_ProcessChannel_Enum, "QtCore", "ProcessChannel");
static gsi::ClassExt<QProcess> decl_QProcess_ProcessChannel_Enums_as_child (decl_QProcess_ProcessChannel_Enums, "QtCore", "QFlags_ProcessChannel");
}
@ -1106,19 +1106,19 @@ static gsi::ClassExt<QProcess> decl_QProcess_ProcessChannel_Enums_as_child (decl
namespace qt_gsi
{
static gsi::Enum<QProcess::ProcessChannelMode> decl_QProcess_ProcessChannelMode_Enum ("QProcess_ProcessChannelMode",
static gsi::Enum<QProcess::ProcessChannelMode> decl_QProcess_ProcessChannelMode_Enum ("QtCore", "QProcess_ProcessChannelMode",
gsi::enum_const ("SeparateChannels", QProcess::SeparateChannels, "@brief Enum constant QProcess::SeparateChannels") +
gsi::enum_const ("MergedChannels", QProcess::MergedChannels, "@brief Enum constant QProcess::MergedChannels") +
gsi::enum_const ("ForwardedChannels", QProcess::ForwardedChannels, "@brief Enum constant QProcess::ForwardedChannels"),
"@qt\n@brief This class represents the QProcess::ProcessChannelMode enum");
static gsi::QFlagsClass<QProcess::ProcessChannelMode > decl_QProcess_ProcessChannelMode_Enums ("QProcess_QFlags_ProcessChannelMode",
static gsi::QFlagsClass<QProcess::ProcessChannelMode > decl_QProcess_ProcessChannelMode_Enums ("QtCore", "QProcess_QFlags_ProcessChannelMode",
"@qt\n@brief This class represents the QFlags<QProcess::ProcessChannelMode> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QProcess> inject_QProcess_ProcessChannelMode_Enum_in_parent (decl_QProcess_ProcessChannelMode_Enum.defs ());
static gsi::ClassExt<QProcess> decl_QProcess_ProcessChannelMode_Enum_as_child (decl_QProcess_ProcessChannelMode_Enum, "ProcessChannelMode");
static gsi::ClassExt<QProcess> decl_QProcess_ProcessChannelMode_Enums_as_child (decl_QProcess_ProcessChannelMode_Enums, "QFlags_ProcessChannelMode");
static gsi::ClassExt<QProcess> decl_QProcess_ProcessChannelMode_Enum_as_child (decl_QProcess_ProcessChannelMode_Enum, "QtCore", "ProcessChannelMode");
static gsi::ClassExt<QProcess> decl_QProcess_ProcessChannelMode_Enums_as_child (decl_QProcess_ProcessChannelMode_Enums, "QtCore", "QFlags_ProcessChannelMode");
}
@ -1127,7 +1127,7 @@ static gsi::ClassExt<QProcess> decl_QProcess_ProcessChannelMode_Enums_as_child (
namespace qt_gsi
{
static gsi::Enum<QProcess::ProcessError> decl_QProcess_ProcessError_Enum ("QProcess_ProcessError",
static gsi::Enum<QProcess::ProcessError> decl_QProcess_ProcessError_Enum ("QtCore", "QProcess_ProcessError",
gsi::enum_const ("FailedToStart", QProcess::FailedToStart, "@brief Enum constant QProcess::FailedToStart") +
gsi::enum_const ("Crashed", QProcess::Crashed, "@brief Enum constant QProcess::Crashed") +
gsi::enum_const ("Timedout", QProcess::Timedout, "@brief Enum constant QProcess::Timedout") +
@ -1136,13 +1136,13 @@ static gsi::Enum<QProcess::ProcessError> decl_QProcess_ProcessError_Enum ("QProc
gsi::enum_const ("UnknownError", QProcess::UnknownError, "@brief Enum constant QProcess::UnknownError"),
"@qt\n@brief This class represents the QProcess::ProcessError enum");
static gsi::QFlagsClass<QProcess::ProcessError > decl_QProcess_ProcessError_Enums ("QProcess_QFlags_ProcessError",
static gsi::QFlagsClass<QProcess::ProcessError > decl_QProcess_ProcessError_Enums ("QtCore", "QProcess_QFlags_ProcessError",
"@qt\n@brief This class represents the QFlags<QProcess::ProcessError> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QProcess> inject_QProcess_ProcessError_Enum_in_parent (decl_QProcess_ProcessError_Enum.defs ());
static gsi::ClassExt<QProcess> decl_QProcess_ProcessError_Enum_as_child (decl_QProcess_ProcessError_Enum, "ProcessError");
static gsi::ClassExt<QProcess> decl_QProcess_ProcessError_Enums_as_child (decl_QProcess_ProcessError_Enums, "QFlags_ProcessError");
static gsi::ClassExt<QProcess> decl_QProcess_ProcessError_Enum_as_child (decl_QProcess_ProcessError_Enum, "QtCore", "ProcessError");
static gsi::ClassExt<QProcess> decl_QProcess_ProcessError_Enums_as_child (decl_QProcess_ProcessError_Enums, "QtCore", "QFlags_ProcessError");
}
@ -1151,19 +1151,19 @@ static gsi::ClassExt<QProcess> decl_QProcess_ProcessError_Enums_as_child (decl_Q
namespace qt_gsi
{
static gsi::Enum<QProcess::ProcessState> decl_QProcess_ProcessState_Enum ("QProcess_ProcessState",
static gsi::Enum<QProcess::ProcessState> decl_QProcess_ProcessState_Enum ("QtCore", "QProcess_ProcessState",
gsi::enum_const ("NotRunning", QProcess::NotRunning, "@brief Enum constant QProcess::NotRunning") +
gsi::enum_const ("Starting", QProcess::Starting, "@brief Enum constant QProcess::Starting") +
gsi::enum_const ("Running", QProcess::Running, "@brief Enum constant QProcess::Running"),
"@qt\n@brief This class represents the QProcess::ProcessState enum");
static gsi::QFlagsClass<QProcess::ProcessState > decl_QProcess_ProcessState_Enums ("QProcess_QFlags_ProcessState",
static gsi::QFlagsClass<QProcess::ProcessState > decl_QProcess_ProcessState_Enums ("QtCore", "QProcess_QFlags_ProcessState",
"@qt\n@brief This class represents the QFlags<QProcess::ProcessState> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QProcess> inject_QProcess_ProcessState_Enum_in_parent (decl_QProcess_ProcessState_Enum.defs ());
static gsi::ClassExt<QProcess> decl_QProcess_ProcessState_Enum_as_child (decl_QProcess_ProcessState_Enum, "ProcessState");
static gsi::ClassExt<QProcess> decl_QProcess_ProcessState_Enums_as_child (decl_QProcess_ProcessState_Enums, "QFlags_ProcessState");
static gsi::ClassExt<QProcess> decl_QProcess_ProcessState_Enum_as_child (decl_QProcess_ProcessState_Enum, "QtCore", "ProcessState");
static gsi::ClassExt<QProcess> decl_QProcess_ProcessState_Enums_as_child (decl_QProcess_ProcessState_Enums, "QtCore", "QFlags_ProcessState");
}

8
src/gsiqt4/gsiDeclQProcessEnvironment.cc → src/gsiqt/qt4/QtCore/gsiDeclQProcessEnvironment.cc
View File

@ -29,8 +29,8 @@
#include <QProcessEnvironment>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -294,12 +294,12 @@ static gsi::Methods methods_QProcessEnvironment () {
return methods;
}
gsi::Class<QProcessEnvironment> decl_QProcessEnvironment ("QProcessEnvironment",
gsi::Class<QProcessEnvironment> decl_QProcessEnvironment ("QtCore", "QProcessEnvironment",
methods_QProcessEnvironment (),
"@qt\n@brief Binding of QProcessEnvironment");
GSIQT_PUBLIC gsi::Class<QProcessEnvironment> &qtdecl_QProcessEnvironment () { return decl_QProcessEnvironment; }
GSI_QTCORE_PUBLIC gsi::Class<QProcessEnvironment> &qtdecl_QProcessEnvironment () { return decl_QProcessEnvironment; }
}

8
src/gsiqt4/gsiDeclQReadLocker.cc → src/gsiqt/qt4/QtCore/gsiDeclQReadLocker.cc
View File

@ -30,8 +30,8 @@
#include <QReadLocker>
#include <QReadWriteLock>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -116,12 +116,12 @@ static gsi::Methods methods_QReadLocker () {
return methods;
}
gsi::Class<QReadLocker> decl_QReadLocker ("QReadLocker",
gsi::Class<QReadLocker> decl_QReadLocker ("QtCore", "QReadLocker",
methods_QReadLocker (),
"@qt\n@brief Binding of QReadLocker");
GSIQT_PUBLIC gsi::Class<QReadLocker> &qtdecl_QReadLocker () { return decl_QReadLocker; }
GSI_QTCORE_PUBLIC gsi::Class<QReadLocker> &qtdecl_QReadLocker () { return decl_QReadLocker; }
}

16
src/gsiqt4/gsiDeclQReadWriteLock.cc → src/gsiqt/qt4/QtCore/gsiDeclQReadWriteLock.cc
View File

@ -29,8 +29,8 @@
#include <QReadWriteLock>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -204,12 +204,12 @@ static gsi::Methods methods_QReadWriteLock () {
return methods;
}
gsi::Class<QReadWriteLock> decl_QReadWriteLock ("QReadWriteLock",
gsi::Class<QReadWriteLock> decl_QReadWriteLock ("QtCore", "QReadWriteLock",
methods_QReadWriteLock (),
"@qt\n@brief Binding of QReadWriteLock");
GSIQT_PUBLIC gsi::Class<QReadWriteLock> &qtdecl_QReadWriteLock () { return decl_QReadWriteLock; }
GSI_QTCORE_PUBLIC gsi::Class<QReadWriteLock> &qtdecl_QReadWriteLock () { return decl_QReadWriteLock; }
}
@ -218,18 +218,18 @@ GSIQT_PUBLIC gsi::Class<QReadWriteLock> &qtdecl_QReadWriteLock () { return decl_
namespace qt_gsi
{
static gsi::Enum<QReadWriteLock::RecursionMode> decl_QReadWriteLock_RecursionMode_Enum ("QReadWriteLock_RecursionMode",
static gsi::Enum<QReadWriteLock::RecursionMode> decl_QReadWriteLock_RecursionMode_Enum ("QtCore", "QReadWriteLock_RecursionMode",
gsi::enum_const ("NonRecursive", QReadWriteLock::NonRecursive, "@brief Enum constant QReadWriteLock::NonRecursive") +
gsi::enum_const ("Recursive", QReadWriteLock::Recursive, "@brief Enum constant QReadWriteLock::Recursive"),
"@qt\n@brief This class represents the QReadWriteLock::RecursionMode enum");
static gsi::QFlagsClass<QReadWriteLock::RecursionMode > decl_QReadWriteLock_RecursionMode_Enums ("QReadWriteLock_QFlags_RecursionMode",
static gsi::QFlagsClass<QReadWriteLock::RecursionMode > decl_QReadWriteLock_RecursionMode_Enums ("QtCore", "QReadWriteLock_QFlags_RecursionMode",
"@qt\n@brief This class represents the QFlags<QReadWriteLock::RecursionMode> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QReadWriteLock> inject_QReadWriteLock_RecursionMode_Enum_in_parent (decl_QReadWriteLock_RecursionMode_Enum.defs ());
static gsi::ClassExt<QReadWriteLock> decl_QReadWriteLock_RecursionMode_Enum_as_child (decl_QReadWriteLock_RecursionMode_Enum, "RecursionMode");
static gsi::ClassExt<QReadWriteLock> decl_QReadWriteLock_RecursionMode_Enums_as_child (decl_QReadWriteLock_RecursionMode_Enums, "QFlags_RecursionMode");
static gsi::ClassExt<QReadWriteLock> decl_QReadWriteLock_RecursionMode_Enum_as_child (decl_QReadWriteLock_RecursionMode_Enum, "QtCore", "RecursionMode");
static gsi::ClassExt<QReadWriteLock> decl_QReadWriteLock_RecursionMode_Enums_as_child (decl_QReadWriteLock_RecursionMode_Enums, "QtCore", "QFlags_RecursionMode");
}

8
src/gsiqt4/gsiDeclQRect.cc → src/gsiqt/qt4/QtCore/gsiDeclQRect.cc
View File

@ -31,8 +31,8 @@
#include <QPoint>
#include <QSize>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -1487,12 +1487,12 @@ static gsi::Methods methods_QRect () {
return methods;
}
gsi::Class<QRect> decl_QRect ("QRect",
gsi::Class<QRect> decl_QRect ("QtCore", "QRect",
methods_QRect (),
"@qt\n@brief Binding of QRect");
GSIQT_PUBLIC gsi::Class<QRect> &qtdecl_QRect () { return decl_QRect; }
GSI_QTCORE_PUBLIC gsi::Class<QRect> &qtdecl_QRect () { return decl_QRect; }
}

8
src/gsiqt4/gsiDeclQRectF.cc → src/gsiqt/qt4/QtCore/gsiDeclQRectF.cc
View File

@ -32,8 +32,8 @@
#include <QRect>
#include <QSizeF>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -1508,12 +1508,12 @@ static gsi::Methods methods_QRectF () {
return methods;
}
gsi::Class<QRectF> decl_QRectF ("QRectF",
gsi::Class<QRectF> decl_QRectF ("QtCore", "QRectF",
methods_QRectF (),
"@qt\n@brief Binding of QRectF");
GSIQT_PUBLIC gsi::Class<QRectF> &qtdecl_QRectF () { return decl_QRectF; }
GSI_QTCORE_PUBLIC gsi::Class<QRectF> &qtdecl_QRectF () { return decl_QRectF; }
}

24
src/gsiqt4/gsiDeclQRegExp.cc → src/gsiqt/qt4/QtCore/gsiDeclQRegExp.cc
View File

@ -29,8 +29,8 @@
#include <QRegExp>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -631,12 +631,12 @@ static gsi::Methods methods_QRegExp () {
return methods;
}
gsi::Class<QRegExp> decl_QRegExp ("QRegExp",
gsi::Class<QRegExp> decl_QRegExp ("QtCore", "QRegExp",
methods_QRegExp (),
"@qt\n@brief Binding of QRegExp");
GSIQT_PUBLIC gsi::Class<QRegExp> &qtdecl_QRegExp () { return decl_QRegExp; }
GSI_QTCORE_PUBLIC gsi::Class<QRegExp> &qtdecl_QRegExp () { return decl_QRegExp; }
}
@ -645,19 +645,19 @@ GSIQT_PUBLIC gsi::Class<QRegExp> &qtdecl_QRegExp () { return decl_QRegExp; }
namespace qt_gsi
{
static gsi::Enum<QRegExp::CaretMode> decl_QRegExp_CaretMode_Enum ("QRegExp_CaretMode",
static gsi::Enum<QRegExp::CaretMode> decl_QRegExp_CaretMode_Enum ("QtCore", "QRegExp_CaretMode",
gsi::enum_const ("CaretAtZero", QRegExp::CaretAtZero, "@brief Enum constant QRegExp::CaretAtZero") +
gsi::enum_const ("CaretAtOffset", QRegExp::CaretAtOffset, "@brief Enum constant QRegExp::CaretAtOffset") +
gsi::enum_const ("CaretWontMatch", QRegExp::CaretWontMatch, "@brief Enum constant QRegExp::CaretWontMatch"),
"@qt\n@brief This class represents the QRegExp::CaretMode enum");
static gsi::QFlagsClass<QRegExp::CaretMode > decl_QRegExp_CaretMode_Enums ("QRegExp_QFlags_CaretMode",
static gsi::QFlagsClass<QRegExp::CaretMode > decl_QRegExp_CaretMode_Enums ("QtCore", "QRegExp_QFlags_CaretMode",
"@qt\n@brief This class represents the QFlags<QRegExp::CaretMode> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QRegExp> inject_QRegExp_CaretMode_Enum_in_parent (decl_QRegExp_CaretMode_Enum.defs ());
static gsi::ClassExt<QRegExp> decl_QRegExp_CaretMode_Enum_as_child (decl_QRegExp_CaretMode_Enum, "CaretMode");
static gsi::ClassExt<QRegExp> decl_QRegExp_CaretMode_Enums_as_child (decl_QRegExp_CaretMode_Enums, "QFlags_CaretMode");
static gsi::ClassExt<QRegExp> decl_QRegExp_CaretMode_Enum_as_child (decl_QRegExp_CaretMode_Enum, "QtCore", "CaretMode");
static gsi::ClassExt<QRegExp> decl_QRegExp_CaretMode_Enums_as_child (decl_QRegExp_CaretMode_Enums, "QtCore", "QFlags_CaretMode");
}
@ -666,7 +666,7 @@ static gsi::ClassExt<QRegExp> decl_QRegExp_CaretMode_Enums_as_child (decl_QRegEx
namespace qt_gsi
{
static gsi::Enum<QRegExp::PatternSyntax> decl_QRegExp_PatternSyntax_Enum ("QRegExp_PatternSyntax",
static gsi::Enum<QRegExp::PatternSyntax> decl_QRegExp_PatternSyntax_Enum ("QtCore", "QRegExp_PatternSyntax",
gsi::enum_const ("RegExp", QRegExp::RegExp, "@brief Enum constant QRegExp::RegExp") +
gsi::enum_const ("Wildcard", QRegExp::Wildcard, "@brief Enum constant QRegExp::Wildcard") +
gsi::enum_const ("FixedString", QRegExp::FixedString, "@brief Enum constant QRegExp::FixedString") +
@ -675,13 +675,13 @@ static gsi::Enum<QRegExp::PatternSyntax> decl_QRegExp_PatternSyntax_Enum ("QRegE
gsi::enum_const ("W3CXmlSchema11", QRegExp::W3CXmlSchema11, "@brief Enum constant QRegExp::W3CXmlSchema11"),
"@qt\n@brief This class represents the QRegExp::PatternSyntax enum");
static gsi::QFlagsClass<QRegExp::PatternSyntax > decl_QRegExp_PatternSyntax_Enums ("QRegExp_QFlags_PatternSyntax",
static gsi::QFlagsClass<QRegExp::PatternSyntax > decl_QRegExp_PatternSyntax_Enums ("QtCore", "QRegExp_QFlags_PatternSyntax",
"@qt\n@brief This class represents the QFlags<QRegExp::PatternSyntax> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QRegExp> inject_QRegExp_PatternSyntax_Enum_in_parent (decl_QRegExp_PatternSyntax_Enum.defs ());
static gsi::ClassExt<QRegExp> decl_QRegExp_PatternSyntax_Enum_as_child (decl_QRegExp_PatternSyntax_Enum, "PatternSyntax");
static gsi::ClassExt<QRegExp> decl_QRegExp_PatternSyntax_Enums_as_child (decl_QRegExp_PatternSyntax_Enums, "QFlags_PatternSyntax");
static gsi::ClassExt<QRegExp> decl_QRegExp_PatternSyntax_Enum_as_child (decl_QRegExp_PatternSyntax_Enum, "QtCore", "PatternSyntax");
static gsi::ClassExt<QRegExp> decl_QRegExp_PatternSyntax_Enums_as_child (decl_QRegExp_PatternSyntax_Enums, "QtCore", "QFlags_PatternSyntax");
}

8
src/gsiqt4/gsiDeclQResource.cc → src/gsiqt/qt4/QtCore/gsiDeclQResource.cc
View File

@ -30,8 +30,8 @@
#include <QResource>
#include <QLocale>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -352,12 +352,12 @@ static gsi::Methods methods_QResource () {
return methods;
}
gsi::Class<QResource> decl_QResource ("QResource",
gsi::Class<QResource> decl_QResource ("QtCore", "QResource",
methods_QResource (),
"@qt\n@brief Binding of QResource");
GSIQT_PUBLIC gsi::Class<QResource> &qtdecl_QResource () { return decl_QResource; }
GSI_QTCORE_PUBLIC gsi::Class<QResource> &qtdecl_QResource () { return decl_QResource; }
}

8
src/gsiqt4/gsiDeclQSemaphore.cc → src/gsiqt/qt4/QtCore/gsiDeclQSemaphore.cc
View File

@ -29,8 +29,8 @@
#include <QSemaphore>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -166,12 +166,12 @@ static gsi::Methods methods_QSemaphore () {
return methods;
}
gsi::Class<QSemaphore> decl_QSemaphore ("QSemaphore",
gsi::Class<QSemaphore> decl_QSemaphore ("QtCore", "QSemaphore",
methods_QSemaphore (),
"@qt\n@brief Binding of QSemaphore");
GSIQT_PUBLIC gsi::Class<QSemaphore> &qtdecl_QSemaphore () { return decl_QSemaphore; }
GSI_QTCORE_PUBLIC gsi::Class<QSemaphore> &qtdecl_QSemaphore () { return decl_QSemaphore; }
}

34
src/gsiqt4/gsiDeclQSettings.cc → src/gsiqt/qt4/QtCore/gsiDeclQSettings.cc
View File

@ -34,8 +34,8 @@
#include <QThread>
#include <QTimerEvent>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -725,11 +725,11 @@ static gsi::Methods methods_QSettings () {
gsi::Class<QObject> &qtdecl_QObject ();
qt_gsi::QtNativeClass<QSettings> decl_QSettings (qtdecl_QObject (), "QSettings_Native",
qt_gsi::QtNativeClass<QSettings> decl_QSettings (qtdecl_QObject (), "QtCore", "QSettings_Native",
methods_QSettings (),
"@hide\n@alias QSettings");
GSIQT_PUBLIC gsi::Class<QSettings> &qtdecl_QSettings () { return decl_QSettings; }
GSI_QTCORE_PUBLIC gsi::Class<QSettings> &qtdecl_QSettings () { return decl_QSettings; }
}
@ -1282,7 +1282,7 @@ static gsi::Methods methods_QSettings_Adaptor () {
return methods;
}
gsi::Class<QSettings_Adaptor> decl_QSettings_Adaptor (qtdecl_QSettings (), "QSettings",
gsi::Class<QSettings_Adaptor> decl_QSettings_Adaptor (qtdecl_QSettings (), "QtCore", "QSettings",
methods_QSettings_Adaptor (),
"@qt\n@brief Binding of QSettings");
@ -1293,7 +1293,7 @@ gsi::Class<QSettings_Adaptor> decl_QSettings_Adaptor (qtdecl_QSettings (), "QSet
namespace qt_gsi
{
static gsi::Enum<QSettings::Format> decl_QSettings_Format_Enum ("QSettings_Format",
static gsi::Enum<QSettings::Format> decl_QSettings_Format_Enum ("QtCore", "QSettings_Format",
gsi::enum_const ("NativeFormat", QSettings::NativeFormat, "@brief Enum constant QSettings::NativeFormat") +
gsi::enum_const ("IniFormat", QSettings::IniFormat, "@brief Enum constant QSettings::IniFormat") +
gsi::enum_const ("InvalidFormat", QSettings::InvalidFormat, "@brief Enum constant QSettings::InvalidFormat") +
@ -1315,13 +1315,13 @@ static gsi::Enum<QSettings::Format> decl_QSettings_Format_Enum ("QSettings_Forma
gsi::enum_const ("CustomFormat16", QSettings::CustomFormat16, "@brief Enum constant QSettings::CustomFormat16"),
"@qt\n@brief This class represents the QSettings::Format enum");
static gsi::QFlagsClass<QSettings::Format > decl_QSettings_Format_Enums ("QSettings_QFlags_Format",
static gsi::QFlagsClass<QSettings::Format > decl_QSettings_Format_Enums ("QtCore", "QSettings_QFlags_Format",
"@qt\n@brief This class represents the QFlags<QSettings::Format> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QSettings> inject_QSettings_Format_Enum_in_parent (decl_QSettings_Format_Enum.defs ());
static gsi::ClassExt<QSettings> decl_QSettings_Format_Enum_as_child (decl_QSettings_Format_Enum, "Format");
static gsi::ClassExt<QSettings> decl_QSettings_Format_Enums_as_child (decl_QSettings_Format_Enums, "QFlags_Format");
static gsi::ClassExt<QSettings> decl_QSettings_Format_Enum_as_child (decl_QSettings_Format_Enum, "QtCore", "Format");
static gsi::ClassExt<QSettings> decl_QSettings_Format_Enums_as_child (decl_QSettings_Format_Enums, "QtCore", "QFlags_Format");
}
@ -1330,18 +1330,18 @@ static gsi::ClassExt<QSettings> decl_QSettings_Format_Enums_as_child (decl_QSett
namespace qt_gsi
{
static gsi::Enum<QSettings::Scope> decl_QSettings_Scope_Enum ("QSettings_Scope",
static gsi::Enum<QSettings::Scope> decl_QSettings_Scope_Enum ("QtCore", "QSettings_Scope",
gsi::enum_const ("UserScope", QSettings::UserScope, "@brief Enum constant QSettings::UserScope") +
gsi::enum_const ("SystemScope", QSettings::SystemScope, "@brief Enum constant QSettings::SystemScope"),
"@qt\n@brief This class represents the QSettings::Scope enum");
static gsi::QFlagsClass<QSettings::Scope > decl_QSettings_Scope_Enums ("QSettings_QFlags_Scope",
static gsi::QFlagsClass<QSettings::Scope > decl_QSettings_Scope_Enums ("QtCore", "QSettings_QFlags_Scope",
"@qt\n@brief This class represents the QFlags<QSettings::Scope> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QSettings> inject_QSettings_Scope_Enum_in_parent (decl_QSettings_Scope_Enum.defs ());
static gsi::ClassExt<QSettings> decl_QSettings_Scope_Enum_as_child (decl_QSettings_Scope_Enum, "Scope");
static gsi::ClassExt<QSettings> decl_QSettings_Scope_Enums_as_child (decl_QSettings_Scope_Enums, "QFlags_Scope");
static gsi::ClassExt<QSettings> decl_QSettings_Scope_Enum_as_child (decl_QSettings_Scope_Enum, "QtCore", "Scope");
static gsi::ClassExt<QSettings> decl_QSettings_Scope_Enums_as_child (decl_QSettings_Scope_Enums, "QtCore", "QFlags_Scope");
}
@ -1350,19 +1350,19 @@ static gsi::ClassExt<QSettings> decl_QSettings_Scope_Enums_as_child (decl_QSetti
namespace qt_gsi
{
static gsi::Enum<QSettings::Status> decl_QSettings_Status_Enum ("QSettings_Status",
static gsi::Enum<QSettings::Status> decl_QSettings_Status_Enum ("QtCore", "QSettings_Status",
gsi::enum_const ("NoError", QSettings::NoError, "@brief Enum constant QSettings::NoError") +
gsi::enum_const ("AccessError", QSettings::AccessError, "@brief Enum constant QSettings::AccessError") +
gsi::enum_const ("FormatError", QSettings::FormatError, "@brief Enum constant QSettings::FormatError"),
"@qt\n@brief This class represents the QSettings::Status enum");
static gsi::QFlagsClass<QSettings::Status > decl_QSettings_Status_Enums ("QSettings_QFlags_Status",
static gsi::QFlagsClass<QSettings::Status > decl_QSettings_Status_Enums ("QtCore", "QSettings_QFlags_Status",
"@qt\n@brief This class represents the QFlags<QSettings::Status> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QSettings> inject_QSettings_Status_Enum_in_parent (decl_QSettings_Status_Enum.defs ());
static gsi::ClassExt<QSettings> decl_QSettings_Status_Enum_as_child (decl_QSettings_Status_Enum, "Status");
static gsi::ClassExt<QSettings> decl_QSettings_Status_Enums_as_child (decl_QSettings_Status_Enums, "QFlags_Status");
static gsi::ClassExt<QSettings> decl_QSettings_Status_Enum_as_child (decl_QSettings_Status_Enum, "QtCore", "Status");
static gsi::ClassExt<QSettings> decl_QSettings_Status_Enums_as_child (decl_QSettings_Status_Enums, "QtCore", "QFlags_Status");
}

10
src/gsiqt4/gsiDeclQSignalMapper.cc → src/gsiqt/qt4/QtCore/gsiDeclQSignalMapper.cc
View File

@ -35,8 +35,8 @@
#include <QTimerEvent>
#include <QWidget>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -404,11 +404,11 @@ static gsi::Methods methods_QSignalMapper () {
gsi::Class<QObject> &qtdecl_QObject ();
qt_gsi::QtNativeClass<QSignalMapper> decl_QSignalMapper (qtdecl_QObject (), "QSignalMapper_Native",
qt_gsi::QtNativeClass<QSignalMapper> decl_QSignalMapper (qtdecl_QObject (), "QtCore", "QSignalMapper_Native",
methods_QSignalMapper (),
"@hide\n@alias QSignalMapper");
GSIQT_PUBLIC gsi::Class<QSignalMapper> &qtdecl_QSignalMapper () { return decl_QSignalMapper; }
GSI_QTCORE_PUBLIC gsi::Class<QSignalMapper> &qtdecl_QSignalMapper () { return decl_QSignalMapper; }
}
@ -886,7 +886,7 @@ static gsi::Methods methods_QSignalMapper_Adaptor () {
return methods;
}
gsi::Class<QSignalMapper_Adaptor> decl_QSignalMapper_Adaptor (qtdecl_QSignalMapper (), "QSignalMapper",
gsi::Class<QSignalMapper_Adaptor> decl_QSignalMapper_Adaptor (qtdecl_QSignalMapper (), "QtCore", "QSignalMapper",
methods_QSignalMapper_Adaptor (),
"@qt\n@brief Binding of QSignalMapper");

8
src/gsiqt4/gsiDeclQSize.cc → src/gsiqt/qt4/QtCore/gsiDeclQSize.cc
View File

@ -29,8 +29,8 @@
#include <QSize>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -462,12 +462,12 @@ static gsi::Methods methods_QSize () {
return methods;
}
gsi::Class<QSize> decl_QSize ("QSize",
gsi::Class<QSize> decl_QSize ("QtCore", "QSize",
methods_QSize (),
"@qt\n@brief Binding of QSize");
GSIQT_PUBLIC gsi::Class<QSize> &qtdecl_QSize () { return decl_QSize; }
GSI_QTCORE_PUBLIC gsi::Class<QSize> &qtdecl_QSize () { return decl_QSize; }
}

8
src/gsiqt4/gsiDeclQSizeF.cc → src/gsiqt/qt4/QtCore/gsiDeclQSizeF.cc
View File

@ -30,8 +30,8 @@
#include <QSizeF>
#include <QSize>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -499,12 +499,12 @@ static gsi::Methods methods_QSizeF () {
return methods;
}
gsi::Class<QSizeF> decl_QSizeF ("QSizeF",
gsi::Class<QSizeF> decl_QSizeF ("QtCore", "QSizeF",
methods_QSizeF (),
"@qt\n@brief Binding of QSizeF");
GSIQT_PUBLIC gsi::Class<QSizeF> &qtdecl_QSizeF () { return decl_QSizeF; }
GSI_QTCORE_PUBLIC gsi::Class<QSizeF> &qtdecl_QSizeF () { return decl_QSizeF; }
}

18
src/gsiqt4/gsiDeclQSocketNotifier.cc → src/gsiqt/qt4/QtCore/gsiDeclQSocketNotifier.cc
View File

@ -34,8 +34,8 @@
#include <QThread>
#include <QTimerEvent>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -234,11 +234,11 @@ static gsi::Methods methods_QSocketNotifier () {
gsi::Class<QObject> &qtdecl_QObject ();
qt_gsi::QtNativeClass<QSocketNotifier> decl_QSocketNotifier (qtdecl_QObject (), "QSocketNotifier_Native",
qt_gsi::QtNativeClass<QSocketNotifier> decl_QSocketNotifier (qtdecl_QObject (), "QtCore", "QSocketNotifier_Native",
methods_QSocketNotifier (),
"@hide\n@alias QSocketNotifier");
GSIQT_PUBLIC gsi::Class<QSocketNotifier> &qtdecl_QSocketNotifier () { return decl_QSocketNotifier; }
GSI_QTCORE_PUBLIC gsi::Class<QSocketNotifier> &qtdecl_QSocketNotifier () { return decl_QSocketNotifier; }
}
@ -647,7 +647,7 @@ static gsi::Methods methods_QSocketNotifier_Adaptor () {
return methods;
}
gsi::Class<QSocketNotifier_Adaptor> decl_QSocketNotifier_Adaptor (qtdecl_QSocketNotifier (), "QSocketNotifier",
gsi::Class<QSocketNotifier_Adaptor> decl_QSocketNotifier_Adaptor (qtdecl_QSocketNotifier (), "QtCore", "QSocketNotifier",
methods_QSocketNotifier_Adaptor (),
"@qt\n@brief Binding of QSocketNotifier");
@ -658,19 +658,19 @@ gsi::Class<QSocketNotifier_Adaptor> decl_QSocketNotifier_Adaptor (qtdecl_QSocket
namespace qt_gsi
{
static gsi::Enum<QSocketNotifier::Type> decl_QSocketNotifier_Type_Enum ("QSocketNotifier_Type",
static gsi::Enum<QSocketNotifier::Type> decl_QSocketNotifier_Type_Enum ("QtCore", "QSocketNotifier_Type",
gsi::enum_const ("Read", QSocketNotifier::Read, "@brief Enum constant QSocketNotifier::Read") +
gsi::enum_const ("Write", QSocketNotifier::Write, "@brief Enum constant QSocketNotifier::Write") +
gsi::enum_const ("Exception", QSocketNotifier::Exception, "@brief Enum constant QSocketNotifier::Exception"),
"@qt\n@brief This class represents the QSocketNotifier::Type enum");
static gsi::QFlagsClass<QSocketNotifier::Type > decl_QSocketNotifier_Type_Enums ("QSocketNotifier_QFlags_Type",
static gsi::QFlagsClass<QSocketNotifier::Type > decl_QSocketNotifier_Type_Enums ("QtCore", "QSocketNotifier_QFlags_Type",
"@qt\n@brief This class represents the QFlags<QSocketNotifier::Type> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QSocketNotifier> inject_QSocketNotifier_Type_Enum_in_parent (decl_QSocketNotifier_Type_Enum.defs ());
static gsi::ClassExt<QSocketNotifier> decl_QSocketNotifier_Type_Enum_as_child (decl_QSocketNotifier_Type_Enum, "Type");
static gsi::ClassExt<QSocketNotifier> decl_QSocketNotifier_Type_Enums_as_child (decl_QSocketNotifier_Type_Enums, "QFlags_Type");
static gsi::ClassExt<QSocketNotifier> decl_QSocketNotifier_Type_Enum_as_child (decl_QSocketNotifier_Type_Enum, "QtCore", "Type");
static gsi::ClassExt<QSocketNotifier> decl_QSocketNotifier_Type_Enums_as_child (decl_QSocketNotifier_Type_Enums, "QtCore", "QFlags_Type");
}

8
src/gsiqt4/gsiDeclQStringMatcher.cc → src/gsiqt/qt4/QtCore/gsiDeclQStringMatcher.cc
View File

@ -29,8 +29,8 @@
#include <QStringMatcher>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -221,12 +221,12 @@ static gsi::Methods methods_QStringMatcher () {
return methods;
}
gsi::Class<QStringMatcher> decl_QStringMatcher ("QStringMatcher",
gsi::Class<QStringMatcher> decl_QStringMatcher ("QtCore", "QStringMatcher",
methods_QStringMatcher (),
"@qt\n@brief Binding of QStringMatcher");
GSIQT_PUBLIC gsi::Class<QStringMatcher> &qtdecl_QStringMatcher () { return decl_QStringMatcher; }
GSI_QTCORE_PUBLIC gsi::Class<QStringMatcher> &qtdecl_QStringMatcher () { return decl_QStringMatcher; }
}

8
src/gsiqt4/gsiDeclQSysInfo.cc → src/gsiqt/qt4/QtCore/gsiDeclQSysInfo.cc
View File

@ -29,8 +29,8 @@
#include <QSysInfo>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -61,12 +61,12 @@ static gsi::Methods methods_QSysInfo () {
return methods;
}
gsi::Class<QSysInfo> decl_QSysInfo ("QSysInfo",
gsi::Class<QSysInfo> decl_QSysInfo ("QtCore", "QSysInfo",
methods_QSysInfo (),
"@qt\n@brief Binding of QSysInfo");
GSIQT_PUBLIC gsi::Class<QSysInfo> &qtdecl_QSysInfo () { return decl_QSysInfo; }
GSI_QTCORE_PUBLIC gsi::Class<QSysInfo> &qtdecl_QSysInfo () { return decl_QSysInfo; }
}

18
src/gsiqt4/gsiDeclQSystemLocale.cc → src/gsiqt/qt4/QtCore/gsiDeclQSystemLocale.cc
View File

@ -30,8 +30,8 @@
#include <QSystemLocale>
#include <QLocale>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -84,11 +84,11 @@ static gsi::Methods methods_QSystemLocale () {
return methods;
}
gsi::Class<QSystemLocale> decl_QSystemLocale ("QSystemLocale_Native",
gsi::Class<QSystemLocale> decl_QSystemLocale ("QtCore", "QSystemLocale_Native",
methods_QSystemLocale (),
"@hide\n@alias QSystemLocale");
GSIQT_PUBLIC gsi::Class<QSystemLocale> &qtdecl_QSystemLocale () { return decl_QSystemLocale; }
GSI_QTCORE_PUBLIC gsi::Class<QSystemLocale> &qtdecl_QSystemLocale () { return decl_QSystemLocale; }
}
@ -215,7 +215,7 @@ static gsi::Methods methods_QSystemLocale_Adaptor () {
return methods;
}
gsi::Class<QSystemLocale_Adaptor> decl_QSystemLocale_Adaptor (qtdecl_QSystemLocale (), "QSystemLocale",
gsi::Class<QSystemLocale_Adaptor> decl_QSystemLocale_Adaptor (qtdecl_QSystemLocale (), "QtCore", "QSystemLocale",
methods_QSystemLocale_Adaptor (),
"@qt\n@brief Binding of QSystemLocale");
@ -226,7 +226,7 @@ gsi::Class<QSystemLocale_Adaptor> decl_QSystemLocale_Adaptor (qtdecl_QSystemLoca
namespace qt_gsi
{
static gsi::Enum<QSystemLocale::QueryType> decl_QSystemLocale_QueryType_Enum ("QSystemLocale_QueryType",
static gsi::Enum<QSystemLocale::QueryType> decl_QSystemLocale_QueryType_Enum ("QtCore", "QSystemLocale_QueryType",
gsi::enum_const ("LanguageId", QSystemLocale::LanguageId, "@brief Enum constant QSystemLocale::LanguageId") +
gsi::enum_const ("CountryId", QSystemLocale::CountryId, "@brief Enum constant QSystemLocale::CountryId") +
gsi::enum_const ("DecimalPoint", QSystemLocale::DecimalPoint, "@brief Enum constant QSystemLocale::DecimalPoint") +
@ -255,13 +255,13 @@ static gsi::Enum<QSystemLocale::QueryType> decl_QSystemLocale_QueryType_Enum ("Q
gsi::enum_const ("PMText", QSystemLocale::PMText, "@brief Enum constant QSystemLocale::PMText"),
"@qt\n@brief This class represents the QSystemLocale::QueryType enum");
static gsi::QFlagsClass<QSystemLocale::QueryType > decl_QSystemLocale_QueryType_Enums ("QSystemLocale_QFlags_QueryType",
static gsi::QFlagsClass<QSystemLocale::QueryType > decl_QSystemLocale_QueryType_Enums ("QtCore", "QSystemLocale_QFlags_QueryType",
"@qt\n@brief This class represents the QFlags<QSystemLocale::QueryType> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QSystemLocale> inject_QSystemLocale_QueryType_Enum_in_parent (decl_QSystemLocale_QueryType_Enum.defs ());
static gsi::ClassExt<QSystemLocale> decl_QSystemLocale_QueryType_Enum_as_child (decl_QSystemLocale_QueryType_Enum, "QueryType");
static gsi::ClassExt<QSystemLocale> decl_QSystemLocale_QueryType_Enums_as_child (decl_QSystemLocale_QueryType_Enums, "QFlags_QueryType");
static gsi::ClassExt<QSystemLocale> decl_QSystemLocale_QueryType_Enum_as_child (decl_QSystemLocale_QueryType_Enum, "QtCore", "QueryType");
static gsi::ClassExt<QSystemLocale> decl_QSystemLocale_QueryType_Enums_as_child (decl_QSystemLocale_QueryType_Enums, "QtCore", "QFlags_QueryType");
}

8
src/gsiqt4/gsiDeclQTemporaryFile.cc → src/gsiqt/qt4/QtCore/gsiDeclQTemporaryFile.cc
View File

@ -35,8 +35,8 @@
#include <QThread>
#include <QTimerEvent>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -395,12 +395,12 @@ static gsi::Methods methods_QTemporaryFile () {
gsi::Class<QFile> &qtdecl_QFile ();
qt_gsi::QtNativeClass<QTemporaryFile> decl_QTemporaryFile (qtdecl_QFile (), "QTemporaryFile",
qt_gsi::QtNativeClass<QTemporaryFile> decl_QTemporaryFile (qtdecl_QFile (), "QtCore", "QTemporaryFile",
methods_QTemporaryFile (),
"@qt\n@brief Binding of QTemporaryFile");
GSIQT_PUBLIC gsi::Class<QTemporaryFile> &qtdecl_QTemporaryFile () { return decl_QTemporaryFile; }
GSI_QTCORE_PUBLIC gsi::Class<QTemporaryFile> &qtdecl_QTemporaryFile () { return decl_QTemporaryFile; }
}

39
src/gsiqt4/gsiDeclQTextCodec.cc → src/gsiqt/qt4/QtCore/gsiDeclQTextCodec.cc
View File

@ -31,8 +31,8 @@
#include <QTextDecoder>
#include <QTextEncoder>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -501,11 +501,11 @@ static gsi::Methods methods_QTextCodec () {
return methods;
}
gsi::Class<QTextCodec> decl_QTextCodec ("QTextCodec_Native",
gsi::Class<QTextCodec> decl_QTextCodec ("QtCore", "QTextCodec_Native",
methods_QTextCodec (),
"@hide\n@alias QTextCodec");
GSIQT_PUBLIC gsi::Class<QTextCodec> &qtdecl_QTextCodec () { return decl_QTextCodec; }
GSI_QTCORE_PUBLIC gsi::Class<QTextCodec> &qtdecl_QTextCodec () { return decl_QTextCodec; }
}
@ -516,6 +516,12 @@ public:
virtual ~QTextCodec_Adaptor();
// [adaptor ctor] QTextCodec::QTextCodec()
QTextCodec_Adaptor() : QTextCodec()
{
qt_gsi::QtObjectBase::init (this);
}
// [adaptor impl] QList<QByteArray> QTextCodec::aliases()
QList<QByteArray> cbs_aliases_c0_0() const
{
@ -606,6 +612,20 @@ public:
QTextCodec_Adaptor::~QTextCodec_Adaptor() { }
// Constructor QTextCodec::QTextCodec() (adaptor class)
static void _init_ctor_QTextCodec_Adaptor_0 (qt_gsi::GenericStaticMethod *decl)
{
decl->set_return_new<QTextCodec_Adaptor> ();
}
static void _call_ctor_QTextCodec_Adaptor_0 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret)
{
__SUPPRESS_UNUSED_WARNING(args);
ret.write<QTextCodec_Adaptor *> (new QTextCodec_Adaptor ());
}
// QList<QByteArray> QTextCodec::aliases()
static void _init_cbs_aliases_c0_0 (qt_gsi::GenericMethod *decl)
@ -728,6 +748,7 @@ gsi::Class<QTextCodec> &qtdecl_QTextCodec ();
static gsi::Methods methods_QTextCodec_Adaptor () {
gsi::Methods methods;
methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QTextCodec::QTextCodec()\nThis method creates an object of class QTextCodec.", &_init_ctor_QTextCodec_Adaptor_0, &_call_ctor_QTextCodec_Adaptor_0);
methods += new qt_gsi::GenericMethod ("aliases", "@hide", true, &_init_cbs_aliases_c0_0, &_call_cbs_aliases_c0_0);
methods += new qt_gsi::GenericMethod ("aliases", "@brief Virtual method QList<QByteArray> QTextCodec::aliases()\nThis method can be reimplemented in a derived class.", true, &_init_cbs_aliases_c0_0, &_call_cbs_aliases_c0_0, &_set_callback_cbs_aliases_c0_0);
methods += new qt_gsi::GenericMethod ("*convertFromUnicode", "@hide", true, &_init_cbs_convertFromUnicode_c5514_0, &_call_cbs_convertFromUnicode_c5514_0);
@ -741,7 +762,7 @@ static gsi::Methods methods_QTextCodec_Adaptor () {
return methods;
}
gsi::Class<QTextCodec_Adaptor> decl_QTextCodec_Adaptor (qtdecl_QTextCodec (), "QTextCodec",
gsi::Class<QTextCodec_Adaptor> decl_QTextCodec_Adaptor (qtdecl_QTextCodec (), "QtCore", "QTextCodec",
methods_QTextCodec_Adaptor (),
"@qt\n@brief Binding of QTextCodec");
@ -752,20 +773,20 @@ gsi::Class<QTextCodec_Adaptor> decl_QTextCodec_Adaptor (qtdecl_QTextCodec (), "Q
namespace qt_gsi
{
static gsi::Enum<QTextCodec::ConversionFlag> decl_QTextCodec_ConversionFlag_Enum ("QTextCodec_ConversionFlag",
static gsi::Enum<QTextCodec::ConversionFlag> decl_QTextCodec_ConversionFlag_Enum ("QtCore", "QTextCodec_ConversionFlag",
gsi::enum_const ("DefaultConversion", QTextCodec::DefaultConversion, "@brief Enum constant QTextCodec::DefaultConversion") +
gsi::enum_const ("ConvertInvalidToNull", QTextCodec::ConvertInvalidToNull, "@brief Enum constant QTextCodec::ConvertInvalidToNull") +
gsi::enum_const ("IgnoreHeader", QTextCodec::IgnoreHeader, "@brief Enum constant QTextCodec::IgnoreHeader") +
gsi::enum_const ("FreeFunction", QTextCodec::FreeFunction, "@brief Enum constant QTextCodec::FreeFunction"),
"@qt\n@brief This class represents the QTextCodec::ConversionFlag enum");
static gsi::QFlagsClass<QTextCodec::ConversionFlag > decl_QTextCodec_ConversionFlag_Enums ("QTextCodec_QFlags_ConversionFlag",
static gsi::QFlagsClass<QTextCodec::ConversionFlag > decl_QTextCodec_ConversionFlag_Enums ("QtCore", "QTextCodec_QFlags_ConversionFlag",
"@qt\n@brief This class represents the QFlags<QTextCodec::ConversionFlag> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QTextCodec> inject_QTextCodec_ConversionFlag_Enum_in_parent (decl_QTextCodec_ConversionFlag_Enum.defs ());
static gsi::ClassExt<QTextCodec> decl_QTextCodec_ConversionFlag_Enum_as_child (decl_QTextCodec_ConversionFlag_Enum, "ConversionFlag");
static gsi::ClassExt<QTextCodec> decl_QTextCodec_ConversionFlag_Enums_as_child (decl_QTextCodec_ConversionFlag_Enums, "QFlags_ConversionFlag");
static gsi::ClassExt<QTextCodec> decl_QTextCodec_ConversionFlag_Enum_as_child (decl_QTextCodec_ConversionFlag_Enum, "QtCore", "ConversionFlag");
static gsi::ClassExt<QTextCodec> decl_QTextCodec_ConversionFlag_Enums_as_child (decl_QTextCodec_ConversionFlag_Enums, "QtCore", "QFlags_ConversionFlag");
}

10
src/gsiqt4/gsiDeclQTextCodec_ConverterState.cc → src/gsiqt/qt4/QtCore/gsiDeclQTextCodec_ConverterState.cc
View File

@ -29,8 +29,8 @@
#include <QTextCodec>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -65,13 +65,13 @@ static gsi::Methods methods_QTextCodec_ConverterState () {
return methods;
}
gsi::Class<QTextCodec::ConverterState> decl_QTextCodec_ConverterState ("QTextCodec_ConverterState",
gsi::Class<QTextCodec::ConverterState> decl_QTextCodec_ConverterState ("QtCore", "QTextCodec_ConverterState",
methods_QTextCodec_ConverterState (),
"@qt\n@brief Binding of QTextCodec::ConverterState");
gsi::ClassExt<QTextCodec> decl_QTextCodec_ConverterState_as_child (decl_QTextCodec_ConverterState, "ConverterState");
gsi::ClassExt<QTextCodec> decl_QTextCodec_ConverterState_as_child (decl_QTextCodec_ConverterState, "QtCore", "ConverterState");
GSIQT_PUBLIC gsi::Class<QTextCodec::ConverterState> &qtdecl_QTextCodec_ConverterState () { return decl_QTextCodec_ConverterState; }
GSI_QTCORE_PUBLIC gsi::Class<QTextCodec::ConverterState> &qtdecl_QTextCodec_ConverterState () { return decl_QTextCodec_ConverterState; }
}

8
src/gsiqt4/gsiDeclQTextDecoder.cc → src/gsiqt/qt4/QtCore/gsiDeclQTextDecoder.cc
View File

@ -30,8 +30,8 @@
#include <QTextDecoder>
#include <QTextCodec>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -152,12 +152,12 @@ static gsi::Methods methods_QTextDecoder () {
return methods;
}
gsi::Class<QTextDecoder> decl_QTextDecoder ("QTextDecoder",
gsi::Class<QTextDecoder> decl_QTextDecoder ("QtCore", "QTextDecoder",
methods_QTextDecoder (),
"@qt\n@brief Binding of QTextDecoder");
GSIQT_PUBLIC gsi::Class<QTextDecoder> &qtdecl_QTextDecoder () { return decl_QTextDecoder; }
GSI_QTCORE_PUBLIC gsi::Class<QTextDecoder> &qtdecl_QTextDecoder () { return decl_QTextDecoder; }
}

8
src/gsiqt4/gsiDeclQTextEncoder.cc → src/gsiqt/qt4/QtCore/gsiDeclQTextEncoder.cc
View File

@ -30,8 +30,8 @@
#include <QTextEncoder>
#include <QTextCodec>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -102,12 +102,12 @@ static gsi::Methods methods_QTextEncoder () {
return methods;
}
gsi::Class<QTextEncoder> decl_QTextEncoder ("QTextEncoder",
gsi::Class<QTextEncoder> decl_QTextEncoder ("QtCore", "QTextEncoder",
methods_QTextEncoder (),
"@qt\n@brief Binding of QTextEncoder");
GSIQT_PUBLIC gsi::Class<QTextEncoder> &qtdecl_QTextEncoder () { return decl_QTextEncoder; }
GSI_QTCORE_PUBLIC gsi::Class<QTextEncoder> &qtdecl_QTextEncoder () { return decl_QTextEncoder; }
}

42
src/gsiqt4/gsiDeclQTextStream.cc → src/gsiqt/qt4/QtCore/gsiDeclQTextStream.cc
View File

@ -34,8 +34,8 @@
#include <QDomNode>
#include <QSplitter>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -910,7 +910,7 @@ static gsi::Methods methods_QTextStream () {
return methods;
}
gsi::Class<QTextStream> decl_QTextStream ("QTextStream_Native",
gsi::Class<QTextStream> decl_QTextStream ("QtCore", "QTextStream_Native",
gsi::method_ext("read_s", &f_QTextStream_read_s, "@brief Non-ambiguous adaptation of the corresponding operator>>") +
gsi::method_ext("read_us", &f_QTextStream_read_us, "@brief Non-ambiguous adaptation of the corresponding operator>>") +
gsi::method_ext("read_i", &f_QTextStream_read_i, "@brief Non-ambiguous adaptation of the corresponding operator>>") +
@ -937,7 +937,7 @@ gsi::Class<QTextStream> decl_QTextStream ("QTextStream_Native",
methods_QTextStream (),
"@hide\n@alias QTextStream");
GSIQT_PUBLIC gsi::Class<QTextStream> &qtdecl_QTextStream () { return decl_QTextStream; }
GSI_QTCORE_PUBLIC gsi::Class<QTextStream> &qtdecl_QTextStream () { return decl_QTextStream; }
}
@ -1043,7 +1043,7 @@ static gsi::Methods methods_QTextStream_Adaptor () {
return methods;
}
gsi::Class<QTextStream_Adaptor> decl_QTextStream_Adaptor (qtdecl_QTextStream (), "QTextStream",
gsi::Class<QTextStream_Adaptor> decl_QTextStream_Adaptor (qtdecl_QTextStream (), "QtCore", "QTextStream",
methods_QTextStream_Adaptor (),
"@qt\n@brief Binding of QTextStream");
@ -1054,20 +1054,20 @@ gsi::Class<QTextStream_Adaptor> decl_QTextStream_Adaptor (qtdecl_QTextStream (),
namespace qt_gsi
{
static gsi::Enum<QTextStream::FieldAlignment> decl_QTextStream_FieldAlignment_Enum ("QTextStream_FieldAlignment",
static gsi::Enum<QTextStream::FieldAlignment> decl_QTextStream_FieldAlignment_Enum ("QtCore", "QTextStream_FieldAlignment",
gsi::enum_const ("AlignLeft", QTextStream::AlignLeft, "@brief Enum constant QTextStream::AlignLeft") +
gsi::enum_const ("AlignRight", QTextStream::AlignRight, "@brief Enum constant QTextStream::AlignRight") +
gsi::enum_const ("AlignCenter", QTextStream::AlignCenter, "@brief Enum constant QTextStream::AlignCenter") +
gsi::enum_const ("AlignAccountingStyle", QTextStream::AlignAccountingStyle, "@brief Enum constant QTextStream::AlignAccountingStyle"),
"@qt\n@brief This class represents the QTextStream::FieldAlignment enum");
static gsi::QFlagsClass<QTextStream::FieldAlignment > decl_QTextStream_FieldAlignment_Enums ("QTextStream_QFlags_FieldAlignment",
static gsi::QFlagsClass<QTextStream::FieldAlignment > decl_QTextStream_FieldAlignment_Enums ("QtCore", "QTextStream_QFlags_FieldAlignment",
"@qt\n@brief This class represents the QFlags<QTextStream::FieldAlignment> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QTextStream> inject_QTextStream_FieldAlignment_Enum_in_parent (decl_QTextStream_FieldAlignment_Enum.defs ());
static gsi::ClassExt<QTextStream> decl_QTextStream_FieldAlignment_Enum_as_child (decl_QTextStream_FieldAlignment_Enum, "FieldAlignment");
static gsi::ClassExt<QTextStream> decl_QTextStream_FieldAlignment_Enums_as_child (decl_QTextStream_FieldAlignment_Enums, "QFlags_FieldAlignment");
static gsi::ClassExt<QTextStream> decl_QTextStream_FieldAlignment_Enum_as_child (decl_QTextStream_FieldAlignment_Enum, "QtCore", "FieldAlignment");
static gsi::ClassExt<QTextStream> decl_QTextStream_FieldAlignment_Enums_as_child (decl_QTextStream_FieldAlignment_Enums, "QtCore", "QFlags_FieldAlignment");
}
@ -1076,7 +1076,7 @@ static gsi::ClassExt<QTextStream> decl_QTextStream_FieldAlignment_Enums_as_child
namespace qt_gsi
{
static gsi::Enum<QTextStream::NumberFlag> decl_QTextStream_NumberFlag_Enum ("QTextStream_NumberFlag",
static gsi::Enum<QTextStream::NumberFlag> decl_QTextStream_NumberFlag_Enum ("QtCore", "QTextStream_NumberFlag",
gsi::enum_const ("ShowBase", QTextStream::ShowBase, "@brief Enum constant QTextStream::ShowBase") +
gsi::enum_const ("ForcePoint", QTextStream::ForcePoint, "@brief Enum constant QTextStream::ForcePoint") +
gsi::enum_const ("ForceSign", QTextStream::ForceSign, "@brief Enum constant QTextStream::ForceSign") +
@ -1084,13 +1084,13 @@ static gsi::Enum<QTextStream::NumberFlag> decl_QTextStream_NumberFlag_Enum ("QTe
gsi::enum_const ("UppercaseDigits", QTextStream::UppercaseDigits, "@brief Enum constant QTextStream::UppercaseDigits"),
"@qt\n@brief This class represents the QTextStream::NumberFlag enum");
static gsi::QFlagsClass<QTextStream::NumberFlag > decl_QTextStream_NumberFlag_Enums ("QTextStream_QFlags_NumberFlag",
static gsi::QFlagsClass<QTextStream::NumberFlag > decl_QTextStream_NumberFlag_Enums ("QtCore", "QTextStream_QFlags_NumberFlag",
"@qt\n@brief This class represents the QFlags<QTextStream::NumberFlag> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QTextStream> inject_QTextStream_NumberFlag_Enum_in_parent (decl_QTextStream_NumberFlag_Enum.defs ());
static gsi::ClassExt<QTextStream> decl_QTextStream_NumberFlag_Enum_as_child (decl_QTextStream_NumberFlag_Enum, "NumberFlag");
static gsi::ClassExt<QTextStream> decl_QTextStream_NumberFlag_Enums_as_child (decl_QTextStream_NumberFlag_Enums, "QFlags_NumberFlag");
static gsi::ClassExt<QTextStream> decl_QTextStream_NumberFlag_Enum_as_child (decl_QTextStream_NumberFlag_Enum, "QtCore", "NumberFlag");
static gsi::ClassExt<QTextStream> decl_QTextStream_NumberFlag_Enums_as_child (decl_QTextStream_NumberFlag_Enums, "QtCore", "QFlags_NumberFlag");
}
@ -1099,19 +1099,19 @@ static gsi::ClassExt<QTextStream> decl_QTextStream_NumberFlag_Enums_as_child (de
namespace qt_gsi
{
static gsi::Enum<QTextStream::RealNumberNotation> decl_QTextStream_RealNumberNotation_Enum ("QTextStream_RealNumberNotation",
static gsi::Enum<QTextStream::RealNumberNotation> decl_QTextStream_RealNumberNotation_Enum ("QtCore", "QTextStream_RealNumberNotation",
gsi::enum_const ("SmartNotation", QTextStream::SmartNotation, "@brief Enum constant QTextStream::SmartNotation") +
gsi::enum_const ("FixedNotation", QTextStream::FixedNotation, "@brief Enum constant QTextStream::FixedNotation") +
gsi::enum_const ("ScientificNotation", QTextStream::ScientificNotation, "@brief Enum constant QTextStream::ScientificNotation"),
"@qt\n@brief This class represents the QTextStream::RealNumberNotation enum");
static gsi::QFlagsClass<QTextStream::RealNumberNotation > decl_QTextStream_RealNumberNotation_Enums ("QTextStream_QFlags_RealNumberNotation",
static gsi::QFlagsClass<QTextStream::RealNumberNotation > decl_QTextStream_RealNumberNotation_Enums ("QtCore", "QTextStream_QFlags_RealNumberNotation",
"@qt\n@brief This class represents the QFlags<QTextStream::RealNumberNotation> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QTextStream> inject_QTextStream_RealNumberNotation_Enum_in_parent (decl_QTextStream_RealNumberNotation_Enum.defs ());
static gsi::ClassExt<QTextStream> decl_QTextStream_RealNumberNotation_Enum_as_child (decl_QTextStream_RealNumberNotation_Enum, "RealNumberNotation");
static gsi::ClassExt<QTextStream> decl_QTextStream_RealNumberNotation_Enums_as_child (decl_QTextStream_RealNumberNotation_Enums, "QFlags_RealNumberNotation");
static gsi::ClassExt<QTextStream> decl_QTextStream_RealNumberNotation_Enum_as_child (decl_QTextStream_RealNumberNotation_Enum, "QtCore", "RealNumberNotation");
static gsi::ClassExt<QTextStream> decl_QTextStream_RealNumberNotation_Enums_as_child (decl_QTextStream_RealNumberNotation_Enums, "QtCore", "QFlags_RealNumberNotation");
}
@ -1120,19 +1120,19 @@ static gsi::ClassExt<QTextStream> decl_QTextStream_RealNumberNotation_Enums_as_c
namespace qt_gsi
{
static gsi::Enum<QTextStream::Status> decl_QTextStream_Status_Enum ("QTextStream_Status",
static gsi::Enum<QTextStream::Status> decl_QTextStream_Status_Enum ("QtCore", "QTextStream_Status",
gsi::enum_const ("Ok", QTextStream::Ok, "@brief Enum constant QTextStream::Ok") +
gsi::enum_const ("ReadPastEnd", QTextStream::ReadPastEnd, "@brief Enum constant QTextStream::ReadPastEnd") +
gsi::enum_const ("ReadCorruptData", QTextStream::ReadCorruptData, "@brief Enum constant QTextStream::ReadCorruptData"),
"@qt\n@brief This class represents the QTextStream::Status enum");
static gsi::QFlagsClass<QTextStream::Status > decl_QTextStream_Status_Enums ("QTextStream_QFlags_Status",
static gsi::QFlagsClass<QTextStream::Status > decl_QTextStream_Status_Enums ("QtCore", "QTextStream_QFlags_Status",
"@qt\n@brief This class represents the QFlags<QTextStream::Status> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QTextStream> inject_QTextStream_Status_Enum_in_parent (decl_QTextStream_Status_Enum.defs ());
static gsi::ClassExt<QTextStream> decl_QTextStream_Status_Enum_as_child (decl_QTextStream_Status_Enum, "Status");
static gsi::ClassExt<QTextStream> decl_QTextStream_Status_Enums_as_child (decl_QTextStream_Status_Enums, "QFlags_Status");
static gsi::ClassExt<QTextStream> decl_QTextStream_Status_Enum_as_child (decl_QTextStream_Status_Enum, "QtCore", "Status");
static gsi::ClassExt<QTextStream> decl_QTextStream_Status_Enums_as_child (decl_QTextStream_Status_Enums, "QtCore", "QFlags_Status");
}

18
src/gsiqt4/gsiDeclQThread.cc → src/gsiqt/qt4/QtCore/gsiDeclQThread.cc
View File

@ -33,8 +33,8 @@
#include <QObject>
#include <QTimerEvent>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -433,11 +433,11 @@ static gsi::Methods methods_QThread () {
gsi::Class<QObject> &qtdecl_QObject ();
qt_gsi::QtNativeClass<QThread> decl_QThread (qtdecl_QObject (), "QThread_Native",
qt_gsi::QtNativeClass<QThread> decl_QThread (qtdecl_QObject (), "QtCore", "QThread_Native",
methods_QThread (),
"@hide\n@alias QThread");
GSIQT_PUBLIC gsi::Class<QThread> &qtdecl_QThread () { return decl_QThread; }
GSI_QTCORE_PUBLIC gsi::Class<QThread> &qtdecl_QThread () { return decl_QThread; }
}
@ -1036,7 +1036,7 @@ static gsi::Methods methods_QThread_Adaptor () {
return methods;
}
gsi::Class<QThread_Adaptor> decl_QThread_Adaptor (qtdecl_QThread (), "QThread",
gsi::Class<QThread_Adaptor> decl_QThread_Adaptor (qtdecl_QThread (), "QtCore", "QThread",
methods_QThread_Adaptor (),
"@qt\n@brief Binding of QThread");
@ -1047,7 +1047,7 @@ gsi::Class<QThread_Adaptor> decl_QThread_Adaptor (qtdecl_QThread (), "QThread",
namespace qt_gsi
{
static gsi::Enum<QThread::Priority> decl_QThread_Priority_Enum ("QThread_Priority",
static gsi::Enum<QThread::Priority> decl_QThread_Priority_Enum ("QtCore", "QThread_Priority",
gsi::enum_const ("IdlePriority", QThread::IdlePriority, "@brief Enum constant QThread::IdlePriority") +
gsi::enum_const ("LowestPriority", QThread::LowestPriority, "@brief Enum constant QThread::LowestPriority") +
gsi::enum_const ("LowPriority", QThread::LowPriority, "@brief Enum constant QThread::LowPriority") +
@ -1058,13 +1058,13 @@ static gsi::Enum<QThread::Priority> decl_QThread_Priority_Enum ("QThread_Priorit
gsi::enum_const ("InheritPriority", QThread::InheritPriority, "@brief Enum constant QThread::InheritPriority"),
"@qt\n@brief This class represents the QThread::Priority enum");
static gsi::QFlagsClass<QThread::Priority > decl_QThread_Priority_Enums ("QThread_QFlags_Priority",
static gsi::QFlagsClass<QThread::Priority > decl_QThread_Priority_Enums ("QtCore", "QThread_QFlags_Priority",
"@qt\n@brief This class represents the QFlags<QThread::Priority> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QThread> inject_QThread_Priority_Enum_in_parent (decl_QThread_Priority_Enum.defs ());
static gsi::ClassExt<QThread> decl_QThread_Priority_Enum_as_child (decl_QThread_Priority_Enum, "Priority");
static gsi::ClassExt<QThread> decl_QThread_Priority_Enums_as_child (decl_QThread_Priority_Enums, "QFlags_Priority");
static gsi::ClassExt<QThread> decl_QThread_Priority_Enum_as_child (decl_QThread_Priority_Enum, "QtCore", "Priority");
static gsi::ClassExt<QThread> decl_QThread_Priority_Enums_as_child (decl_QThread_Priority_Enums, "QtCore", "QFlags_Priority");
}

8
src/gsiqt4/gsiDeclQTime.cc → src/gsiqt/qt4/QtCore/gsiDeclQTime.cc
View File

@ -29,8 +29,8 @@
#include <QTime>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -595,12 +595,12 @@ static gsi::Methods methods_QTime () {
return methods;
}
gsi::Class<QTime> decl_QTime ("QTime",
gsi::Class<QTime> decl_QTime ("QtCore", "QTime",
methods_QTime (),
"@qt\n@brief Binding of QTime");
GSIQT_PUBLIC gsi::Class<QTime> &qtdecl_QTime () { return decl_QTime; }
GSI_QTCORE_PUBLIC gsi::Class<QTime> &qtdecl_QTime () { return decl_QTime; }
}

34
src/gsiqt4/gsiDeclQTimeLine.cc → src/gsiqt/qt4/QtCore/gsiDeclQTimeLine.cc
View File

@ -35,8 +35,8 @@
#include <QThread>
#include <QTimerEvent>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -703,11 +703,11 @@ static gsi::Methods methods_QTimeLine () {
gsi::Class<QObject> &qtdecl_QObject ();
qt_gsi::QtNativeClass<QTimeLine> decl_QTimeLine (qtdecl_QObject (), "QTimeLine_Native",
qt_gsi::QtNativeClass<QTimeLine> decl_QTimeLine (qtdecl_QObject (), "QtCore", "QTimeLine_Native",
methods_QTimeLine (),
"@hide\n@alias QTimeLine");
GSIQT_PUBLIC gsi::Class<QTimeLine> &qtdecl_QTimeLine () { return decl_QTimeLine; }
GSI_QTCORE_PUBLIC gsi::Class<QTimeLine> &qtdecl_QTimeLine () { return decl_QTimeLine; }
}
@ -1231,7 +1231,7 @@ static gsi::Methods methods_QTimeLine_Adaptor () {
return methods;
}
gsi::Class<QTimeLine_Adaptor> decl_QTimeLine_Adaptor (qtdecl_QTimeLine (), "QTimeLine",
gsi::Class<QTimeLine_Adaptor> decl_QTimeLine_Adaptor (qtdecl_QTimeLine (), "QtCore", "QTimeLine",
methods_QTimeLine_Adaptor (),
"@qt\n@brief Binding of QTimeLine");
@ -1242,7 +1242,7 @@ gsi::Class<QTimeLine_Adaptor> decl_QTimeLine_Adaptor (qtdecl_QTimeLine (), "QTim
namespace qt_gsi
{
static gsi::Enum<QTimeLine::CurveShape> decl_QTimeLine_CurveShape_Enum ("QTimeLine_CurveShape",
static gsi::Enum<QTimeLine::CurveShape> decl_QTimeLine_CurveShape_Enum ("QtCore", "QTimeLine_CurveShape",
gsi::enum_const ("EaseInCurve", QTimeLine::EaseInCurve, "@brief Enum constant QTimeLine::EaseInCurve") +
gsi::enum_const ("EaseOutCurve", QTimeLine::EaseOutCurve, "@brief Enum constant QTimeLine::EaseOutCurve") +
gsi::enum_const ("EaseInOutCurve", QTimeLine::EaseInOutCurve, "@brief Enum constant QTimeLine::EaseInOutCurve") +
@ -1251,13 +1251,13 @@ static gsi::Enum<QTimeLine::CurveShape> decl_QTimeLine_CurveShape_Enum ("QTimeLi
gsi::enum_const ("CosineCurve", QTimeLine::CosineCurve, "@brief Enum constant QTimeLine::CosineCurve"),
"@qt\n@brief This class represents the QTimeLine::CurveShape enum");
static gsi::QFlagsClass<QTimeLine::CurveShape > decl_QTimeLine_CurveShape_Enums ("QTimeLine_QFlags_CurveShape",
static gsi::QFlagsClass<QTimeLine::CurveShape > decl_QTimeLine_CurveShape_Enums ("QtCore", "QTimeLine_QFlags_CurveShape",
"@qt\n@brief This class represents the QFlags<QTimeLine::CurveShape> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QTimeLine> inject_QTimeLine_CurveShape_Enum_in_parent (decl_QTimeLine_CurveShape_Enum.defs ());
static gsi::ClassExt<QTimeLine> decl_QTimeLine_CurveShape_Enum_as_child (decl_QTimeLine_CurveShape_Enum, "CurveShape");
static gsi::ClassExt<QTimeLine> decl_QTimeLine_CurveShape_Enums_as_child (decl_QTimeLine_CurveShape_Enums, "QFlags_CurveShape");
static gsi::ClassExt<QTimeLine> decl_QTimeLine_CurveShape_Enum_as_child (decl_QTimeLine_CurveShape_Enum, "QtCore", "CurveShape");
static gsi::ClassExt<QTimeLine> decl_QTimeLine_CurveShape_Enums_as_child (decl_QTimeLine_CurveShape_Enums, "QtCore", "QFlags_CurveShape");
}
@ -1266,18 +1266,18 @@ static gsi::ClassExt<QTimeLine> decl_QTimeLine_CurveShape_Enums_as_child (decl_Q
namespace qt_gsi
{
static gsi::Enum<QTimeLine::Direction> decl_QTimeLine_Direction_Enum ("QTimeLine_Direction",
static gsi::Enum<QTimeLine::Direction> decl_QTimeLine_Direction_Enum ("QtCore", "QTimeLine_Direction",
gsi::enum_const ("Forward", QTimeLine::Forward, "@brief Enum constant QTimeLine::Forward") +
gsi::enum_const ("Backward", QTimeLine::Backward, "@brief Enum constant QTimeLine::Backward"),
"@qt\n@brief This class represents the QTimeLine::Direction enum");
static gsi::QFlagsClass<QTimeLine::Direction > decl_QTimeLine_Direction_Enums ("QTimeLine_QFlags_Direction",
static gsi::QFlagsClass<QTimeLine::Direction > decl_QTimeLine_Direction_Enums ("QtCore", "QTimeLine_QFlags_Direction",
"@qt\n@brief This class represents the QFlags<QTimeLine::Direction> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QTimeLine> inject_QTimeLine_Direction_Enum_in_parent (decl_QTimeLine_Direction_Enum.defs ());
static gsi::ClassExt<QTimeLine> decl_QTimeLine_Direction_Enum_as_child (decl_QTimeLine_Direction_Enum, "Direction");
static gsi::ClassExt<QTimeLine> decl_QTimeLine_Direction_Enums_as_child (decl_QTimeLine_Direction_Enums, "QFlags_Direction");
static gsi::ClassExt<QTimeLine> decl_QTimeLine_Direction_Enum_as_child (decl_QTimeLine_Direction_Enum, "QtCore", "Direction");
static gsi::ClassExt<QTimeLine> decl_QTimeLine_Direction_Enums_as_child (decl_QTimeLine_Direction_Enums, "QtCore", "QFlags_Direction");
}
@ -1286,19 +1286,19 @@ static gsi::ClassExt<QTimeLine> decl_QTimeLine_Direction_Enums_as_child (decl_QT
namespace qt_gsi
{
static gsi::Enum<QTimeLine::State> decl_QTimeLine_State_Enum ("QTimeLine_State",
static gsi::Enum<QTimeLine::State> decl_QTimeLine_State_Enum ("QtCore", "QTimeLine_State",
gsi::enum_const ("NotRunning", QTimeLine::NotRunning, "@brief Enum constant QTimeLine::NotRunning") +
gsi::enum_const ("Paused", QTimeLine::Paused, "@brief Enum constant QTimeLine::Paused") +
gsi::enum_const ("Running", QTimeLine::Running, "@brief Enum constant QTimeLine::Running"),
"@qt\n@brief This class represents the QTimeLine::State enum");
static gsi::QFlagsClass<QTimeLine::State > decl_QTimeLine_State_Enums ("QTimeLine_QFlags_State",
static gsi::QFlagsClass<QTimeLine::State > decl_QTimeLine_State_Enums ("QtCore", "QTimeLine_QFlags_State",
"@qt\n@brief This class represents the QFlags<QTimeLine::State> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QTimeLine> inject_QTimeLine_State_Enum_in_parent (decl_QTimeLine_State_Enum.defs ());
static gsi::ClassExt<QTimeLine> decl_QTimeLine_State_Enum_as_child (decl_QTimeLine_State_Enum, "State");
static gsi::ClassExt<QTimeLine> decl_QTimeLine_State_Enums_as_child (decl_QTimeLine_State_Enums, "QFlags_State");
static gsi::ClassExt<QTimeLine> decl_QTimeLine_State_Enum_as_child (decl_QTimeLine_State_Enum, "QtCore", "State");
static gsi::ClassExt<QTimeLine> decl_QTimeLine_State_Enums_as_child (decl_QTimeLine_State_Enums, "QtCore", "QFlags_State");
}

10
src/gsiqt4/gsiDeclQTimer.cc → src/gsiqt/qt4/QtCore/gsiDeclQTimer.cc
View File

@ -34,8 +34,8 @@
#include <QThread>
#include <QTimerEvent>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -326,11 +326,11 @@ static gsi::Methods methods_QTimer () {
gsi::Class<QObject> &qtdecl_QObject ();
qt_gsi::QtNativeClass<QTimer> decl_QTimer (qtdecl_QObject (), "QTimer_Native",
qt_gsi::QtNativeClass<QTimer> decl_QTimer (qtdecl_QObject (), "QtCore", "QTimer_Native",
methods_QTimer (),
"@hide\n@alias QTimer");
GSIQT_PUBLIC gsi::Class<QTimer> &qtdecl_QTimer () { return decl_QTimer; }
GSI_QTCORE_PUBLIC gsi::Class<QTimer> &qtdecl_QTimer () { return decl_QTimer; }
}
@ -729,7 +729,7 @@ static gsi::Methods methods_QTimer_Adaptor () {
return methods;
}
gsi::Class<QTimer_Adaptor> decl_QTimer_Adaptor (qtdecl_QTimer (), "QTimer",
gsi::Class<QTimer_Adaptor> decl_QTimer_Adaptor (qtdecl_QTimer (), "QtCore", "QTimer",
methods_QTimer_Adaptor (),
"@qt\n@brief Binding of QTimer");

10
src/gsiqt4/gsiDeclQTimerEvent.cc → src/gsiqt/qt4/QtCore/gsiDeclQTimerEvent.cc
View File

@ -29,8 +29,8 @@
#include <QTimerEvent>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -62,11 +62,11 @@ static gsi::Methods methods_QTimerEvent () {
gsi::Class<QEvent> &qtdecl_QEvent ();
gsi::Class<QTimerEvent> decl_QTimerEvent (qtdecl_QEvent (), "QTimerEvent_Native",
gsi::Class<QTimerEvent> decl_QTimerEvent (qtdecl_QEvent (), "QtCore", "QTimerEvent_Native",
methods_QTimerEvent (),
"@hide\n@alias QTimerEvent");
GSIQT_PUBLIC gsi::Class<QTimerEvent> &qtdecl_QTimerEvent () { return decl_QTimerEvent; }
GSI_QTCORE_PUBLIC gsi::Class<QTimerEvent> &qtdecl_QTimerEvent () { return decl_QTimerEvent; }
}
@ -117,7 +117,7 @@ static gsi::Methods methods_QTimerEvent_Adaptor () {
return methods;
}
gsi::Class<QTimerEvent_Adaptor> decl_QTimerEvent_Adaptor (qtdecl_QTimerEvent (), "QTimerEvent",
gsi::Class<QTimerEvent_Adaptor> decl_QTimerEvent_Adaptor (qtdecl_QTimerEvent (), "QtCore", "QTimerEvent",
methods_QTimerEvent_Adaptor (),
"@qt\n@brief Binding of QTimerEvent");

10
src/gsiqt4/gsiDeclQTranslator.cc → src/gsiqt/qt4/QtCore/gsiDeclQTranslator.cc
View File

@ -34,8 +34,8 @@
#include <QThread>
#include <QTimerEvent>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -287,11 +287,11 @@ static gsi::Methods methods_QTranslator () {
gsi::Class<QObject> &qtdecl_QObject ();
qt_gsi::QtNativeClass<QTranslator> decl_QTranslator (qtdecl_QObject (), "QTranslator_Native",
qt_gsi::QtNativeClass<QTranslator> decl_QTranslator (qtdecl_QObject (), "QtCore", "QTranslator_Native",
methods_QTranslator (),
"@hide\n@alias QTranslator");
GSIQT_PUBLIC gsi::Class<QTranslator> &qtdecl_QTranslator () { return decl_QTranslator; }
GSI_QTCORE_PUBLIC gsi::Class<QTranslator> &qtdecl_QTranslator () { return decl_QTranslator; }
}
@ -753,7 +753,7 @@ static gsi::Methods methods_QTranslator_Adaptor () {
return methods;
}
gsi::Class<QTranslator_Adaptor> decl_QTranslator_Adaptor (qtdecl_QTranslator (), "QTranslator",
gsi::Class<QTranslator_Adaptor> decl_QTranslator_Adaptor (qtdecl_QTranslator (), "QtCore", "QTranslator",
methods_QTranslator_Adaptor (),
"@qt\n@brief Binding of QTranslator");

24
src/gsiqt4/gsiDeclQUrl.cc → src/gsiqt/qt4/QtCore/gsiDeclQUrl.cc
View File

@ -29,8 +29,8 @@
#include <QUrl>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -1759,12 +1759,12 @@ static gsi::Methods methods_QUrl () {
return methods;
}
gsi::Class<QUrl> decl_QUrl ("QUrl",
gsi::Class<QUrl> decl_QUrl ("QtCore", "QUrl",
methods_QUrl (),
"@qt\n@brief Binding of QUrl");
GSIQT_PUBLIC gsi::Class<QUrl> &qtdecl_QUrl () { return decl_QUrl; }
GSI_QTCORE_PUBLIC gsi::Class<QUrl> &qtdecl_QUrl () { return decl_QUrl; }
}
@ -1773,7 +1773,7 @@ GSIQT_PUBLIC gsi::Class<QUrl> &qtdecl_QUrl () { return decl_QUrl; }
namespace qt_gsi
{
static gsi::Enum<QUrl::FormattingOption> decl_QUrl_FormattingOption_Enum ("QUrl_FormattingOption",
static gsi::Enum<QUrl::FormattingOption> decl_QUrl_FormattingOption_Enum ("QtCore", "QUrl_FormattingOption",
gsi::enum_const ("None", QUrl::None, "@brief Enum constant QUrl::None") +
gsi::enum_const ("RemoveScheme", QUrl::RemoveScheme, "@brief Enum constant QUrl::RemoveScheme") +
gsi::enum_const ("RemovePassword", QUrl::RemovePassword, "@brief Enum constant QUrl::RemovePassword") +
@ -1786,13 +1786,13 @@ static gsi::Enum<QUrl::FormattingOption> decl_QUrl_FormattingOption_Enum ("QUrl_
gsi::enum_const ("StripTrailingSlash", QUrl::StripTrailingSlash, "@brief Enum constant QUrl::StripTrailingSlash"),
"@qt\n@brief This class represents the QUrl::FormattingOption enum");
static gsi::QFlagsClass<QUrl::FormattingOption > decl_QUrl_FormattingOption_Enums ("QUrl_QFlags_FormattingOption",
static gsi::QFlagsClass<QUrl::FormattingOption > decl_QUrl_FormattingOption_Enums ("QtCore", "QUrl_QFlags_FormattingOption",
"@qt\n@brief This class represents the QFlags<QUrl::FormattingOption> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QUrl> inject_QUrl_FormattingOption_Enum_in_parent (decl_QUrl_FormattingOption_Enum.defs ());
static gsi::ClassExt<QUrl> decl_QUrl_FormattingOption_Enum_as_child (decl_QUrl_FormattingOption_Enum, "FormattingOption");
static gsi::ClassExt<QUrl> decl_QUrl_FormattingOption_Enums_as_child (decl_QUrl_FormattingOption_Enums, "QFlags_FormattingOption");
static gsi::ClassExt<QUrl> decl_QUrl_FormattingOption_Enum_as_child (decl_QUrl_FormattingOption_Enum, "QtCore", "FormattingOption");
static gsi::ClassExt<QUrl> decl_QUrl_FormattingOption_Enums_as_child (decl_QUrl_FormattingOption_Enums, "QtCore", "QFlags_FormattingOption");
}
@ -1801,18 +1801,18 @@ static gsi::ClassExt<QUrl> decl_QUrl_FormattingOption_Enums_as_child (decl_QUrl_
namespace qt_gsi
{
static gsi::Enum<QUrl::ParsingMode> decl_QUrl_ParsingMode_Enum ("QUrl_ParsingMode",
static gsi::Enum<QUrl::ParsingMode> decl_QUrl_ParsingMode_Enum ("QtCore", "QUrl_ParsingMode",
gsi::enum_const ("TolerantMode", QUrl::TolerantMode, "@brief Enum constant QUrl::TolerantMode") +
gsi::enum_const ("StrictMode", QUrl::StrictMode, "@brief Enum constant QUrl::StrictMode"),
"@qt\n@brief This class represents the QUrl::ParsingMode enum");
static gsi::QFlagsClass<QUrl::ParsingMode > decl_QUrl_ParsingMode_Enums ("QUrl_QFlags_ParsingMode",
static gsi::QFlagsClass<QUrl::ParsingMode > decl_QUrl_ParsingMode_Enums ("QtCore", "QUrl_QFlags_ParsingMode",
"@qt\n@brief This class represents the QFlags<QUrl::ParsingMode> flag set");
// Inject the declarations into the parent
static gsi::ClassExt<QUrl> inject_QUrl_ParsingMode_Enum_in_parent (decl_QUrl_ParsingMode_Enum.defs ());
static gsi::ClassExt<QUrl> decl_QUrl_ParsingMode_Enum_as_child (decl_QUrl_ParsingMode_Enum, "ParsingMode");
static gsi::ClassExt<QUrl> decl_QUrl_ParsingMode_Enums_as_child (decl_QUrl_ParsingMode_Enums, "QFlags_ParsingMode");
static gsi::ClassExt<QUrl> decl_QUrl_ParsingMode_Enum_as_child (decl_QUrl_ParsingMode_Enum, "QtCore", "ParsingMode");
static gsi::ClassExt<QUrl> decl_QUrl_ParsingMode_Enums_as_child (decl_QUrl_ParsingMode_Enums, "QtCore", "QFlags_ParsingMode");
}

8
src/gsiqt4/gsiDeclQWaitCondition.cc → src/gsiqt/qt4/QtCore/gsiDeclQWaitCondition.cc
View File

@ -31,8 +31,8 @@
#include <QMutex>
#include <QReadWriteLock>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -143,12 +143,12 @@ static gsi::Methods methods_QWaitCondition () {
return methods;
}
gsi::Class<QWaitCondition> decl_QWaitCondition ("QWaitCondition",
gsi::Class<QWaitCondition> decl_QWaitCondition ("QtCore", "QWaitCondition",
methods_QWaitCondition (),
"@qt\n@brief Binding of QWaitCondition");
GSIQT_PUBLIC gsi::Class<QWaitCondition> &qtdecl_QWaitCondition () { return decl_QWaitCondition; }
GSI_QTCORE_PUBLIC gsi::Class<QWaitCondition> &qtdecl_QWaitCondition () { return decl_QWaitCondition; }
}

8
src/gsiqt4/gsiDeclQWriteLocker.cc → src/gsiqt/qt4/QtCore/gsiDeclQWriteLocker.cc
View File

@ -30,8 +30,8 @@
#include <QWriteLocker>
#include <QReadWriteLock>
#include "gsiQt.h"
#include "gsiQtCommon.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiQtCoreCommon.h"
#include "gsiDeclQtCoreTypeTraits.h"
#include <memory>
// -----------------------------------------------------------------------
@ -116,12 +116,12 @@ static gsi::Methods methods_QWriteLocker () {
return methods;
}
gsi::Class<QWriteLocker> decl_QWriteLocker ("QWriteLocker",
gsi::Class<QWriteLocker> decl_QWriteLocker ("QtCore", "QWriteLocker",
methods_QWriteLocker (),
"@qt\n@brief Binding of QWriteLocker");
GSIQT_PUBLIC gsi::Class<QWriteLocker> &qtdecl_QWriteLocker () { return decl_QWriteLocker; }
GSI_QTCORE_PUBLIC gsi::Class<QWriteLocker> &qtdecl_QWriteLocker () { return decl_QWriteLocker; }
}

Some files were not shown because too many files have changed in this diff Show More