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_dir4=`pwd`/scripts/mkqtdecl4
inst_dir5=`pwd`/scripts/mkqtdecl5 inst_dir5=`pwd`/scripts/mkqtdecl5
src_dir=`pwd`/src src_dir=`pwd`/src
src_name4=gsiqt4 src_name4=gsiqt/qt4
src_name5=gsiqt5 src_name5=gsiqt/qt5
src_name=$src_name4 src_name=$src_name4
inst_dir=$inst_dir4 inst_dir=$inst_dir4
work_dir="mkqtdecl.tmp"
while [ "$1" != "" ]; do while [ "$1" != "" ]; do
a="$1" a="$1"
@ -92,6 +94,7 @@ while [ "$1" != "" ]; do
;; ;;
-qt5) -qt5)
qt="$qt5" qt="$qt5"
work_dir="mkqtdecl5.tmp"
inst_dir="$inst_dir5" inst_dir="$inst_dir5"
src_name="$src_name5" src_name="$src_name5"
;; ;;
@ -144,8 +147,6 @@ if ! ruby -e "require 'treetop'" 2>&1; then
exit 1 exit 1
fi fi
work_dir="./mkqtdecl.tmp"
if [ $update != 0 ]; then if [ $update != 0 ]; then
if [ -e $work_dir ] && [ $reuse == 0 ]; then if [ -e $work_dir ] && [ $reuse == 0 ]; then
@ -155,71 +156,116 @@ if [ $update != 0 ]; then
mkdir -p $work_dir mkdir -p $work_dir
cd $work_dir cd $work_dir
cp $inst_dir/{allofqt.cpp,mkqtdecl.conf,mkqtdecl.properties,mkqtdecl.events} . cp -R $inst_dir/Qt* .
cp $inst_dir_common/{cpp_parser_classes.rb,cpp_classes.rb,c++.treetop,parse.rb,reader_ext.rb,produce.rb} . 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 if [ $reuse == 0 ]; then
echo "Running gcc preprocessor .." for d in Qt*; do
# 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 .." echo "--------------------------------------------------------"
egrep -v '^#' <allofqt.x >allofqt.e echo "Parsing $d ..."
rm allofqt.x echo ""
echo "Parsing and producing db .." cd $d
./parse.rb -i allofqt.e -o allofqt.db
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 fi
mkdir -p generated rm -f produced.txt
touch produced.txt
echo "Producing code .." # Note the order of the modules is important: first modules get the
./produce.rb -i allofqt.db # 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 else
cd $work_dir cd $work_dir
fi fi
if [ ! -e generated ]; then for d in Qt*; do
echo "*** ERROR: production output ("`pwd`"/generated) does not exist - production failed?"
exit 1
fi
cd generated echo "--------------------------------------------------------"
echo "Processing $d ..."
echo ""
if [ $dry != 0 ]; then cd $d
echo "Synchronizing dry run .."
else
echo "Synchronizing .."
fi
count=0 if [ ! -e generated ]; then
for f in {*.cc,*.h} qtdecl.pri; do echo "*** ERROR: production output ("`pwd`"/generated) does not exist - production failed?"
needs_update=0 exit 1
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
fi fi
if [ $needs_update != 0 ]; then
count=`expr $count + 1` cd generated
if [ $dry != 0 ]; then
echo cp $f $src_dir/$src_name/$f if [ $dry != 0 ]; then
else echo "Synchronizing dry run .."
echo === cp $f $src_dir/$src_name/$f else
cp $f $src_dir/$src_name/$f 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 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 fi
cd ..
cd ..
done 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/QWizardPage"
#include "QtGui/QPrinter" #include "QtGui/QPrinter"
#include "QtGui/QAccessible" #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: public:
RawQObjectClass () 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" input_file = "all.db"
conf_file = "mkqtdecl.conf" conf_file = "mkqtdecl.conf"
cls_list = nil cls_list = nil
excl_list = {}
modn = "Qt"
$gen_dir = "generated" $gen_dir = "generated"
while ARGV.size > 0 while ARGV.size > 0
@ -35,8 +37,15 @@ while ARGV.size > 0
input_file = ARGV.shift input_file = ARGV.shift
elsif o == "-c" elsif o == "-c"
cls_list = ARGV.shift 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" elsif o == "-s"
conf_file = ARGV.shift conf_file = ARGV.shift
elsif o == "-m"
modn = ARGV.shift
else else
raise("Invalid option #{o} - usage is 'produce.rb -s mkqtdecl.conf -i all.db -c QWidget,QSizePolicy'") raise("Invalid option #{o} - usage is 'produce.rb -s mkqtdecl.conf -i all.db -c QWidget,QSizePolicy'")
end end
@ -363,6 +372,9 @@ class CPPStruct
if bd.is_a?(CPPDeclaration) && ! bd.template_decl 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 func = bd.type.func
if func if func
@ -1285,6 +1297,8 @@ end
class BindingProducer class BindingProducer
attr_accessor :modn
# @brief Read the input file (JSON) # @brief Read the input file (JSON)
# #
# This method will set up the binding producer for generating # This method will set up the binding producer for generating
@ -1293,6 +1307,7 @@ class BindingProducer
def read(input_file) def read(input_file)
@source_files = nil @source_files = nil
@classes = nil
@ext_decls = [] @ext_decls = []
File.open(input_file, "r") do |file| File.open(input_file, "r") do |file|
@ -1386,6 +1401,8 @@ class BindingProducer
while cont while cont
(cls, clsn) = make_cls_names(decl_obj) (cls, clsn) = make_cls_names(decl_obj)
@classes ||= []
@classes << clsn
if index > 0 if index > 0
ofile_name = "gsiDecl#{clsn}_#{index}.cc" ofile_name = "gsiDecl#{clsn}_#{index}.cc"
@ -1495,6 +1512,7 @@ END
methods = {} methods = {}
struct.collect_all_methods(methods, conf) struct.collect_all_methods(methods, conf)
methods[cls] = struct.collect_ctors methods[cls] = struct.collect_ctors
needs_adaptor = struct.needs_adaptor(conf)
used_classes = {} used_classes = {}
@ -1503,7 +1521,7 @@ END
m.each do |bd| m.each do |bd|
vis = bd.visibility vis = bd.visibility
if vis == :public || vis == :protected if vis == :public || (vis == :protected && needs_adaptor)
# don't consider dropped methods # don't consider dropped methods
conf.target_name(cls, bd, mn) || next conf.target_name(cls, bd, mn) || next
@ -1520,7 +1538,7 @@ END
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}>") ofile.puts("#include <#{uc}>")
end end
@ -1535,8 +1553,8 @@ END
end end
ofile.puts("#include \"gsiQt.h\"") ofile.puts("#include \"gsiQt.h\"")
ofile.puts("#include \"gsiQtCommon.h\"") ofile.puts("#include \"gsi#{modn}Common.h\"")
ofile.puts("#include \"gsiDeclQtTypeTraits.h\"") ofile.puts("#include \"gsiDecl#{modn}TypeTraits.h\"")
end end
@ -1561,7 +1579,7 @@ END
if index == 0 if index == 0
ofile.puts("namespace gsi") ofile.puts("namespace gsi")
ofile.puts("{") 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(" gsi::Methods(),")
ofile.puts(" \"@qt\\n@brief This class represents the #{cls} namespace\");") ofile.puts(" \"@qt\\n@brief This class represents the #{cls} namespace\");")
ofile.puts("}") ofile.puts("}")
@ -1597,7 +1615,7 @@ END
ofile.puts("namespace qt_gsi") ofile.puts("namespace qt_gsi")
ofile.puts("{") ofile.puts("{")
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 = [] edecl = []
@ -1618,7 +1636,7 @@ END
ofile.puts(" \"@qt\\n@brief This class represents the #{cls}::#{en} enum\");") ofile.puts(" \"@qt\\n@brief This class represents the #{cls}::#{en} enum\");")
ofile.puts("") 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(" \"@qt\\n@brief This class represents the QFlags<#{cls}::#{en}> flag set\");")
ofile.puts("") ofile.puts("")
@ -1640,8 +1658,8 @@ END
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}> 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}_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, \"QFlags_#{en}\");") ofile.puts("static gsi::ClassExt<#{pname}> decl_#{clsn}_#{en}_Enums_as_child (decl_#{clsn}_#{en}_Enums, \"#{modn}\", \"QFlags_#{en}\");")
ofile.puts("") ofile.puts("")
ofile.puts("}") ofile.puts("}")
@ -2249,9 +2267,9 @@ END
if base_cls if base_cls
ofile.puts("gsi::Class<#{base_cls}> &qtdecl_#{base_clsn} ();") ofile.puts("gsi::Class<#{base_cls}> &qtdecl_#{base_clsn} ();")
ofile.puts("") 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 else
ofile.puts("#{decl_type} decl_#{clsn} (" + "\"#{clsn}" + (needs_adaptor ? "_Native" : "") + "\",") ofile.puts("#{decl_type} decl_#{clsn} (\"#{modn}\", \"#{clsn}" + (needs_adaptor ? "_Native" : "") + "\",")
end end
if native_impl if native_impl
native_impl.each { |n| n[1] && ofile.puts(n[1] + "+") } native_impl.each { |n| n[1] && ofile.puts(n[1] + "+") }
@ -2279,7 +2297,7 @@ END
pcls = o.myself + "::" + pcls pcls = o.myself + "::" + pcls
end 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 end
@ -2287,11 +2305,11 @@ END
if !is_child_class if !is_child_class
# only for top-level classes external declarations are produced currently # 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 end
ofile.puts("") 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("")
ofile.puts("}") ofile.puts("}")
@ -2772,7 +2790,7 @@ END
ofile.puts(" return methods;") ofile.puts(" return methods;")
ofile.puts("}") ofile.puts("}")
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 if native_impl
native_impl.each { |n| n[1] && ofile.puts(n[1] + "+") } native_impl.each { |n| n[1] && ofile.puts(n[1] + "+") }
end end
@ -2792,7 +2810,7 @@ END
pcls = o.myself + "::" + pcls pcls = o.myself + "::" + pcls
end 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 end
@ -2882,7 +2900,7 @@ END
def produce_ttfile(conf) def produce_ttfile(conf)
ttfile_name = "gsiDeclQtTypeTraits.h" ttfile_name = "gsiDecl#{modn}TypeTraits.h"
ttfile_path = $gen_dir + "/" + ttfile_name ttfile_path = $gen_dir + "/" + ttfile_name
ttfile_path && File.open(ttfile_path, "w") do |ttfile| ttfile_path && File.open(ttfile_path, "w") do |ttfile|
@ -2920,8 +2938,8 @@ END
ttfile.puts("* This file has been created automatically") ttfile.puts("* This file has been created automatically")
ttfile.puts("*/") ttfile.puts("*/")
ttfile.puts("") ttfile.puts("")
ttfile.puts("#ifndef _HDR_gsiDeclQtTypeTraits") ttfile.puts("#ifndef _HDR_gsiDecl#{modn}TypeTraits")
ttfile.puts("#define _HDR_gsiDeclQtTypeTraits") ttfile.puts("#define _HDR_gsiDecl#{modn}TypeTraits")
ttfile.puts("") ttfile.puts("")
ttfile.puts("#include \"gsiTypes.h\"") ttfile.puts("#include \"gsiTypes.h\"")
ttfile.puts("") ttfile.puts("")
@ -2932,7 +2950,7 @@ END
if decl_obj.is_a?(CPPStructDeclaration) 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) elsif decl_obj.is_a?(CPPNamespace)
@ -3004,7 +3022,7 @@ END
extfile.puts("") extfile.puts("")
extfile.puts("#include \"gsiClassBase.h\"") extfile.puts("#include \"gsiClassBase.h\"")
extfile.puts("#include \"gsiQtCommon.h\"") extfile.puts("#include \"gsi#{modn}Common.h\"")
extfile.puts("") extfile.puts("")
@ext_decls.each do |ed| @ext_decls.each do |ed|
@ -3023,7 +3041,7 @@ END
def produce_makefile def produce_makefile
makefile_name = "qtdecl.pri" makefile_name = modn + ".pri"
makefile_path = $gen_dir + "/" + makefile_name makefile_path = $gen_dir + "/" + makefile_name
File.open(makefile_path, "w") do |makefile| File.open(makefile_path, "w") do |makefile|
@ -3047,6 +3065,16 @@ END
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 end
# --------------------------------------------------------------------- # ---------------------------------------------------------------------
@ -3058,6 +3086,7 @@ File.open(conf_file, "r") do |file|
end end
bp = BindingProducer::new bp = BindingProducer::new
bp.modn = modn
bp.read(input_file) bp.read(input_file)
puts("Collecting used enums ..") puts("Collecting used enums ..")
@ -3074,9 +3103,12 @@ if cls_list
end end
else else
bp.prod_list(conf).each do |decl_obj| 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
end end
bp.produce_class_list
puts("Producing type traits file ..") puts("Producing type traits file ..")
bp.produce_ttfile(conf) bp.produce_ttfile(conf)

23
scripts/mkqtdecl_common/reader_ext.rb
View File

@ -35,6 +35,12 @@ class CPPObject
nil nil
end 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 # delivers a CPPQualifiedId representation of the object's location or nil if the object
# does not have a location to contribute # does not have a location to contribute
def myid def myid
@ -155,8 +161,13 @@ module QualifiedNameResolver
@id2obj = {} @id2obj = {}
self.children.each do |d| self.children.each do |d|
d.myself && (@id2obj[d.myself] = d) d.myself && (@id2obj[d.myself] = d)
d.set_parent(self)
end 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 # Add other children, for example contributed by base classes
if self.respond_to?(:other_children) if self.respond_to?(:other_children)
self.other_children.each do |d| self.other_children.each do |d|
@ -171,6 +182,11 @@ module QualifiedNameResolver
end end
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 # returns a list of names of child objects
def ids def ids
(@id2obj || {}).keys.sort (@id2obj || {}).keys.sort
@ -390,6 +406,11 @@ class CPPStructDeclaration
end end
def myself_weak
# the weak identity will also include forward declarations
self.struct.id.to_s
end
def myself def myself
# forward declarations (struct.body_decl == nil and no base classes) don't produce a name and # forward declarations (struct.body_decl == nil and no base classes) don't produce a name and
# will therefore not contribute # 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. // 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::method ("register_template", &gsi::register_annotation_template,
gsi::arg ("annotation"), gsi::arg ("title"), gsi::arg ("mode", ruler_mode_normal (), "\\RulerModeNormal"), gsi::arg ("annotation"), gsi::arg ("title"), gsi::arg ("mode", ruler_mode_normal (), "\\RulerModeNormal"),
"@brief Registers the given annotation as a template\n" "@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<, gsi::method ("<", &lay::ObjectInstPath::operator<,
"@brief Provides an order criterion for two ObjectInstPath objects\n" "@brief Provides an order criterion for two ObjectInstPath objects\n"
"@args b\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 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, gsi::method ("layer_map", (db::LayerMap &(LEFDEFReaderOptions::*) ()) &LEFDEFReaderOptions::layer_map,
"@brief Gets the layer map to be used for the LEF/DEF reader\n" "@brief Gets the layer map to be used for the LEF/DEF reader\n"
"@return A reference to the layer map\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<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"), gsi::method_ext ("connection", &def_connection2, gsi::arg("a"), gsi::arg("b"),
"@brief Defines a connection between two materials\n" "@brief Defines a connection between two materials\n"
"See the class description for details about this method." "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); 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, gsi::method ("trans", &ext::NetTracerShape::trans,
"@brief Gets the transformation to apply for rendering the shape in the original top cell\n" "@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." "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" "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"), 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" "@brief Runs a net extraction\n"
"\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. // The dummy class is just provided to avoid some assertions.
struct EmptyClass { }; 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) 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 * This feature is not quite useful usually and is reserved for special use cases
* such as including enums into a declaration namespace. * 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) : ClassBase (doc, Methods ()), mp_declaration (&import)
{ {
set_module (module);
set_name (name); 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_default_constructor has_default_ctor;
typedef typename tl::type_traits<X>::has_public_destructor has_public_dtor; 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) : ClassBase (doc, mm, do_register)
{ {
set_module (module);
set_name (name); set_name (name);
} }
template <class B> 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> ()) : ClassBase (doc, mm, do_register), m_subclass_tester (new SubClassTester<X, B, typename is_polymorphic<B>::value> ())
{ {
set_module (module);
set_name (name); set_name (name);
set_base (&base); 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) : ClassBase (doc, Methods (), do_register)
{ {
set_module (module);
set_name (name); set_name (name);
} }
template <class B> 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> ()) : ClassBase (doc, Methods (), do_register), m_subclass_tester (new SubClassTester<X, B, typename is_polymorphic<B>::value> ())
{ {
set_module (module);
set_name (name); set_name (name);
set_base (&base); set_base (&base);
} }
@ -909,14 +914,14 @@ class SubClass
: public Class<X, Adapted> : public Class<X, Adapted>
{ {
public: public:
SubClass (const std::string &name, const Methods &mm, const std::string &doc = std::string ()) SubClass (const std::string &module, const std::string &name, const Methods &mm, const std::string &doc = std::string ())
: Class<X, Adapted> (name, mm, doc) : Class<X, Adapted> (module, name, mm, doc)
{ {
// .. nothing yet .. // .. nothing yet ..
} }
SubClass (const std::string &name, const std::string &doc = std::string ()) SubClass (const std::string &module, const std::string &name, const std::string &doc = std::string ())
: Class<X, Adapted> (name, doc) : Class<X, Adapted> (module, name, doc)
{ {
// .. nothing yet .. // .. nothing yet ..
} }
@ -941,14 +946,14 @@ class GSI_PUBLIC_TEMPLATE ChildClass
: public Class<X, Adapted> : public Class<X, Adapted>
{ {
public: public:
ChildClass (const std::string &name, const Methods &mm, const std::string &doc = std::string ()) ChildClass (const std::string &module, const std::string &name, const Methods &mm, const std::string &doc = std::string ())
: Class<X, Adapted> (name, mm, doc) : Class<X, Adapted> (module, name, mm, doc)
{ {
// .. nothing yet .. // .. nothing yet ..
} }
ChildClass (const std::string &name, const std::string &doc = std::string ()) ChildClass (const std::string &module, const std::string &name, const std::string &doc = std::string ())
: Class<X, Adapted> (name, doc) : Class<X, Adapted> (module, name, doc)
{ {
// .. nothing yet .. // .. nothing yet ..
} }
@ -974,14 +979,14 @@ class GSI_PUBLIC_TEMPLATE ChildSubClass
: public SubClass<X, B, Adapted> : public SubClass<X, B, Adapted>
{ {
public: public:
ChildSubClass (const std::string &name, const Methods &mm, const std::string &doc = std::string ()) ChildSubClass (const std::string &module, const std::string &name, const Methods &mm, const std::string &doc = std::string ())
: SubClass<X, B, Adapted> (name, mm, doc) : SubClass<X, B, Adapted> (module, name, mm, doc)
{ {
// .. nothing yet .. // .. nothing yet ..
} }
ChildSubClass (const std::string &name, const std::string &doc = std::string ()) ChildSubClass (const std::string &module, const std::string &name, const std::string &doc = std::string ())
: SubClass<X, B, Adapted> (name, doc) : SubClass<X, B, Adapted> (module, name, doc)
{ {
// .. nothing yet .. // .. nothing yet ..
} }

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

@ -144,6 +144,14 @@ public:
return m_name; return m_name;
} }
/**
* @brief Gets the module name
*/
const std::string &module () const
{
return m_module;
}
/** /**
* @brief Gets the documentation string * @brief Gets the documentation string
*/ */
@ -559,6 +567,11 @@ protected:
m_name = n; m_name = n;
} }
void set_module (const std::string &m)
{
m_module = m;
}
void set_parent (const ClassBase *parent); void set_parent (const ClassBase *parent);
void set_base (const ClassBase *base); void set_base (const ClassBase *base);
@ -568,6 +581,7 @@ private:
Methods m_methods; Methods m_methods;
std::vector<MethodBase *> m_callbacks, m_constructors; std::vector<MethodBase *> m_callbacks, m_constructors;
std::string m_name; std::string m_name;
std::string m_module;
tl::weak_collection<ClassBase> m_child_classes, m_subclasses; tl::weak_collection<ClassBase> m_child_classes, m_subclasses;
mutable std::auto_ptr<PerClassClientSpecificData> mp_data[ClientIndex::MaxClientIndex]; 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) #if !defined(HDR_gsiCommon_h)
# define HDR_gsiCommon_h # define HDR_gsiCommon_h
# if defined _WIN32 || defined __CYGWIN__ // NOTE: this is required because we have some forward declarations to
// gsi::Class and gsi::ClassBase in tlVariant.h.
# ifdef MAKE_GSI_LIBRARY // TODO: there should not be any dependency of tl on gsi.
# define GSI_PUBLIC __declspec(dllexport) # ifdef MAKE_GSI_LIBRARY
# else # define GSI_PUBLIC DEF_INSIDE_PUBLIC
# define GSI_PUBLIC __declspec(dllimport) # define GSI_PUBLIC_TEMPLATE DEF_INSIDE_PUBLIC_TEMPLATE
# endif # define GSI_LOCAL DEF_INSIDE_LOCAL
# define GSI_LOCAL
# define GSI_PUBLIC_TEMPLATE
# else # else
# define GSI_PUBLIC DEF_OUTSIDE_PUBLIC
# if __GNUC__ >= 4 || defined(__clang__) # define GSI_PUBLIC_TEMPLATE DEF_OUTSIDE_PUBLIC_TEMPLATE
# define GSI_PUBLIC __attribute__ ((visibility ("default"))) # define GSI_LOCAL DEF_OUTSIDE_LOCAL
# 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
# endif # endif
#endif #endif

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

@ -41,7 +41,7 @@ static gsi::Value *new_vv0 ()
return new gsi::Value (); return new gsi::Value ();
} }
Class<Value> decl_Value ("Value", Class<Value> decl_Value ("tl", "Value",
gsi::constructor ("new", &new_vv0, gsi::constructor ("new", &new_vv0,
"@brief Constructs a nil object.\n" "@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; 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 ("TypeVoid|#t_void", &t_void) +
gsi::method ("TypeBool|#t_bool", &t_bool) + gsi::method ("TypeBool|#t_bool", &t_bool) +
gsi::method ("TypeChar|#t_char", &t_char) + 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; return syn->is_setter;
} }
Class<MethodBase::MethodSynonym> decl_MethodOverload ("MethodOverload", Class<MethodBase::MethodSynonym> decl_MethodOverload ("tl", "MethodOverload",
gsi::method_ext ("name", &_syn_name, gsi::method_ext ("name", &_syn_name,
"@brief The name of this overload\n" "@brief The name of this overload\n"
"This is the raw, unadorned name. I.e. no question mark suffix for predicates, no " "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" "@hide"
); );
Class<MethodBase> decl_Method ("Method", Class<MethodBase> decl_Method ("tl", "Method",
gsi::iterator ("each_argument", &MethodBase::begin_arguments, &MethodBase::end_arguments, gsi::iterator ("each_argument", &MethodBase::begin_arguments, &MethodBase::end_arguments,
"@brief Iterate over all arguments of this method\n" "@brief Iterate over all arguments of this method\n"
) + ) +
@ -291,7 +291,7 @@ Class<MethodBase> decl_Method ("Method",
"@hide" "@hide"
); );
Class<ClassBase> decl_Class ("Class", Class<ClassBase> decl_Class ("tl", "Class",
gsi::iterator ("each_class", &ClassBase::begin_classes, &ClassBase::end_classes, gsi::iterator ("each_class", &ClassBase::begin_classes, &ClassBase::end_classes,
"@brief Iterate over all classes\n" "@brief Iterate over all classes\n"
) + ) +

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

@ -87,7 +87,7 @@ namespace tl {
namespace gsi namespace gsi
{ {
Class<Logger> decl_Logger ("Logger", Class<Logger> decl_Logger ("tl", "Logger",
gsi::method ("info", &Logger::info, gsi::method ("info", &Logger::info,
"@brief Writes the given string to the info channel\n" "@brief Writes the given string to the info channel\n"
"@args msg\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 ()); 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, gsi::method ("user", &tl::Timer::sec_user,
"@brief Returns the elapsed CPU time in user mode from start to stop in seconds\n" "@brief Returns the elapsed CPU time in user mode from start to stop in seconds\n"
) + ) +
@ -217,7 +217,7 @@ namespace tl {
namespace gsi namespace gsi
{ {
Class<tl::Progress> decl_Progress ("Progress", Class<tl::Progress> decl_Progress ("tl", "Progress",
gsi::method ("desc=", &tl::Progress::set_desc, gsi::method ("desc=", &tl::Progress::set_desc,
"@brief Sets the description text of the progress object\n" "@brief Sets the description text of the progress object\n"
"@args desc\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); 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, gsi::constructor ("new", &rel_progress_2,
"@brief Creates a relative progress reporter with the given description and maximum value\n" "@brief Creates a relative progress reporter with the given description and maximum value\n"
"@args desc, max_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); 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, gsi::constructor ("new", &abs_progress_1,
"@brief Creates an absolute progress reporter with the given description\n" "@brief Creates an absolute progress reporter with the given description\n"
"@args desc, max_value\n" "@args desc, max_value\n"
@ -518,7 +518,7 @@ namespace tl {
namespace gsi namespace gsi
{ {
Class<ExpressionWrapper> decl_ExpressionWrapper ("Expression", Class<ExpressionWrapper> decl_ExpressionWrapper ("tl", "Expression",
gsi::constructor ("new", &new_expr1, gsi::arg ("expr"), gsi::constructor ("new", &new_expr1, gsi::arg ("expr"),
"@brief Creates an expression evaluator\n" "@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 Class<EnumAdaptor<E>, E>
{ {
public: public:
Enum (const std::string &name, const EnumSpecs<E> &specs, const std::string &doc = std::string ()) Enum (const std::string &module, 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) : Class<EnumAdaptor<E>, E> (module, name, specs.methods (), doc), m_specs (specs)
{ {
} }
@ -389,8 +389,8 @@ public:
typedef int int_repr; typedef int int_repr;
#endif #endif
QFlagsClass (const std::string &name, const std::string &doc = std::string ()) QFlagsClass (const std::string &module, const std::string &name, const std::string &doc = std::string ())
: Class<QFlagsAdaptor<E>, QFlags<E> > (name, methods (), doc), : Class<QFlagsAdaptor<E>, QFlags<E> > (module, name, methods (), doc),
m_enum_ext (ext_methods ()) 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::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::constructor ("new_a|new", &a_ctor) +
gsi::method ("br", &A::br) + gsi::method ("br", &A::br) +
gsi::method ("get_e", &A::get_e) + 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) 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 ("inst", &B::inst) +
gsi::method ("has_inst", &B::has_inst) + gsi::method ("has_inst", &B::has_inst) +
gsi::method ("set_inst", &B::set_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::callback ("f", &C_P::f, &C_P::f_cb) +
gsi::method ("g", &C_P::g) + gsi::method ("g", &C_P::g) +
gsi::method ("s1", &C::s1) + 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; } 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 ("e0", &E::ev0) +
gsi::event_ext ("e1", &ev1_ext) + gsi::event_ext ("e1", &ev1_ext) +
gsi::event ("e2", &E::ev2) + gsi::event ("e2", &E::ev2) +
@ -1062,7 +1062,7 @@ static gsi::Class<E> decl_e ("E",
gsi::method ("reset_inst", &E::reset_inst) 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 ("ic", &F::ic) +
gsi::method ("inc", &F::inc) + gsi::method ("inc", &F::inc) +
gsi::method ("icref", &F::icref) + gsi::method ("icref", &F::icref) +
@ -1071,7 +1071,7 @@ static gsi::Class<F> decl_f ("F",
gsi::method ("x", &F::get_x) 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 ("iv", &G::iv) +
gsi::method ("sv", &G::sv) + gsi::method ("sv", &G::sv) +
gsi::method ("set_iva", &G::set_iv, gsi::arg ()) + 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")) 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::constructor ("new", &make_x) +
gsi::method ("instances", &X::instances) + gsi::method ("instances", &X::instances) +
gsi::method ("x1", &X::x1) + gsi::method ("x1", &X::x1) +
@ -1102,7 +1102,7 @@ static gsi::Class<X> decl_x ("X",
gsi::method ("s=", &X::set_si) 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::constructor ("new", &make_y) +
gsi::method ("x1", &Y::x1) + gsi::method ("x1", &Y::x1) +
gsi::method ("y1", &Y::y1) + 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) 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) 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) 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::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::method ("f", &Z_P::f_org) +
gsi::callback ("f", &Z_P::f, &Z_P::f_cb) + gsi::callback ("f", &Z_P::f, &Z_P::f_cb) +
gsi::method ("f_with_x", &Z_P::f_with_x) + 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::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_s0", &SQ::trigger_s0) +
gsi::method ("trigger_s1", &SQ::trigger_s1) + gsi::method ("trigger_s1", &SQ::trigger_s1) +
gsi::method ("trigger_s2", &SQ::trigger_s2) + 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::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_s0", &SE::trigger_s0) +
gsi::method ("trigger_s1", &SE::trigger_s1) + gsi::method ("trigger_s1", &SE::trigger_s1) +
gsi::method ("trigger_s2", &SE::trigger_s2) + gsi::method ("trigger_s2", &SE::trigger_s2) +
@ -1222,12 +1222,12 @@ int g_virtual (GObject *go)
return go->g (); 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::method_ext ("g_virtual", &g_virtual) +
gsi::Methods() 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::method_ext ("g_org", &g_org) +
gsi::callback ("g", &GObject_P::g, &GObject_P::g_cb) + gsi::callback ("g", &GObject_P::g, &GObject_P::g_cb) +
gsi::method ("g_inst_count", &GObject::g_inst_count) 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); 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) 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::method_ext ("f", &f_org) +
gsi::factory_callback ("f", &GFactory_P::f, &GFactory_P::f_cb) 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/.. TEMPLATE = subdirs
TARGET = klayout_gsiqt SUBDIRS = qtbasic
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
equals(HAVE_QT5, "1") { equals(HAVE_QT5, "1") {
include($$PWD/../gsiqt5/qtdecl.pri) SUBDIRS += qt5
qt5.depends += qtbasic
} else { } 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 <QThread>
#include <QTimerEvent> #include <QTimerEvent>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -1016,11 +1016,11 @@ static gsi::Methods methods_QAbstractItemModel () {
gsi::Class<QObject> &qtdecl_QObject (); 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 (), methods_QAbstractItemModel (),
"@hide\n@alias 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; 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 (), methods_QAbstractItemModel_Adaptor (),
"@qt\n@brief Binding of QAbstractItemModel"); "@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 <QThread>
#include <QTimerEvent> #include <QTimerEvent>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -230,11 +230,11 @@ static gsi::Methods methods_QAbstractListModel () {
gsi::Class<QAbstractItemModel> &qtdecl_QAbstractItemModel (); 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 (), methods_QAbstractListModel (),
"@hide\n@alias 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; 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 (), methods_QAbstractListModel_Adaptor (),
"@qt\n@brief Binding of QAbstractListModel"); "@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 <QThread>
#include <QTimerEvent> #include <QTimerEvent>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -230,11 +230,11 @@ static gsi::Methods methods_QAbstractTableModel () {
gsi::Class<QAbstractItemModel> &qtdecl_QAbstractItemModel (); 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 (), methods_QAbstractTableModel (),
"@hide\n@alias 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; 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 (), methods_QAbstractTableModel_Adaptor (),
"@qt\n@brief Binding of QAbstractTableModel"); "@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 <QBasicTimer>
#include <QObject> #include <QObject>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -135,12 +135,12 @@ static gsi::Methods methods_QBasicTimer () {
return methods; return methods;
} }
gsi::Class<QBasicTimer> decl_QBasicTimer ("QBasicTimer", gsi::Class<QBasicTimer> decl_QBasicTimer ("QtCore", "QBasicTimer",
methods_QBasicTimer (), methods_QBasicTimer (),
"@qt\n@brief Binding of 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 <QThread>
#include <QTimerEvent> #include <QTimerEvent>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -447,12 +447,12 @@ static gsi::Methods methods_QBuffer () {
gsi::Class<QIODevice> &qtdecl_QIODevice (); 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 (), methods_QBuffer (),
"@qt\n@brief Binding of 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 <QByteArrayMatcher>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -207,12 +207,12 @@ static gsi::Methods methods_QByteArrayMatcher () {
return methods; return methods;
} }
gsi::Class<QByteArrayMatcher> decl_QByteArrayMatcher ("QByteArrayMatcher", gsi::Class<QByteArrayMatcher> decl_QByteArrayMatcher ("QtCore", "QByteArrayMatcher",
methods_QByteArrayMatcher (), methods_QByteArrayMatcher (),
"@qt\n@brief Binding of 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 <QChildEvent>
#include <QObject> #include <QObject>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -51,7 +51,7 @@
{ {
public: public:
RawQObjectClass () 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<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", gsi::Methods(new qt_gsi::GenericMethod ("child",
"@brief Method QObject *QChildEvent::child()\n" "@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" "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 (), methods_QChildEvent (),
"@hide\n@alias 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; 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 (), methods_QChildEvent_Adaptor (),
"@qt\n@brief Binding of QChildEvent"); "@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 <QTimerEvent>
#include <QTranslator> #include <QTranslator>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -993,11 +993,11 @@ static gsi::Methods methods_QCoreApplication () {
gsi::Class<QObject> &qtdecl_QObject (); 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 (), methods_QCoreApplication (),
"@hide\n@alias 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; 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 (), methods_QCoreApplication_Adaptor (),
"@qt\n@brief Binding of QCoreApplication"); "@qt\n@brief Binding of QCoreApplication");
@ -1445,19 +1445,19 @@ gsi::Class<QCoreApplication_Adaptor> decl_QCoreApplication_Adaptor (qtdecl_QCore
namespace qt_gsi 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 ("CodecForTr", QCoreApplication::CodecForTr, "@brief Enum constant QCoreApplication::CodecForTr") +
gsi::enum_const ("UnicodeUTF8", QCoreApplication::UnicodeUTF8, "@brief Enum constant QCoreApplication::UnicodeUTF8") + gsi::enum_const ("UnicodeUTF8", QCoreApplication::UnicodeUTF8, "@brief Enum constant QCoreApplication::UnicodeUTF8") +
gsi::enum_const ("DefaultCodec", QCoreApplication::DefaultCodec, "@brief Enum constant QCoreApplication::DefaultCodec"), gsi::enum_const ("DefaultCodec", QCoreApplication::DefaultCodec, "@brief Enum constant QCoreApplication::DefaultCodec"),
"@qt\n@brief This class represents the QCoreApplication::Encoding enum"); "@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"); "@qt\n@brief This class represents the QFlags<QCoreApplication::Encoding> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QCoreApplication_Encoding_Enum, "QtCore", "Encoding");
static gsi::ClassExt<QCoreApplication> decl_QCoreApplication_Encoding_Enums_as_child (decl_QCoreApplication_Encoding_Enums, "QFlags_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 <QCryptographicHash>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -166,12 +166,12 @@ static gsi::Methods methods_QCryptographicHash () {
return methods; return methods;
} }
gsi::Class<QCryptographicHash> decl_QCryptographicHash ("QCryptographicHash", gsi::Class<QCryptographicHash> decl_QCryptographicHash ("QtCore", "QCryptographicHash",
methods_QCryptographicHash (), methods_QCryptographicHash (),
"@qt\n@brief Binding of 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 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 ("Md4", QCryptographicHash::Md4, "@brief Enum constant QCryptographicHash::Md4") +
gsi::enum_const ("Md5", QCryptographicHash::Md5, "@brief Enum constant QCryptographicHash::Md5") + gsi::enum_const ("Md5", QCryptographicHash::Md5, "@brief Enum constant QCryptographicHash::Md5") +
gsi::enum_const ("Sha1", QCryptographicHash::Sha1, "@brief Enum constant QCryptographicHash::Sha1"), gsi::enum_const ("Sha1", QCryptographicHash::Sha1, "@brief Enum constant QCryptographicHash::Sha1"),
"@qt\n@brief This class represents the QCryptographicHash::Algorithm enum"); "@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"); "@qt\n@brief This class represents the QFlags<QCryptographicHash::Algorithm> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QCryptographicHash_Algorithm_Enum, "QtCore", "Algorithm");
static gsi::ClassExt<QCryptographicHash> decl_QCryptographicHash_Algorithm_Enums_as_child (decl_QCryptographicHash_Algorithm_Enums, "QFlags_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 <QDataStream>
#include <QIODevice> #include <QIODevice>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -554,7 +554,7 @@ static gsi::Methods methods_QDataStream () {
return methods; 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_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_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>>") + 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 (), methods_QDataStream (),
"@hide\n@alias 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; 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 (), methods_QDataStream_Adaptor (),
"@qt\n@brief Binding of QDataStream"); "@qt\n@brief Binding of QDataStream");
@ -727,18 +727,18 @@ gsi::Class<QDataStream_Adaptor> decl_QDataStream_Adaptor (qtdecl_QDataStream (),
namespace qt_gsi 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 ("BigEndian", QDataStream::BigEndian, "@brief Enum constant QDataStream::BigEndian") +
gsi::enum_const ("LittleEndian", QDataStream::LittleEndian, "@brief Enum constant QDataStream::LittleEndian"), gsi::enum_const ("LittleEndian", QDataStream::LittleEndian, "@brief Enum constant QDataStream::LittleEndian"),
"@qt\n@brief This class represents the QDataStream::ByteOrder enum"); "@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"); "@qt\n@brief This class represents the QFlags<QDataStream::ByteOrder> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QDataStream_ByteOrder_Enum, "QtCore", "ByteOrder");
static gsi::ClassExt<QDataStream> decl_QDataStream_ByteOrder_Enums_as_child (decl_QDataStream_ByteOrder_Enums, "QFlags_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 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 ("SinglePrecision", QDataStream::SinglePrecision, "@brief Enum constant QDataStream::SinglePrecision") +
gsi::enum_const ("DoublePrecision", QDataStream::DoublePrecision, "@brief Enum constant QDataStream::DoublePrecision"), gsi::enum_const ("DoublePrecision", QDataStream::DoublePrecision, "@brief Enum constant QDataStream::DoublePrecision"),
"@qt\n@brief This class represents the QDataStream::FloatingPointPrecision enum"); "@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"); "@qt\n@brief This class represents the QFlags<QDataStream::FloatingPointPrecision> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QDataStream_FloatingPointPrecision_Enum, "QtCore", "FloatingPointPrecision");
static gsi::ClassExt<QDataStream> decl_QDataStream_FloatingPointPrecision_Enums_as_child (decl_QDataStream_FloatingPointPrecision_Enums, "QFlags_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 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 ("Ok", QDataStream::Ok, "@brief Enum constant QDataStream::Ok") +
gsi::enum_const ("ReadPastEnd", QDataStream::ReadPastEnd, "@brief Enum constant QDataStream::ReadPastEnd") + gsi::enum_const ("ReadPastEnd", QDataStream::ReadPastEnd, "@brief Enum constant QDataStream::ReadPastEnd") +
gsi::enum_const ("ReadCorruptData", QDataStream::ReadCorruptData, "@brief Enum constant QDataStream::ReadCorruptData"), gsi::enum_const ("ReadCorruptData", QDataStream::ReadCorruptData, "@brief Enum constant QDataStream::ReadCorruptData"),
"@qt\n@brief This class represents the QDataStream::Status enum"); "@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"); "@qt\n@brief This class represents the QFlags<QDataStream::Status> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QDataStream_Status_Enum, "QtCore", "Status");
static gsi::ClassExt<QDataStream> decl_QDataStream_Status_Enums_as_child (decl_QDataStream_Status_Enums, "QFlags_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 <QDate>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -942,12 +942,12 @@ static gsi::Methods methods_QDate () {
return methods; return methods;
} }
gsi::Class<QDate> decl_QDate ("QDate", gsi::Class<QDate> decl_QDate ("QtCore", "QDate",
methods_QDate (), methods_QDate (),
"@qt\n@brief Binding of 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 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 ("DateFormat", QDate::DateFormat, "@brief Enum constant QDate::DateFormat") +
gsi::enum_const ("StandaloneFormat", QDate::StandaloneFormat, "@brief Enum constant QDate::StandaloneFormat"), gsi::enum_const ("StandaloneFormat", QDate::StandaloneFormat, "@brief Enum constant QDate::StandaloneFormat"),
"@qt\n@brief This class represents the QDate::MonthNameType enum"); "@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"); "@qt\n@brief This class represents the QFlags<QDate::MonthNameType> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QDate_MonthNameType_Enum, "QtCore", "MonthNameType");
static gsi::ClassExt<QDate> decl_QDate_MonthNameType_Enums_as_child (decl_QDate_MonthNameType_Enums, "QFlags_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 <QDate>
#include <QTime> #include <QTime>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -800,12 +800,12 @@ static gsi::Methods methods_QDateTime () {
return methods; return methods;
} }
gsi::Class<QDateTime> decl_QDateTime ("QDateTime", gsi::Class<QDateTime> decl_QDateTime ("QtCore", "QDateTime",
methods_QDateTime (), methods_QDateTime (),
"@qt\n@brief Binding of 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 <QDir>
#include <QFileInfo> #include <QFileInfo>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -1332,12 +1332,12 @@ static gsi::Methods methods_QDir () {
return methods; return methods;
} }
gsi::Class<QDir> decl_QDir ("QDir", gsi::Class<QDir> decl_QDir ("QtCore", "QDir",
methods_QDir (), methods_QDir (),
"@qt\n@brief Binding of 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 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 ("Dirs", QDir::Dirs, "@brief Enum constant QDir::Dirs") +
gsi::enum_const ("Files", QDir::Files, "@brief Enum constant QDir::Files") + gsi::enum_const ("Files", QDir::Files, "@brief Enum constant QDir::Files") +
gsi::enum_const ("Drives", QDir::Drives, "@brief Enum constant QDir::Drives") + 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"), gsi::enum_const ("NoFilter", QDir::NoFilter, "@brief Enum constant QDir::NoFilter"),
"@qt\n@brief This class represents the QDir::Filter enum"); "@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"); "@qt\n@brief This class represents the QFlags<QDir::Filter> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QDir_Filter_Enum, "QtCore", "Filter");
static gsi::ClassExt<QDir> decl_QDir_Filter_Enums_as_child (decl_QDir_Filter_Enums, "QFlags_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 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 ("Name", QDir::Name, "@brief Enum constant QDir::Name") +
gsi::enum_const ("Time", QDir::Time, "@brief Enum constant QDir::Time") + gsi::enum_const ("Time", QDir::Time, "@brief Enum constant QDir::Time") +
gsi::enum_const ("Size", QDir::Size, "@brief Enum constant QDir::Size") + 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"), gsi::enum_const ("NoSort", QDir::NoSort, "@brief Enum constant QDir::NoSort"),
"@qt\n@brief This class represents the QDir::SortFlag enum"); "@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"); "@qt\n@brief This class represents the QFlags<QDir::SortFlag> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QDir_SortFlag_Enum, "QtCore", "SortFlag");
static gsi::ClassExt<QDir> decl_QDir_SortFlag_Enums_as_child (decl_QDir_SortFlag_Enums, "QFlags_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 <QDynamicPropertyChangeEvent>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -62,11 +62,11 @@ static gsi::Methods methods_QDynamicPropertyChangeEvent () {
gsi::Class<QEvent> &qtdecl_QEvent (); 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 (), methods_QDynamicPropertyChangeEvent (),
"@hide\n@alias 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; 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 (), methods_QDynamicPropertyChangeEvent_Adaptor (),
"@qt\n@brief Binding of QDynamicPropertyChangeEvent"); "@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 <QEasingCurve>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -313,12 +313,12 @@ static gsi::Methods methods_QEasingCurve () {
return methods; return methods;
} }
gsi::Class<QEasingCurve> decl_QEasingCurve ("QEasingCurve", gsi::Class<QEasingCurve> decl_QEasingCurve ("QtCore", "QEasingCurve",
methods_QEasingCurve (), methods_QEasingCurve (),
"@qt\n@brief Binding of 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 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 ("Linear", QEasingCurve::Linear, "@brief Enum constant QEasingCurve::Linear") +
gsi::enum_const ("InQuad", QEasingCurve::InQuad, "@brief Enum constant QEasingCurve::InQuad") + gsi::enum_const ("InQuad", QEasingCurve::InQuad, "@brief Enum constant QEasingCurve::InQuad") +
gsi::enum_const ("OutQuad", QEasingCurve::OutQuad, "@brief Enum constant QEasingCurve::OutQuad") + 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"), gsi::enum_const ("NCurveTypes", QEasingCurve::NCurveTypes, "@brief Enum constant QEasingCurve::NCurveTypes"),
"@qt\n@brief This class represents the QEasingCurve::Type enum"); "@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"); "@qt\n@brief This class represents the QFlags<QEasingCurve::Type> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QEasingCurve_Type_Enum, "QtCore", "Type");
static gsi::ClassExt<QEasingCurve> decl_QEasingCurve_Type_Enums_as_child (decl_QEasingCurve_Type_Enums, "QFlags_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 <QEvent>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -167,11 +167,11 @@ static gsi::Methods methods_QEvent () {
return methods; return methods;
} }
gsi::Class<QEvent> decl_QEvent ("QEvent_Native", gsi::Class<QEvent> decl_QEvent ("QtCore", "QEvent_Native",
methods_QEvent (), methods_QEvent (),
"@hide\n@alias 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; 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 (), methods_QEvent_Adaptor (),
"@qt\n@brief Binding of QEvent"); "@qt\n@brief Binding of QEvent");
@ -233,7 +233,7 @@ gsi::Class<QEvent_Adaptor> decl_QEvent_Adaptor (qtdecl_QEvent (), "QEvent",
namespace qt_gsi 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 ("None", QEvent::None, "@brief Enum constant QEvent::None") +
gsi::enum_const ("Timer", QEvent::Timer, "@brief Enum constant QEvent::Timer") + gsi::enum_const ("Timer", QEvent::Timer, "@brief Enum constant QEvent::Timer") +
gsi::enum_const ("MouseButtonPress", QEvent::MouseButtonPress, "@brief Enum constant QEvent::MouseButtonPress") + 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"), gsi::enum_const ("MaxUser", QEvent::MaxUser, "@brief Enum constant QEvent::MaxUser"),
"@qt\n@brief This class represents the QEvent::Type enum"); "@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"); "@qt\n@brief This class represents the QFlags<QEvent::Type> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QEvent_Type_Enum, "QtCore", "Type");
static gsi::ClassExt<QEvent> decl_QEvent_Type_Enums_as_child (decl_QEvent_Type_Enums, "QFlags_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 <QThread>
#include <QTimerEvent> #include <QTimerEvent>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -299,11 +299,11 @@ static gsi::Methods methods_QEventLoop () {
gsi::Class<QObject> &qtdecl_QObject (); 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 (), methods_QEventLoop (),
"@hide\n@alias 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; 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 (), methods_QEventLoop_Adaptor (),
"@qt\n@brief Binding of QEventLoop"); "@qt\n@brief Binding of QEventLoop");
@ -692,7 +692,7 @@ gsi::Class<QEventLoop_Adaptor> decl_QEventLoop_Adaptor (qtdecl_QEventLoop (), "Q
namespace qt_gsi 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 ("AllEvents", QEventLoop::AllEvents, "@brief Enum constant QEventLoop::AllEvents") +
gsi::enum_const ("ExcludeUserInputEvents", QEventLoop::ExcludeUserInputEvents, "@brief Enum constant QEventLoop::ExcludeUserInputEvents") + gsi::enum_const ("ExcludeUserInputEvents", QEventLoop::ExcludeUserInputEvents, "@brief Enum constant QEventLoop::ExcludeUserInputEvents") +
gsi::enum_const ("ExcludeSocketNotifiers", QEventLoop::ExcludeSocketNotifiers, "@brief Enum constant QEventLoop::ExcludeSocketNotifiers") + 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"), gsi::enum_const ("DialogExec", QEventLoop::DialogExec, "@brief Enum constant QEventLoop::DialogExec"),
"@qt\n@brief This class represents the QEventLoop::ProcessEventsFlag enum"); "@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"); "@qt\n@brief This class represents the QFlags<QEventLoop::ProcessEventsFlag> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QEventLoop_ProcessEventsFlag_Enum, "QtCore", "ProcessEventsFlag");
static gsi::ClassExt<QEventLoop> decl_QEventLoop_ProcessEventsFlag_Enums_as_child (decl_QEventLoop_ProcessEventsFlag_Enums, "QFlags_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 <QFactoryInterface>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -60,11 +60,11 @@ static gsi::Methods methods_QFactoryInterface () {
return methods; return methods;
} }
gsi::Class<QFactoryInterface> decl_QFactoryInterface ("QFactoryInterface_Native", gsi::Class<QFactoryInterface> decl_QFactoryInterface ("QtCore", "QFactoryInterface_Native",
methods_QFactoryInterface (), methods_QFactoryInterface (),
"@hide\n@alias 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; 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 (), methods_QFactoryInterface_Adaptor (),
"@qt\n@brief Binding of QFactoryInterface"); "@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 <QThread>
#include <QTimerEvent> #include <QTimerEvent>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -906,12 +906,12 @@ static gsi::Methods methods_QFile () {
gsi::Class<QIODevice> &qtdecl_QIODevice (); 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 (), methods_QFile (),
"@qt\n@brief Binding of 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 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 ("NoError", QFile::NoError, "@brief Enum constant QFile::NoError") +
gsi::enum_const ("ReadError", QFile::ReadError, "@brief Enum constant QFile::ReadError") + gsi::enum_const ("ReadError", QFile::ReadError, "@brief Enum constant QFile::ReadError") +
gsi::enum_const ("WriteError", QFile::WriteError, "@brief Enum constant QFile::WriteError") + 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"), gsi::enum_const ("CopyError", QFile::CopyError, "@brief Enum constant QFile::CopyError"),
"@qt\n@brief This class represents the QFile::FileError enum"); "@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"); "@qt\n@brief This class represents the QFlags<QFile::FileError> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QFile_FileError_Enum, "QtCore", "FileError");
static gsi::ClassExt<QFile> decl_QFile_FileError_Enums_as_child (decl_QFile_FileError_Enums, "QFlags_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 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 ("ReadOwner", QFile::ReadOwner, "@brief Enum constant QFile::ReadOwner") +
gsi::enum_const ("WriteOwner", QFile::WriteOwner, "@brief Enum constant QFile::WriteOwner") + gsi::enum_const ("WriteOwner", QFile::WriteOwner, "@brief Enum constant QFile::WriteOwner") +
gsi::enum_const ("ExeOwner", QFile::ExeOwner, "@brief Enum constant QFile::ExeOwner") + 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"), gsi::enum_const ("ExeOther", QFile::ExeOther, "@brief Enum constant QFile::ExeOther"),
"@qt\n@brief This class represents the QFile::Permission enum"); "@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"); "@qt\n@brief This class represents the QFlags<QFile::Permission> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QFile_Permission_Enum, "QtCore", "Permission");
static gsi::ClassExt<QFile> decl_QFile_Permission_Enums_as_child (decl_QFile_Permission_Enums, "QFlags_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 <QDir>
#include <QFile> #include <QFile>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -1012,12 +1012,12 @@ static gsi::Methods methods_QFileInfo () {
return methods; return methods;
} }
gsi::Class<QFileInfo> decl_QFileInfo ("QFileInfo", gsi::Class<QFileInfo> decl_QFileInfo ("QtCore", "QFileInfo",
methods_QFileInfo (), methods_QFileInfo (),
"@qt\n@brief Binding of 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 <QThread>
#include <QTimerEvent> #include <QTimerEvent>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -282,11 +282,11 @@ static gsi::Methods methods_QFileSystemWatcher () {
gsi::Class<QObject> &qtdecl_QObject (); 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 (), methods_QFileSystemWatcher (),
"@hide\n@alias 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; 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 (), methods_QFileSystemWatcher_Adaptor (),
"@qt\n@brief Binding of QFileSystemWatcher"); "@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 <QThread>
#include <QTimerEvent> #include <QTimerEvent>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -671,12 +671,12 @@ static gsi::Methods methods_QIODevice () {
gsi::Class<QObject> &qtdecl_QObject (); 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 (), methods_QIODevice (),
"@qt\n@brief Binding of 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 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 ("NotOpen", QIODevice::NotOpen, "@brief Enum constant QIODevice::NotOpen") +
gsi::enum_const ("ReadOnly", QIODevice::ReadOnly, "@brief Enum constant QIODevice::ReadOnly") + gsi::enum_const ("ReadOnly", QIODevice::ReadOnly, "@brief Enum constant QIODevice::ReadOnly") +
gsi::enum_const ("WriteOnly", QIODevice::WriteOnly, "@brief Enum constant QIODevice::WriteOnly") + 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"), gsi::enum_const ("Unbuffered", QIODevice::Unbuffered, "@brief Enum constant QIODevice::Unbuffered"),
"@qt\n@brief This class represents the QIODevice::OpenModeFlag enum"); "@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"); "@qt\n@brief This class represents the QFlags<QIODevice::OpenModeFlag> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QIODevice_OpenModeFlag_Enum, "QtCore", "OpenModeFlag");
static gsi::ClassExt<QIODevice> decl_QIODevice_OpenModeFlag_Enums_as_child (decl_QIODevice_OpenModeFlag_Enums, "QFlags_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 <QThread>
#include <QTimerEvent> #include <QTimerEvent>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -465,11 +465,11 @@ static gsi::Methods methods_QLibrary () {
gsi::Class<QObject> &qtdecl_QObject (); 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 (), methods_QLibrary (),
"@hide\n@alias 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; 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 (), methods_QLibrary_Adaptor (),
"@qt\n@brief Binding of QLibrary"); "@qt\n@brief Binding of QLibrary");
@ -966,19 +966,19 @@ gsi::Class<QLibrary_Adaptor> decl_QLibrary_Adaptor (qtdecl_QLibrary (), "QLibrar
namespace qt_gsi 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 ("ResolveAllSymbolsHint", QLibrary::ResolveAllSymbolsHint, "@brief Enum constant QLibrary::ResolveAllSymbolsHint") +
gsi::enum_const ("ExportExternalSymbolsHint", QLibrary::ExportExternalSymbolsHint, "@brief Enum constant QLibrary::ExportExternalSymbolsHint") + gsi::enum_const ("ExportExternalSymbolsHint", QLibrary::ExportExternalSymbolsHint, "@brief Enum constant QLibrary::ExportExternalSymbolsHint") +
gsi::enum_const ("LoadArchiveMemberHint", QLibrary::LoadArchiveMemberHint, "@brief Enum constant QLibrary::LoadArchiveMemberHint"), gsi::enum_const ("LoadArchiveMemberHint", QLibrary::LoadArchiveMemberHint, "@brief Enum constant QLibrary::LoadArchiveMemberHint"),
"@qt\n@brief This class represents the QLibrary::LoadHint enum"); "@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"); "@qt\n@brief This class represents the QFlags<QLibrary::LoadHint> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QLibrary_LoadHint_Enum, "QtCore", "LoadHint");
static gsi::ClassExt<QLibrary> decl_QLibrary_LoadHint_Enums_as_child (decl_QLibrary_LoadHint_Enums, "QFlags_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 <QLibraryInfo>
#include <QDate> #include <QDate>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -130,12 +130,12 @@ static gsi::Methods methods_QLibraryInfo () {
return methods; return methods;
} }
gsi::Class<QLibraryInfo> decl_QLibraryInfo ("QLibraryInfo", gsi::Class<QLibraryInfo> decl_QLibraryInfo ("QtCore", "QLibraryInfo",
methods_QLibraryInfo (), methods_QLibraryInfo (),
"@qt\n@brief Binding of 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 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 ("PrefixPath", QLibraryInfo::PrefixPath, "@brief Enum constant QLibraryInfo::PrefixPath") +
gsi::enum_const ("DocumentationPath", QLibraryInfo::DocumentationPath, "@brief Enum constant QLibraryInfo::DocumentationPath") + gsi::enum_const ("DocumentationPath", QLibraryInfo::DocumentationPath, "@brief Enum constant QLibraryInfo::DocumentationPath") +
gsi::enum_const ("HeadersPath", QLibraryInfo::HeadersPath, "@brief Enum constant QLibraryInfo::HeadersPath") + 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"), gsi::enum_const ("ExamplesPath", QLibraryInfo::ExamplesPath, "@brief Enum constant QLibraryInfo::ExamplesPath"),
"@qt\n@brief This class represents the QLibraryInfo::LibraryLocation enum"); "@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"); "@qt\n@brief This class represents the QFlags<QLibraryInfo::LibraryLocation> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QLibraryInfo_LibraryLocation_Enum, "QtCore", "LibraryLocation");
static gsi::ClassExt<QLibraryInfo> decl_QLibraryInfo_LibraryLocation_Enums_as_child (decl_QLibraryInfo_LibraryLocation_Enums, "QFlags_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 <QLine>
#include <QPoint> #include <QPoint>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #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 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 ("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 ("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 += 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; return methods;
} }
gsi::Class<QLine> decl_QLine ("QLine", gsi::Class<QLine> decl_QLine ("QtCore", "QLine",
methods_QLine (), methods_QLine (),
"@qt\n@brief Binding of 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 <QLine>
#include <QPointF> #include <QPointF>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #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 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 ("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::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 += 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; return methods;
} }
gsi::Class<QLineF> decl_QLineF ("QLineF", gsi::Class<QLineF> decl_QLineF ("QtCore", "QLineF",
methods_QLineF (), methods_QLineF (),
"@qt\n@brief Binding of 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 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 ("NoIntersection", QLineF::NoIntersection, "@brief Enum constant QLineF::NoIntersection") +
gsi::enum_const ("BoundedIntersection", QLineF::BoundedIntersection, "@brief Enum constant QLineF::BoundedIntersection") + gsi::enum_const ("BoundedIntersection", QLineF::BoundedIntersection, "@brief Enum constant QLineF::BoundedIntersection") +
gsi::enum_const ("UnboundedIntersection", QLineF::UnboundedIntersection, "@brief Enum constant QLineF::UnboundedIntersection"), gsi::enum_const ("UnboundedIntersection", QLineF::UnboundedIntersection, "@brief Enum constant QLineF::UnboundedIntersection"),
"@qt\n@brief This class represents the QLineF::IntersectType enum"); "@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"); "@qt\n@brief This class represents the QFlags<QLineF::IntersectType> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QLineF_IntersectType_Enum, "QtCore", "IntersectType");
static gsi::ClassExt<QLineF> decl_QLineF_IntersectType_Enums_as_child (decl_QLineF_IntersectType_Enums, "QFlags_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 <QDateTime>
#include <QTime> #include <QTime>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -1347,12 +1347,12 @@ static gsi::Methods methods_QLocale () {
return methods; return methods;
} }
gsi::Class<QLocale> decl_QLocale ("QLocale", gsi::Class<QLocale> decl_QLocale ("QtCore", "QLocale",
methods_QLocale (), methods_QLocale (),
"@qt\n@brief Binding of 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 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 ("AnyCountry", QLocale::AnyCountry, "@brief Enum constant QLocale::AnyCountry") +
gsi::enum_const ("Afghanistan", QLocale::Afghanistan, "@brief Enum constant QLocale::Afghanistan") + gsi::enum_const ("Afghanistan", QLocale::Afghanistan, "@brief Enum constant QLocale::Afghanistan") +
gsi::enum_const ("Albania", QLocale::Albania, "@brief Enum constant QLocale::Albania") + 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"), gsi::enum_const ("LastCountry", QLocale::LastCountry, "@brief Enum constant QLocale::LastCountry"),
"@qt\n@brief This class represents the QLocale::Country enum"); "@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"); "@qt\n@brief This class represents the QFlags<QLocale::Country> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QLocale_Country_Enum, "QtCore", "Country");
static gsi::ClassExt<QLocale> decl_QLocale_Country_Enums_as_child (decl_QLocale_Country_Enums, "QFlags_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 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 ("LongFormat", QLocale::LongFormat, "@brief Enum constant QLocale::LongFormat") +
gsi::enum_const ("ShortFormat", QLocale::ShortFormat, "@brief Enum constant QLocale::ShortFormat") + gsi::enum_const ("ShortFormat", QLocale::ShortFormat, "@brief Enum constant QLocale::ShortFormat") +
gsi::enum_const ("NarrowFormat", QLocale::NarrowFormat, "@brief Enum constant QLocale::NarrowFormat"), gsi::enum_const ("NarrowFormat", QLocale::NarrowFormat, "@brief Enum constant QLocale::NarrowFormat"),
"@qt\n@brief This class represents the QLocale::FormatType enum"); "@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"); "@qt\n@brief This class represents the QFlags<QLocale::FormatType> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QLocale_FormatType_Enum, "QtCore", "FormatType");
static gsi::ClassExt<QLocale> decl_QLocale_FormatType_Enums_as_child (decl_QLocale_FormatType_Enums, "QFlags_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 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 ("C", QLocale::C, "@brief Enum constant QLocale::C") +
gsi::enum_const ("Abkhazian", QLocale::Abkhazian, "@brief Enum constant QLocale::Abkhazian") + gsi::enum_const ("Abkhazian", QLocale::Abkhazian, "@brief Enum constant QLocale::Abkhazian") +
gsi::enum_const ("Afan", QLocale::Afan, "@brief Enum constant QLocale::Afan") + 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"), gsi::enum_const ("LastLanguage", QLocale::LastLanguage, "@brief Enum constant QLocale::LastLanguage"),
"@qt\n@brief This class represents the QLocale::Language enum"); "@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"); "@qt\n@brief This class represents the QFlags<QLocale::Language> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QLocale_Language_Enum, "QtCore", "Language");
static gsi::ClassExt<QLocale> decl_QLocale_Language_Enums_as_child (decl_QLocale_Language_Enums, "QFlags_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 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 ("MetricSystem", QLocale::MetricSystem, "@brief Enum constant QLocale::MetricSystem") +
gsi::enum_const ("ImperialSystem", QLocale::ImperialSystem, "@brief Enum constant QLocale::ImperialSystem"), gsi::enum_const ("ImperialSystem", QLocale::ImperialSystem, "@brief Enum constant QLocale::ImperialSystem"),
"@qt\n@brief This class represents the QLocale::MeasurementSystem enum"); "@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"); "@qt\n@brief This class represents the QFlags<QLocale::MeasurementSystem> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QLocale_MeasurementSystem_Enum, "QtCore", "MeasurementSystem");
static gsi::ClassExt<QLocale> decl_QLocale_MeasurementSystem_Enums_as_child (decl_QLocale_MeasurementSystem_Enums, "QFlags_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 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 ("OmitGroupSeparator", QLocale::OmitGroupSeparator, "@brief Enum constant QLocale::OmitGroupSeparator") +
gsi::enum_const ("RejectGroupSeparator", QLocale::RejectGroupSeparator, "@brief Enum constant QLocale::RejectGroupSeparator"), gsi::enum_const ("RejectGroupSeparator", QLocale::RejectGroupSeparator, "@brief Enum constant QLocale::RejectGroupSeparator"),
"@qt\n@brief This class represents the QLocale::NumberOption enum"); "@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"); "@qt\n@brief This class represents the QFlags<QLocale::NumberOption> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QLocale_NumberOption_Enum, "QtCore", "NumberOption");
static gsi::ClassExt<QLocale> decl_QLocale_NumberOption_Enums_as_child (decl_QLocale_NumberOption_Enums, "QFlags_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 <QMargins>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -266,12 +266,12 @@ static gsi::Methods methods_QMargins () {
return methods; return methods;
} }
gsi::Class<QMargins> decl_QMargins ("QMargins", gsi::Class<QMargins> decl_QMargins ("QtCore", "QMargins",
methods_QMargins (), methods_QMargins (),
"@qt\n@brief Binding of 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 <QMetaClassInfo>
#include <QMetaObject> #include <QMetaObject>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -110,12 +110,12 @@ static gsi::Methods methods_QMetaClassInfo () {
return methods; return methods;
} }
gsi::Class<QMetaClassInfo> decl_QMetaClassInfo ("QMetaClassInfo", gsi::Class<QMetaClassInfo> decl_QMetaClassInfo ("QtCore", "QMetaClassInfo",
methods_QMetaClassInfo (), methods_QMetaClassInfo (),
"@qt\n@brief Binding of 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 <QMetaEnum>
#include <QMetaObject> #include <QMetaObject>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -278,12 +278,12 @@ static gsi::Methods methods_QMetaEnum () {
return methods; return methods;
} }
gsi::Class<QMetaEnum> decl_QMetaEnum ("QMetaEnum", gsi::Class<QMetaEnum> decl_QMetaEnum ("QtCore", "QMetaEnum",
methods_QMetaEnum (), methods_QMetaEnum (),
"@qt\n@brief Binding of 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 <QMetaMethod>
#include <QMetaObject> #include <QMetaObject>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -222,12 +222,12 @@ static gsi::Methods methods_QMetaMethod () {
return methods; return methods;
} }
gsi::Class<QMetaMethod> decl_QMetaMethod ("QMetaMethod", gsi::Class<QMetaMethod> decl_QMetaMethod ("QtCore", "QMetaMethod",
methods_QMetaMethod (), methods_QMetaMethod (),
"@qt\n@brief Binding of 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 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 ("Private", QMetaMethod::Private, "@brief Enum constant QMetaMethod::Private") +
gsi::enum_const ("Protected", QMetaMethod::Protected, "@brief Enum constant QMetaMethod::Protected") + gsi::enum_const ("Protected", QMetaMethod::Protected, "@brief Enum constant QMetaMethod::Protected") +
gsi::enum_const ("Public", QMetaMethod::Public, "@brief Enum constant QMetaMethod::Public"), gsi::enum_const ("Public", QMetaMethod::Public, "@brief Enum constant QMetaMethod::Public"),
"@qt\n@brief This class represents the QMetaMethod::Access enum"); "@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"); "@qt\n@brief This class represents the QFlags<QMetaMethod::Access> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QMetaMethod_Access_Enum, "QtCore", "Access");
static gsi::ClassExt<QMetaMethod> decl_QMetaMethod_Access_Enums_as_child (decl_QMetaMethod_Access_Enums, "QFlags_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 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 ("Method", QMetaMethod::Method, "@brief Enum constant QMetaMethod::Method") +
gsi::enum_const ("Signal", QMetaMethod::Signal, "@brief Enum constant QMetaMethod::Signal") + 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 ("Slot", QMetaMethod::Slot, "@brief Enum constant QMetaMethod::Slot") +
gsi::enum_const ("Constructor", QMetaMethod::Constructor, "@brief Enum constant QMetaMethod::Constructor"), gsi::enum_const ("Constructor", QMetaMethod::Constructor, "@brief Enum constant QMetaMethod::Constructor"),
"@qt\n@brief This class represents the QMetaMethod::MethodType enum"); "@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"); "@qt\n@brief This class represents the QFlags<QMetaMethod::MethodType> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QMetaMethod_MethodType_Enum, "QtCore", "MethodType");
static gsi::ClassExt<QMetaMethod> decl_QMetaMethod_MethodType_Enums_as_child (decl_QMetaMethod_MethodType_Enums, "QFlags_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 <QMetaProperty>
#include <QObject> #include <QObject>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -793,12 +793,12 @@ static gsi::Methods methods_QMetaObject () {
return methods; return methods;
} }
gsi::Class<QMetaObject> decl_QMetaObject ("QMetaObject", gsi::Class<QMetaObject> decl_QMetaObject ("QtCore", "QMetaObject",
methods_QMetaObject (), methods_QMetaObject (),
"@qt\n@brief Binding of 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 <QMetaObject>
#include <QObject> #include <QObject>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -532,12 +532,12 @@ static gsi::Methods methods_QMetaProperty () {
return methods; return methods;
} }
gsi::Class<QMetaProperty> decl_QMetaProperty ("QMetaProperty", gsi::Class<QMetaProperty> decl_QMetaProperty ("QtCore", "QMetaProperty",
methods_QMetaProperty (), methods_QMetaProperty (),
"@qt\n@brief Binding of 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 <QMetaType>
#include <QDataStream> #include <QDataStream>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -242,12 +242,12 @@ static gsi::Methods methods_QMetaType () {
return methods; return methods;
} }
gsi::Class<QMetaType> decl_QMetaType ("QMetaType", gsi::Class<QMetaType> decl_QMetaType ("QtCore", "QMetaType",
methods_QMetaType (), methods_QMetaType (),
"@qt\n@brief Binding of 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 <QTimerEvent>
#include <QUrl> #include <QUrl>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -548,11 +548,11 @@ static gsi::Methods methods_QMimeData () {
gsi::Class<QObject> &qtdecl_QObject (); 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 (), methods_QMimeData (),
"@hide\n@alias 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; 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 (), methods_QMimeData_Adaptor (),
"@qt\n@brief Binding of QMimeData"); "@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 <QModelIndex>
#include <QAbstractItemModel> #include <QAbstractItemModel>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -336,12 +336,12 @@ static gsi::Methods methods_QModelIndex () {
return methods; return methods;
} }
gsi::Class<QModelIndex> decl_QModelIndex ("QModelIndex", gsi::Class<QModelIndex> decl_QModelIndex ("QtCore", "QModelIndex",
methods_QModelIndex (), methods_QModelIndex (),
"@qt\n@brief Binding of 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 <QMutex>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -135,12 +135,12 @@ static gsi::Methods methods_QMutex () {
return methods; return methods;
} }
gsi::Class<QMutex> decl_QMutex ("QMutex", gsi::Class<QMutex> decl_QMutex ("QtCore", "QMutex",
methods_QMutex (), methods_QMutex (),
"@qt\n@brief Binding of 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 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 ("NonRecursive", QMutex::NonRecursive, "@brief Enum constant QMutex::NonRecursive") +
gsi::enum_const ("Recursive", QMutex::Recursive, "@brief Enum constant QMutex::Recursive"), gsi::enum_const ("Recursive", QMutex::Recursive, "@brief Enum constant QMutex::Recursive"),
"@qt\n@brief This class represents the QMutex::RecursionMode enum"); "@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"); "@qt\n@brief This class represents the QFlags<QMutex::RecursionMode> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QMutex_RecursionMode_Enum, "QtCore", "RecursionMode");
static gsi::ClassExt<QMutex> decl_QMutex_RecursionMode_Enums_as_child (decl_QMutex_RecursionMode_Enums, "QFlags_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 <QThread>
#include <QTimerEvent> #include <QTimerEvent>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -751,13 +751,13 @@ static gsi::Methods methods_QObject () {
return methods; 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).") gsi::method_ext("findChild", &find_child_impl, "@brief Specialisation for findChild (uses QObject as T).")
+ +
methods_QObject (), methods_QObject (),
"@hide\n@alias 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; 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 (), methods_QObject_Adaptor (),
"@qt\n@brief Binding of QObject"); "@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 <QAbstractItemModel>
#include <QModelIndex> #include <QModelIndex>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -441,14 +441,14 @@ static gsi::Methods methods_QPersistentModelIndex () {
return methods; 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 &\".") gsi::method_ext("castToQModelIndex", &castToQModelIndex, "@brief Binding for \"operator const QModelIndex &\".")
+ +
methods_QPersistentModelIndex (), methods_QPersistentModelIndex (),
"@qt\n@brief Binding of 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 <QThread>
#include <QTimerEvent> #include <QTimerEvent>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -334,11 +334,11 @@ static gsi::Methods methods_QPluginLoader () {
gsi::Class<QObject> &qtdecl_QObject (); 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 (), methods_QPluginLoader (),
"@hide\n@alias 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; 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 (), methods_QPluginLoader_Adaptor (),
"@qt\n@brief Binding of QPluginLoader"); "@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 <QMatrix>
#include <QMatrix4x4> #include <QMatrix4x4>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -316,21 +316,6 @@ static const QPoint op_QPoint_operator_slash__2777(const QPoint *_self, qreal c)
return ::operator/(*_self, 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 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_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_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_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; return methods;
} }
gsi::Class<QPoint> decl_QPoint ("QPoint", gsi::Class<QPoint> decl_QPoint ("QtCore", "QPoint",
methods_QPoint (), methods_QPoint (),
"@qt\n@brief Binding of 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 <QMatrix>
#include <QMatrix4x4> #include <QMatrix4x4>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -350,21 +350,6 @@ static const QPointF op_QPointF_operator_slash__2847(const QPointF *_self, qreal
return ::operator/(*_self, c); 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 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_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_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_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; return methods;
} }
gsi::Class<QPointF> decl_QPointF ("QPointF", gsi::Class<QPointF> decl_QPointF ("QtCore", "QPointF",
methods_QPointF (), methods_QPointF (),
"@qt\n@brief Binding of 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 <QThread>
#include <QTimerEvent> #include <QTimerEvent>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -1052,12 +1052,12 @@ static gsi::Methods methods_QProcess () {
gsi::Class<QIODevice> &qtdecl_QIODevice (); 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 (), methods_QProcess (),
"@qt\n@brief Binding of 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 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 ("NormalExit", QProcess::NormalExit, "@brief Enum constant QProcess::NormalExit") +
gsi::enum_const ("CrashExit", QProcess::CrashExit, "@brief Enum constant QProcess::CrashExit"), gsi::enum_const ("CrashExit", QProcess::CrashExit, "@brief Enum constant QProcess::CrashExit"),
"@qt\n@brief This class represents the QProcess::ExitStatus enum"); "@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"); "@qt\n@brief This class represents the QFlags<QProcess::ExitStatus> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QProcess_ExitStatus_Enum, "QtCore", "ExitStatus");
static gsi::ClassExt<QProcess> decl_QProcess_ExitStatus_Enums_as_child (decl_QProcess_ExitStatus_Enums, "QFlags_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 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 ("StandardOutput", QProcess::StandardOutput, "@brief Enum constant QProcess::StandardOutput") +
gsi::enum_const ("StandardError", QProcess::StandardError, "@brief Enum constant QProcess::StandardError"), gsi::enum_const ("StandardError", QProcess::StandardError, "@brief Enum constant QProcess::StandardError"),
"@qt\n@brief This class represents the QProcess::ProcessChannel enum"); "@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"); "@qt\n@brief This class represents the QFlags<QProcess::ProcessChannel> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QProcess_ProcessChannel_Enum, "QtCore", "ProcessChannel");
static gsi::ClassExt<QProcess> decl_QProcess_ProcessChannel_Enums_as_child (decl_QProcess_ProcessChannel_Enums, "QFlags_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 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 ("SeparateChannels", QProcess::SeparateChannels, "@brief Enum constant QProcess::SeparateChannels") +
gsi::enum_const ("MergedChannels", QProcess::MergedChannels, "@brief Enum constant QProcess::MergedChannels") + gsi::enum_const ("MergedChannels", QProcess::MergedChannels, "@brief Enum constant QProcess::MergedChannels") +
gsi::enum_const ("ForwardedChannels", QProcess::ForwardedChannels, "@brief Enum constant QProcess::ForwardedChannels"), gsi::enum_const ("ForwardedChannels", QProcess::ForwardedChannels, "@brief Enum constant QProcess::ForwardedChannels"),
"@qt\n@brief This class represents the QProcess::ProcessChannelMode enum"); "@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"); "@qt\n@brief This class represents the QFlags<QProcess::ProcessChannelMode> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QProcess_ProcessChannelMode_Enum, "QtCore", "ProcessChannelMode");
static gsi::ClassExt<QProcess> decl_QProcess_ProcessChannelMode_Enums_as_child (decl_QProcess_ProcessChannelMode_Enums, "QFlags_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 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 ("FailedToStart", QProcess::FailedToStart, "@brief Enum constant QProcess::FailedToStart") +
gsi::enum_const ("Crashed", QProcess::Crashed, "@brief Enum constant QProcess::Crashed") + gsi::enum_const ("Crashed", QProcess::Crashed, "@brief Enum constant QProcess::Crashed") +
gsi::enum_const ("Timedout", QProcess::Timedout, "@brief Enum constant QProcess::Timedout") + 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"), gsi::enum_const ("UnknownError", QProcess::UnknownError, "@brief Enum constant QProcess::UnknownError"),
"@qt\n@brief This class represents the QProcess::ProcessError enum"); "@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"); "@qt\n@brief This class represents the QFlags<QProcess::ProcessError> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QProcess_ProcessError_Enum, "QtCore", "ProcessError");
static gsi::ClassExt<QProcess> decl_QProcess_ProcessError_Enums_as_child (decl_QProcess_ProcessError_Enums, "QFlags_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 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 ("NotRunning", QProcess::NotRunning, "@brief Enum constant QProcess::NotRunning") +
gsi::enum_const ("Starting", QProcess::Starting, "@brief Enum constant QProcess::Starting") + gsi::enum_const ("Starting", QProcess::Starting, "@brief Enum constant QProcess::Starting") +
gsi::enum_const ("Running", QProcess::Running, "@brief Enum constant QProcess::Running"), gsi::enum_const ("Running", QProcess::Running, "@brief Enum constant QProcess::Running"),
"@qt\n@brief This class represents the QProcess::ProcessState enum"); "@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"); "@qt\n@brief This class represents the QFlags<QProcess::ProcessState> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QProcess_ProcessState_Enum, "QtCore", "ProcessState");
static gsi::ClassExt<QProcess> decl_QProcess_ProcessState_Enums_as_child (decl_QProcess_ProcessState_Enums, "QFlags_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 <QProcessEnvironment>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -294,12 +294,12 @@ static gsi::Methods methods_QProcessEnvironment () {
return methods; return methods;
} }
gsi::Class<QProcessEnvironment> decl_QProcessEnvironment ("QProcessEnvironment", gsi::Class<QProcessEnvironment> decl_QProcessEnvironment ("QtCore", "QProcessEnvironment",
methods_QProcessEnvironment (), methods_QProcessEnvironment (),
"@qt\n@brief Binding of 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 <QReadLocker>
#include <QReadWriteLock> #include <QReadWriteLock>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -116,12 +116,12 @@ static gsi::Methods methods_QReadLocker () {
return methods; return methods;
} }
gsi::Class<QReadLocker> decl_QReadLocker ("QReadLocker", gsi::Class<QReadLocker> decl_QReadLocker ("QtCore", "QReadLocker",
methods_QReadLocker (), methods_QReadLocker (),
"@qt\n@brief Binding of 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 <QReadWriteLock>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -204,12 +204,12 @@ static gsi::Methods methods_QReadWriteLock () {
return methods; return methods;
} }
gsi::Class<QReadWriteLock> decl_QReadWriteLock ("QReadWriteLock", gsi::Class<QReadWriteLock> decl_QReadWriteLock ("QtCore", "QReadWriteLock",
methods_QReadWriteLock (), methods_QReadWriteLock (),
"@qt\n@brief Binding of 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 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 ("NonRecursive", QReadWriteLock::NonRecursive, "@brief Enum constant QReadWriteLock::NonRecursive") +
gsi::enum_const ("Recursive", QReadWriteLock::Recursive, "@brief Enum constant QReadWriteLock::Recursive"), gsi::enum_const ("Recursive", QReadWriteLock::Recursive, "@brief Enum constant QReadWriteLock::Recursive"),
"@qt\n@brief This class represents the QReadWriteLock::RecursionMode enum"); "@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"); "@qt\n@brief This class represents the QFlags<QReadWriteLock::RecursionMode> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QReadWriteLock_RecursionMode_Enum, "QtCore", "RecursionMode");
static gsi::ClassExt<QReadWriteLock> decl_QReadWriteLock_RecursionMode_Enums_as_child (decl_QReadWriteLock_RecursionMode_Enums, "QFlags_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 <QPoint>
#include <QSize> #include <QSize>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -1487,12 +1487,12 @@ static gsi::Methods methods_QRect () {
return methods; return methods;
} }
gsi::Class<QRect> decl_QRect ("QRect", gsi::Class<QRect> decl_QRect ("QtCore", "QRect",
methods_QRect (), methods_QRect (),
"@qt\n@brief Binding of 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 <QRect>
#include <QSizeF> #include <QSizeF>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -1508,12 +1508,12 @@ static gsi::Methods methods_QRectF () {
return methods; return methods;
} }
gsi::Class<QRectF> decl_QRectF ("QRectF", gsi::Class<QRectF> decl_QRectF ("QtCore", "QRectF",
methods_QRectF (), methods_QRectF (),
"@qt\n@brief Binding of 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 <QRegExp>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -631,12 +631,12 @@ static gsi::Methods methods_QRegExp () {
return methods; return methods;
} }
gsi::Class<QRegExp> decl_QRegExp ("QRegExp", gsi::Class<QRegExp> decl_QRegExp ("QtCore", "QRegExp",
methods_QRegExp (), methods_QRegExp (),
"@qt\n@brief Binding of 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 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 ("CaretAtZero", QRegExp::CaretAtZero, "@brief Enum constant QRegExp::CaretAtZero") +
gsi::enum_const ("CaretAtOffset", QRegExp::CaretAtOffset, "@brief Enum constant QRegExp::CaretAtOffset") + gsi::enum_const ("CaretAtOffset", QRegExp::CaretAtOffset, "@brief Enum constant QRegExp::CaretAtOffset") +
gsi::enum_const ("CaretWontMatch", QRegExp::CaretWontMatch, "@brief Enum constant QRegExp::CaretWontMatch"), gsi::enum_const ("CaretWontMatch", QRegExp::CaretWontMatch, "@brief Enum constant QRegExp::CaretWontMatch"),
"@qt\n@brief This class represents the QRegExp::CaretMode enum"); "@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"); "@qt\n@brief This class represents the QFlags<QRegExp::CaretMode> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QRegExp_CaretMode_Enum, "QtCore", "CaretMode");
static gsi::ClassExt<QRegExp> decl_QRegExp_CaretMode_Enums_as_child (decl_QRegExp_CaretMode_Enums, "QFlags_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 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 ("RegExp", QRegExp::RegExp, "@brief Enum constant QRegExp::RegExp") +
gsi::enum_const ("Wildcard", QRegExp::Wildcard, "@brief Enum constant QRegExp::Wildcard") + gsi::enum_const ("Wildcard", QRegExp::Wildcard, "@brief Enum constant QRegExp::Wildcard") +
gsi::enum_const ("FixedString", QRegExp::FixedString, "@brief Enum constant QRegExp::FixedString") + 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"), gsi::enum_const ("W3CXmlSchema11", QRegExp::W3CXmlSchema11, "@brief Enum constant QRegExp::W3CXmlSchema11"),
"@qt\n@brief This class represents the QRegExp::PatternSyntax enum"); "@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"); "@qt\n@brief This class represents the QFlags<QRegExp::PatternSyntax> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QRegExp_PatternSyntax_Enum, "QtCore", "PatternSyntax");
static gsi::ClassExt<QRegExp> decl_QRegExp_PatternSyntax_Enums_as_child (decl_QRegExp_PatternSyntax_Enums, "QFlags_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 <QResource>
#include <QLocale> #include <QLocale>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -352,12 +352,12 @@ static gsi::Methods methods_QResource () {
return methods; return methods;
} }
gsi::Class<QResource> decl_QResource ("QResource", gsi::Class<QResource> decl_QResource ("QtCore", "QResource",
methods_QResource (), methods_QResource (),
"@qt\n@brief Binding of 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 <QSemaphore>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -166,12 +166,12 @@ static gsi::Methods methods_QSemaphore () {
return methods; return methods;
} }
gsi::Class<QSemaphore> decl_QSemaphore ("QSemaphore", gsi::Class<QSemaphore> decl_QSemaphore ("QtCore", "QSemaphore",
methods_QSemaphore (), methods_QSemaphore (),
"@qt\n@brief Binding of 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 <QThread>
#include <QTimerEvent> #include <QTimerEvent>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -725,11 +725,11 @@ static gsi::Methods methods_QSettings () {
gsi::Class<QObject> &qtdecl_QObject (); 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 (), methods_QSettings (),
"@hide\n@alias 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; 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 (), methods_QSettings_Adaptor (),
"@qt\n@brief Binding of QSettings"); "@qt\n@brief Binding of QSettings");
@ -1293,7 +1293,7 @@ gsi::Class<QSettings_Adaptor> decl_QSettings_Adaptor (qtdecl_QSettings (), "QSet
namespace qt_gsi 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 ("NativeFormat", QSettings::NativeFormat, "@brief Enum constant QSettings::NativeFormat") +
gsi::enum_const ("IniFormat", QSettings::IniFormat, "@brief Enum constant QSettings::IniFormat") + gsi::enum_const ("IniFormat", QSettings::IniFormat, "@brief Enum constant QSettings::IniFormat") +
gsi::enum_const ("InvalidFormat", QSettings::InvalidFormat, "@brief Enum constant QSettings::InvalidFormat") + 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"), gsi::enum_const ("CustomFormat16", QSettings::CustomFormat16, "@brief Enum constant QSettings::CustomFormat16"),
"@qt\n@brief This class represents the QSettings::Format enum"); "@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"); "@qt\n@brief This class represents the QFlags<QSettings::Format> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QSettings_Format_Enum, "QtCore", "Format");
static gsi::ClassExt<QSettings> decl_QSettings_Format_Enums_as_child (decl_QSettings_Format_Enums, "QFlags_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 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 ("UserScope", QSettings::UserScope, "@brief Enum constant QSettings::UserScope") +
gsi::enum_const ("SystemScope", QSettings::SystemScope, "@brief Enum constant QSettings::SystemScope"), gsi::enum_const ("SystemScope", QSettings::SystemScope, "@brief Enum constant QSettings::SystemScope"),
"@qt\n@brief This class represents the QSettings::Scope enum"); "@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"); "@qt\n@brief This class represents the QFlags<QSettings::Scope> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QSettings_Scope_Enum, "QtCore", "Scope");
static gsi::ClassExt<QSettings> decl_QSettings_Scope_Enums_as_child (decl_QSettings_Scope_Enums, "QFlags_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 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 ("NoError", QSettings::NoError, "@brief Enum constant QSettings::NoError") +
gsi::enum_const ("AccessError", QSettings::AccessError, "@brief Enum constant QSettings::AccessError") + gsi::enum_const ("AccessError", QSettings::AccessError, "@brief Enum constant QSettings::AccessError") +
gsi::enum_const ("FormatError", QSettings::FormatError, "@brief Enum constant QSettings::FormatError"), gsi::enum_const ("FormatError", QSettings::FormatError, "@brief Enum constant QSettings::FormatError"),
"@qt\n@brief This class represents the QSettings::Status enum"); "@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"); "@qt\n@brief This class represents the QFlags<QSettings::Status> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QSettings_Status_Enum, "QtCore", "Status");
static gsi::ClassExt<QSettings> decl_QSettings_Status_Enums_as_child (decl_QSettings_Status_Enums, "QFlags_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 <QTimerEvent>
#include <QWidget> #include <QWidget>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -404,11 +404,11 @@ static gsi::Methods methods_QSignalMapper () {
gsi::Class<QObject> &qtdecl_QObject (); 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 (), methods_QSignalMapper (),
"@hide\n@alias 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; 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 (), methods_QSignalMapper_Adaptor (),
"@qt\n@brief Binding of QSignalMapper"); "@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 <QSize>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -462,12 +462,12 @@ static gsi::Methods methods_QSize () {
return methods; return methods;
} }
gsi::Class<QSize> decl_QSize ("QSize", gsi::Class<QSize> decl_QSize ("QtCore", "QSize",
methods_QSize (), methods_QSize (),
"@qt\n@brief Binding of 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 <QSizeF>
#include <QSize> #include <QSize>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -499,12 +499,12 @@ static gsi::Methods methods_QSizeF () {
return methods; return methods;
} }
gsi::Class<QSizeF> decl_QSizeF ("QSizeF", gsi::Class<QSizeF> decl_QSizeF ("QtCore", "QSizeF",
methods_QSizeF (), methods_QSizeF (),
"@qt\n@brief Binding of 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 <QThread>
#include <QTimerEvent> #include <QTimerEvent>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -234,11 +234,11 @@ static gsi::Methods methods_QSocketNotifier () {
gsi::Class<QObject> &qtdecl_QObject (); 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 (), methods_QSocketNotifier (),
"@hide\n@alias 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; 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 (), methods_QSocketNotifier_Adaptor (),
"@qt\n@brief Binding of QSocketNotifier"); "@qt\n@brief Binding of QSocketNotifier");
@ -658,19 +658,19 @@ gsi::Class<QSocketNotifier_Adaptor> decl_QSocketNotifier_Adaptor (qtdecl_QSocket
namespace qt_gsi 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 ("Read", QSocketNotifier::Read, "@brief Enum constant QSocketNotifier::Read") +
gsi::enum_const ("Write", QSocketNotifier::Write, "@brief Enum constant QSocketNotifier::Write") + gsi::enum_const ("Write", QSocketNotifier::Write, "@brief Enum constant QSocketNotifier::Write") +
gsi::enum_const ("Exception", QSocketNotifier::Exception, "@brief Enum constant QSocketNotifier::Exception"), gsi::enum_const ("Exception", QSocketNotifier::Exception, "@brief Enum constant QSocketNotifier::Exception"),
"@qt\n@brief This class represents the QSocketNotifier::Type enum"); "@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"); "@qt\n@brief This class represents the QFlags<QSocketNotifier::Type> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QSocketNotifier_Type_Enum, "QtCore", "Type");
static gsi::ClassExt<QSocketNotifier> decl_QSocketNotifier_Type_Enums_as_child (decl_QSocketNotifier_Type_Enums, "QFlags_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 <QStringMatcher>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -221,12 +221,12 @@ static gsi::Methods methods_QStringMatcher () {
return methods; return methods;
} }
gsi::Class<QStringMatcher> decl_QStringMatcher ("QStringMatcher", gsi::Class<QStringMatcher> decl_QStringMatcher ("QtCore", "QStringMatcher",
methods_QStringMatcher (), methods_QStringMatcher (),
"@qt\n@brief Binding of 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 <QSysInfo>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -61,12 +61,12 @@ static gsi::Methods methods_QSysInfo () {
return methods; return methods;
} }
gsi::Class<QSysInfo> decl_QSysInfo ("QSysInfo", gsi::Class<QSysInfo> decl_QSysInfo ("QtCore", "QSysInfo",
methods_QSysInfo (), methods_QSysInfo (),
"@qt\n@brief Binding of 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 <QSystemLocale>
#include <QLocale> #include <QLocale>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -84,11 +84,11 @@ static gsi::Methods methods_QSystemLocale () {
return methods; return methods;
} }
gsi::Class<QSystemLocale> decl_QSystemLocale ("QSystemLocale_Native", gsi::Class<QSystemLocale> decl_QSystemLocale ("QtCore", "QSystemLocale_Native",
methods_QSystemLocale (), methods_QSystemLocale (),
"@hide\n@alias 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; 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 (), methods_QSystemLocale_Adaptor (),
"@qt\n@brief Binding of QSystemLocale"); "@qt\n@brief Binding of QSystemLocale");
@ -226,7 +226,7 @@ gsi::Class<QSystemLocale_Adaptor> decl_QSystemLocale_Adaptor (qtdecl_QSystemLoca
namespace qt_gsi 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 ("LanguageId", QSystemLocale::LanguageId, "@brief Enum constant QSystemLocale::LanguageId") +
gsi::enum_const ("CountryId", QSystemLocale::CountryId, "@brief Enum constant QSystemLocale::CountryId") + gsi::enum_const ("CountryId", QSystemLocale::CountryId, "@brief Enum constant QSystemLocale::CountryId") +
gsi::enum_const ("DecimalPoint", QSystemLocale::DecimalPoint, "@brief Enum constant QSystemLocale::DecimalPoint") + 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"), gsi::enum_const ("PMText", QSystemLocale::PMText, "@brief Enum constant QSystemLocale::PMText"),
"@qt\n@brief This class represents the QSystemLocale::QueryType enum"); "@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"); "@qt\n@brief This class represents the QFlags<QSystemLocale::QueryType> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QSystemLocale_QueryType_Enum, "QtCore", "QueryType");
static gsi::ClassExt<QSystemLocale> decl_QSystemLocale_QueryType_Enums_as_child (decl_QSystemLocale_QueryType_Enums, "QFlags_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 <QThread>
#include <QTimerEvent> #include <QTimerEvent>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -395,12 +395,12 @@ static gsi::Methods methods_QTemporaryFile () {
gsi::Class<QFile> &qtdecl_QFile (); 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 (), methods_QTemporaryFile (),
"@qt\n@brief Binding of 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 <QTextDecoder>
#include <QTextEncoder> #include <QTextEncoder>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -501,11 +501,11 @@ static gsi::Methods methods_QTextCodec () {
return methods; return methods;
} }
gsi::Class<QTextCodec> decl_QTextCodec ("QTextCodec_Native", gsi::Class<QTextCodec> decl_QTextCodec ("QtCore", "QTextCodec_Native",
methods_QTextCodec (), methods_QTextCodec (),
"@hide\n@alias 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(); virtual ~QTextCodec_Adaptor();
// [adaptor ctor] QTextCodec::QTextCodec()
QTextCodec_Adaptor() : QTextCodec()
{
qt_gsi::QtObjectBase::init (this);
}
// [adaptor impl] QList<QByteArray> QTextCodec::aliases() // [adaptor impl] QList<QByteArray> QTextCodec::aliases()
QList<QByteArray> cbs_aliases_c0_0() const QList<QByteArray> cbs_aliases_c0_0() const
{ {
@ -606,6 +612,20 @@ public:
QTextCodec_Adaptor::~QTextCodec_Adaptor() { } 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() // QList<QByteArray> QTextCodec::aliases()
static void _init_cbs_aliases_c0_0 (qt_gsi::GenericMethod *decl) 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 () { static gsi::Methods methods_QTextCodec_Adaptor () {
gsi::Methods methods; 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", "@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 ("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); 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; 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 (), methods_QTextCodec_Adaptor (),
"@qt\n@brief Binding of QTextCodec"); "@qt\n@brief Binding of QTextCodec");
@ -752,20 +773,20 @@ gsi::Class<QTextCodec_Adaptor> decl_QTextCodec_Adaptor (qtdecl_QTextCodec (), "Q
namespace qt_gsi 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 ("DefaultConversion", QTextCodec::DefaultConversion, "@brief Enum constant QTextCodec::DefaultConversion") +
gsi::enum_const ("ConvertInvalidToNull", QTextCodec::ConvertInvalidToNull, "@brief Enum constant QTextCodec::ConvertInvalidToNull") + 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 ("IgnoreHeader", QTextCodec::IgnoreHeader, "@brief Enum constant QTextCodec::IgnoreHeader") +
gsi::enum_const ("FreeFunction", QTextCodec::FreeFunction, "@brief Enum constant QTextCodec::FreeFunction"), gsi::enum_const ("FreeFunction", QTextCodec::FreeFunction, "@brief Enum constant QTextCodec::FreeFunction"),
"@qt\n@brief This class represents the QTextCodec::ConversionFlag enum"); "@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"); "@qt\n@brief This class represents the QFlags<QTextCodec::ConversionFlag> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QTextCodec_ConversionFlag_Enum, "QtCore", "ConversionFlag");
static gsi::ClassExt<QTextCodec> decl_QTextCodec_ConversionFlag_Enums_as_child (decl_QTextCodec_ConversionFlag_Enums, "QFlags_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 <QTextCodec>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -65,13 +65,13 @@ static gsi::Methods methods_QTextCodec_ConverterState () {
return methods; return methods;
} }
gsi::Class<QTextCodec::ConverterState> decl_QTextCodec_ConverterState ("QTextCodec_ConverterState", gsi::Class<QTextCodec::ConverterState> decl_QTextCodec_ConverterState ("QtCore", "QTextCodec_ConverterState",
methods_QTextCodec_ConverterState (), methods_QTextCodec_ConverterState (),
"@qt\n@brief Binding of 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 <QTextDecoder>
#include <QTextCodec> #include <QTextCodec>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -152,12 +152,12 @@ static gsi::Methods methods_QTextDecoder () {
return methods; return methods;
} }
gsi::Class<QTextDecoder> decl_QTextDecoder ("QTextDecoder", gsi::Class<QTextDecoder> decl_QTextDecoder ("QtCore", "QTextDecoder",
methods_QTextDecoder (), methods_QTextDecoder (),
"@qt\n@brief Binding of 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 <QTextEncoder>
#include <QTextCodec> #include <QTextCodec>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -102,12 +102,12 @@ static gsi::Methods methods_QTextEncoder () {
return methods; return methods;
} }
gsi::Class<QTextEncoder> decl_QTextEncoder ("QTextEncoder", gsi::Class<QTextEncoder> decl_QTextEncoder ("QtCore", "QTextEncoder",
methods_QTextEncoder (), methods_QTextEncoder (),
"@qt\n@brief Binding of 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 <QDomNode>
#include <QSplitter> #include <QSplitter>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -910,7 +910,7 @@ static gsi::Methods methods_QTextStream () {
return methods; 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_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_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>>") + 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 (), methods_QTextStream (),
"@hide\n@alias 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; 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 (), methods_QTextStream_Adaptor (),
"@qt\n@brief Binding of QTextStream"); "@qt\n@brief Binding of QTextStream");
@ -1054,20 +1054,20 @@ gsi::Class<QTextStream_Adaptor> decl_QTextStream_Adaptor (qtdecl_QTextStream (),
namespace qt_gsi 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 ("AlignLeft", QTextStream::AlignLeft, "@brief Enum constant QTextStream::AlignLeft") +
gsi::enum_const ("AlignRight", QTextStream::AlignRight, "@brief Enum constant QTextStream::AlignRight") + 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 ("AlignCenter", QTextStream::AlignCenter, "@brief Enum constant QTextStream::AlignCenter") +
gsi::enum_const ("AlignAccountingStyle", QTextStream::AlignAccountingStyle, "@brief Enum constant QTextStream::AlignAccountingStyle"), gsi::enum_const ("AlignAccountingStyle", QTextStream::AlignAccountingStyle, "@brief Enum constant QTextStream::AlignAccountingStyle"),
"@qt\n@brief This class represents the QTextStream::FieldAlignment enum"); "@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"); "@qt\n@brief This class represents the QFlags<QTextStream::FieldAlignment> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QTextStream_FieldAlignment_Enum, "QtCore", "FieldAlignment");
static gsi::ClassExt<QTextStream> decl_QTextStream_FieldAlignment_Enums_as_child (decl_QTextStream_FieldAlignment_Enums, "QFlags_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 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 ("ShowBase", QTextStream::ShowBase, "@brief Enum constant QTextStream::ShowBase") +
gsi::enum_const ("ForcePoint", QTextStream::ForcePoint, "@brief Enum constant QTextStream::ForcePoint") + gsi::enum_const ("ForcePoint", QTextStream::ForcePoint, "@brief Enum constant QTextStream::ForcePoint") +
gsi::enum_const ("ForceSign", QTextStream::ForceSign, "@brief Enum constant QTextStream::ForceSign") + 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"), gsi::enum_const ("UppercaseDigits", QTextStream::UppercaseDigits, "@brief Enum constant QTextStream::UppercaseDigits"),
"@qt\n@brief This class represents the QTextStream::NumberFlag enum"); "@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"); "@qt\n@brief This class represents the QFlags<QTextStream::NumberFlag> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QTextStream_NumberFlag_Enum, "QtCore", "NumberFlag");
static gsi::ClassExt<QTextStream> decl_QTextStream_NumberFlag_Enums_as_child (decl_QTextStream_NumberFlag_Enums, "QFlags_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 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 ("SmartNotation", QTextStream::SmartNotation, "@brief Enum constant QTextStream::SmartNotation") +
gsi::enum_const ("FixedNotation", QTextStream::FixedNotation, "@brief Enum constant QTextStream::FixedNotation") + gsi::enum_const ("FixedNotation", QTextStream::FixedNotation, "@brief Enum constant QTextStream::FixedNotation") +
gsi::enum_const ("ScientificNotation", QTextStream::ScientificNotation, "@brief Enum constant QTextStream::ScientificNotation"), gsi::enum_const ("ScientificNotation", QTextStream::ScientificNotation, "@brief Enum constant QTextStream::ScientificNotation"),
"@qt\n@brief This class represents the QTextStream::RealNumberNotation enum"); "@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"); "@qt\n@brief This class represents the QFlags<QTextStream::RealNumberNotation> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QTextStream_RealNumberNotation_Enum, "QtCore", "RealNumberNotation");
static gsi::ClassExt<QTextStream> decl_QTextStream_RealNumberNotation_Enums_as_child (decl_QTextStream_RealNumberNotation_Enums, "QFlags_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 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 ("Ok", QTextStream::Ok, "@brief Enum constant QTextStream::Ok") +
gsi::enum_const ("ReadPastEnd", QTextStream::ReadPastEnd, "@brief Enum constant QTextStream::ReadPastEnd") + gsi::enum_const ("ReadPastEnd", QTextStream::ReadPastEnd, "@brief Enum constant QTextStream::ReadPastEnd") +
gsi::enum_const ("ReadCorruptData", QTextStream::ReadCorruptData, "@brief Enum constant QTextStream::ReadCorruptData"), gsi::enum_const ("ReadCorruptData", QTextStream::ReadCorruptData, "@brief Enum constant QTextStream::ReadCorruptData"),
"@qt\n@brief This class represents the QTextStream::Status enum"); "@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"); "@qt\n@brief This class represents the QFlags<QTextStream::Status> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QTextStream_Status_Enum, "QtCore", "Status");
static gsi::ClassExt<QTextStream> decl_QTextStream_Status_Enums_as_child (decl_QTextStream_Status_Enums, "QFlags_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 <QObject>
#include <QTimerEvent> #include <QTimerEvent>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -433,11 +433,11 @@ static gsi::Methods methods_QThread () {
gsi::Class<QObject> &qtdecl_QObject (); 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 (), methods_QThread (),
"@hide\n@alias 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; 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 (), methods_QThread_Adaptor (),
"@qt\n@brief Binding of QThread"); "@qt\n@brief Binding of QThread");
@ -1047,7 +1047,7 @@ gsi::Class<QThread_Adaptor> decl_QThread_Adaptor (qtdecl_QThread (), "QThread",
namespace qt_gsi 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 ("IdlePriority", QThread::IdlePriority, "@brief Enum constant QThread::IdlePriority") +
gsi::enum_const ("LowestPriority", QThread::LowestPriority, "@brief Enum constant QThread::LowestPriority") + gsi::enum_const ("LowestPriority", QThread::LowestPriority, "@brief Enum constant QThread::LowestPriority") +
gsi::enum_const ("LowPriority", QThread::LowPriority, "@brief Enum constant QThread::LowPriority") + 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"), gsi::enum_const ("InheritPriority", QThread::InheritPriority, "@brief Enum constant QThread::InheritPriority"),
"@qt\n@brief This class represents the QThread::Priority enum"); "@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"); "@qt\n@brief This class represents the QFlags<QThread::Priority> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QThread_Priority_Enum, "QtCore", "Priority");
static gsi::ClassExt<QThread> decl_QThread_Priority_Enums_as_child (decl_QThread_Priority_Enums, "QFlags_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 <QTime>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -595,12 +595,12 @@ static gsi::Methods methods_QTime () {
return methods; return methods;
} }
gsi::Class<QTime> decl_QTime ("QTime", gsi::Class<QTime> decl_QTime ("QtCore", "QTime",
methods_QTime (), methods_QTime (),
"@qt\n@brief Binding of 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 <QThread>
#include <QTimerEvent> #include <QTimerEvent>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -703,11 +703,11 @@ static gsi::Methods methods_QTimeLine () {
gsi::Class<QObject> &qtdecl_QObject (); 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 (), methods_QTimeLine (),
"@hide\n@alias 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; 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 (), methods_QTimeLine_Adaptor (),
"@qt\n@brief Binding of QTimeLine"); "@qt\n@brief Binding of QTimeLine");
@ -1242,7 +1242,7 @@ gsi::Class<QTimeLine_Adaptor> decl_QTimeLine_Adaptor (qtdecl_QTimeLine (), "QTim
namespace qt_gsi 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 ("EaseInCurve", QTimeLine::EaseInCurve, "@brief Enum constant QTimeLine::EaseInCurve") +
gsi::enum_const ("EaseOutCurve", QTimeLine::EaseOutCurve, "@brief Enum constant QTimeLine::EaseOutCurve") + gsi::enum_const ("EaseOutCurve", QTimeLine::EaseOutCurve, "@brief Enum constant QTimeLine::EaseOutCurve") +
gsi::enum_const ("EaseInOutCurve", QTimeLine::EaseInOutCurve, "@brief Enum constant QTimeLine::EaseInOutCurve") + 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"), gsi::enum_const ("CosineCurve", QTimeLine::CosineCurve, "@brief Enum constant QTimeLine::CosineCurve"),
"@qt\n@brief This class represents the QTimeLine::CurveShape enum"); "@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"); "@qt\n@brief This class represents the QFlags<QTimeLine::CurveShape> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QTimeLine_CurveShape_Enum, "QtCore", "CurveShape");
static gsi::ClassExt<QTimeLine> decl_QTimeLine_CurveShape_Enums_as_child (decl_QTimeLine_CurveShape_Enums, "QFlags_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 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 ("Forward", QTimeLine::Forward, "@brief Enum constant QTimeLine::Forward") +
gsi::enum_const ("Backward", QTimeLine::Backward, "@brief Enum constant QTimeLine::Backward"), gsi::enum_const ("Backward", QTimeLine::Backward, "@brief Enum constant QTimeLine::Backward"),
"@qt\n@brief This class represents the QTimeLine::Direction enum"); "@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"); "@qt\n@brief This class represents the QFlags<QTimeLine::Direction> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QTimeLine_Direction_Enum, "QtCore", "Direction");
static gsi::ClassExt<QTimeLine> decl_QTimeLine_Direction_Enums_as_child (decl_QTimeLine_Direction_Enums, "QFlags_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 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 ("NotRunning", QTimeLine::NotRunning, "@brief Enum constant QTimeLine::NotRunning") +
gsi::enum_const ("Paused", QTimeLine::Paused, "@brief Enum constant QTimeLine::Paused") + gsi::enum_const ("Paused", QTimeLine::Paused, "@brief Enum constant QTimeLine::Paused") +
gsi::enum_const ("Running", QTimeLine::Running, "@brief Enum constant QTimeLine::Running"), gsi::enum_const ("Running", QTimeLine::Running, "@brief Enum constant QTimeLine::Running"),
"@qt\n@brief This class represents the QTimeLine::State enum"); "@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"); "@qt\n@brief This class represents the QFlags<QTimeLine::State> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QTimeLine_State_Enum, "QtCore", "State");
static gsi::ClassExt<QTimeLine> decl_QTimeLine_State_Enums_as_child (decl_QTimeLine_State_Enums, "QFlags_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 <QThread>
#include <QTimerEvent> #include <QTimerEvent>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -326,11 +326,11 @@ static gsi::Methods methods_QTimer () {
gsi::Class<QObject> &qtdecl_QObject (); 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 (), methods_QTimer (),
"@hide\n@alias 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; 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 (), methods_QTimer_Adaptor (),
"@qt\n@brief Binding of QTimer"); "@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 <QTimerEvent>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -62,11 +62,11 @@ static gsi::Methods methods_QTimerEvent () {
gsi::Class<QEvent> &qtdecl_QEvent (); 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 (), methods_QTimerEvent (),
"@hide\n@alias 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; 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 (), methods_QTimerEvent_Adaptor (),
"@qt\n@brief Binding of QTimerEvent"); "@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 <QThread>
#include <QTimerEvent> #include <QTimerEvent>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -287,11 +287,11 @@ static gsi::Methods methods_QTranslator () {
gsi::Class<QObject> &qtdecl_QObject (); 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 (), methods_QTranslator (),
"@hide\n@alias 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; 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 (), methods_QTranslator_Adaptor (),
"@qt\n@brief Binding of QTranslator"); "@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 <QUrl>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -1759,12 +1759,12 @@ static gsi::Methods methods_QUrl () {
return methods; return methods;
} }
gsi::Class<QUrl> decl_QUrl ("QUrl", gsi::Class<QUrl> decl_QUrl ("QtCore", "QUrl",
methods_QUrl (), methods_QUrl (),
"@qt\n@brief Binding of 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 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 ("None", QUrl::None, "@brief Enum constant QUrl::None") +
gsi::enum_const ("RemoveScheme", QUrl::RemoveScheme, "@brief Enum constant QUrl::RemoveScheme") + gsi::enum_const ("RemoveScheme", QUrl::RemoveScheme, "@brief Enum constant QUrl::RemoveScheme") +
gsi::enum_const ("RemovePassword", QUrl::RemovePassword, "@brief Enum constant QUrl::RemovePassword") + 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"), gsi::enum_const ("StripTrailingSlash", QUrl::StripTrailingSlash, "@brief Enum constant QUrl::StripTrailingSlash"),
"@qt\n@brief This class represents the QUrl::FormattingOption enum"); "@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"); "@qt\n@brief This class represents the QFlags<QUrl::FormattingOption> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QUrl_FormattingOption_Enum, "QtCore", "FormattingOption");
static gsi::ClassExt<QUrl> decl_QUrl_FormattingOption_Enums_as_child (decl_QUrl_FormattingOption_Enums, "QFlags_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 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 ("TolerantMode", QUrl::TolerantMode, "@brief Enum constant QUrl::TolerantMode") +
gsi::enum_const ("StrictMode", QUrl::StrictMode, "@brief Enum constant QUrl::StrictMode"), gsi::enum_const ("StrictMode", QUrl::StrictMode, "@brief Enum constant QUrl::StrictMode"),
"@qt\n@brief This class represents the QUrl::ParsingMode enum"); "@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"); "@qt\n@brief This class represents the QFlags<QUrl::ParsingMode> flag set");
// Inject the declarations into the parent // 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> 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_Enum_as_child (decl_QUrl_ParsingMode_Enum, "QtCore", "ParsingMode");
static gsi::ClassExt<QUrl> decl_QUrl_ParsingMode_Enums_as_child (decl_QUrl_ParsingMode_Enums, "QFlags_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 <QMutex>
#include <QReadWriteLock> #include <QReadWriteLock>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -143,12 +143,12 @@ static gsi::Methods methods_QWaitCondition () {
return methods; return methods;
} }
gsi::Class<QWaitCondition> decl_QWaitCondition ("QWaitCondition", gsi::Class<QWaitCondition> decl_QWaitCondition ("QtCore", "QWaitCondition",
methods_QWaitCondition (), methods_QWaitCondition (),
"@qt\n@brief Binding of 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 <QWriteLocker>
#include <QReadWriteLock> #include <QReadWriteLock>
#include "gsiQt.h" #include "gsiQt.h"
#include "gsiQtCommon.h" #include "gsiQtCoreCommon.h"
#include "gsiDeclQtTypeTraits.h" #include "gsiDeclQtCoreTypeTraits.h"
#include <memory> #include <memory>
// ----------------------------------------------------------------------- // -----------------------------------------------------------------------
@ -116,12 +116,12 @@ static gsi::Methods methods_QWriteLocker () {
return methods; return methods;
} }
gsi::Class<QWriteLocker> decl_QWriteLocker ("QWriteLocker", gsi::Class<QWriteLocker> decl_QWriteLocker ("QtCore", "QWriteLocker",
methods_QWriteLocker (), methods_QWriteLocker (),
"@qt\n@brief Binding of 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