mirror of https://github.com/KLayout/klayout.git
1564 lines
73 KiB
Plaintext
1564 lines
73 KiB
Plaintext
|
|
# Run the script with Qt >=4.6.2
|
|
# QTINCLUDE=/usr/include/qt4 ./mkqtdecl.rb
|
|
# mv Makefile.qtdecl.new Makefile.qtdecl
|
|
# mv gsiDeclQtTypeTraits.h.new gsiDeclQtTypeTraits.h
|
|
|
|
# --------------------------------------------------------------
|
|
# Qt
|
|
|
|
# drops enum members
|
|
drop_enum_const "Qt", /WindowType::WindowSoftkeysVisibleHint/
|
|
drop_enum_const "Qt", /WindowType::WindowSoftkeysRespondHint/
|
|
|
|
# --------------------------------------------------------------
|
|
# QtCore
|
|
|
|
drop_class "QLocale", /Data/
|
|
drop_class "QVariant", /Private/
|
|
drop_class "QVariant", /Handler/
|
|
drop_class "QVariant" # implicitly defined
|
|
|
|
# not implemented:
|
|
drop_class "QAbstractEventDispatcher"
|
|
drop_class "QAbstractFileEngineHandler"
|
|
drop_class "QAbstractFileEngineIterator"
|
|
drop_class "QAbstractFileEngine" # read requires char *
|
|
drop_class "QAlgorithmsPrivate"
|
|
drop_class "QArgument"
|
|
drop_class "QAtomic"
|
|
drop_class "QAtomicInt"
|
|
drop_class "QAtomicPointer"
|
|
drop_class "QBasicAtomicInt"
|
|
drop_class "QBasicAtomicPointer"
|
|
drop_class "QBitArray"
|
|
drop_class "QBitRef"
|
|
drop_class "QBool"
|
|
drop_class "QByteArray"
|
|
drop_class "QByteRef"
|
|
drop_class "QCache"
|
|
drop_class "QChar"
|
|
drop_class "QCharRef"
|
|
drop_class "QConstString"
|
|
drop_class "QContiguousCache"
|
|
drop_class "QContiguousCacheData"
|
|
drop_class "QContiguousCacheTypedData"
|
|
drop_class "QDebug"
|
|
drop_class "QExplicitlySharedDataPointer"
|
|
drop_class "QFileInfoList"
|
|
drop_class "QFileInfoListIterator"
|
|
drop_class "QFlag"
|
|
drop_class "QFlags"
|
|
drop_class "QForeachContainer"
|
|
drop_class "QForeachContainerBase"
|
|
drop_class "QFSFileEngine"
|
|
drop_class "QGenericArgument"
|
|
drop_class "QGenericReturnArgument"
|
|
drop_class "QGlobalStatic"
|
|
drop_class "QGlobalStaticDeleter"
|
|
drop_class "QHash"
|
|
drop_class "QHashData"
|
|
drop_class "QHashDummyNode"
|
|
drop_class "QHashDummyValue"
|
|
drop_class "QHashIterator"
|
|
drop_class "QHashNode"
|
|
drop_class "QIncompatibleFlag"
|
|
drop_class "QInternal"
|
|
drop_class "QIntegerForSizeof"
|
|
drop_class "QLatin1Char"
|
|
drop_class "QLatin1String"
|
|
drop_class "QLinkedList"
|
|
drop_class "QLinkedListData"
|
|
drop_class "QLinkedListIterator"
|
|
drop_class "QLinkedListNode"
|
|
drop_class "QList"
|
|
drop_class "QListData"
|
|
drop_class "QListIterator"
|
|
drop_class "QMap"
|
|
drop_class "QMapData"
|
|
drop_class "QMapIterator"
|
|
drop_class "QMapNode"
|
|
drop_class "QMapPayloadNode"
|
|
drop_class "QMetaObjectExtraData"
|
|
drop_class "QMetaTypeId"
|
|
drop_class "QMetaTypeId2"
|
|
drop_class "QModelIndexList"
|
|
drop_class "QMultiHash"
|
|
drop_class "QMultiMap"
|
|
drop_class "QMutableHashIterator"
|
|
drop_class "QMutableLinkedListIterator"
|
|
drop_class "QMutableListIterator"
|
|
drop_class "QMutableMapIterator"
|
|
drop_class "QMutableSetIterator"
|
|
drop_class "QMutableStringListIterator"
|
|
drop_class "QMutableVectorIterator"
|
|
drop_class "QMutexLocker"
|
|
drop_class "QNoDebug"
|
|
drop_class "QNoImplicitBoolCast"
|
|
drop_class "QObjectCleanupHandler"
|
|
drop_class "QObjectData"
|
|
drop_class "QObjectList"
|
|
drop_class "QObjectUserData"
|
|
drop_class "QPair"
|
|
drop_class "QPointer"
|
|
drop_class "QQueue"
|
|
drop_class "QReturnArgument"
|
|
drop_class "QScopedArrayPointer"
|
|
drop_class "QScopedPointerArrayDeleter"
|
|
drop_class "QScopedPointerDeleter"
|
|
drop_class "QScopedPointerPodDeleter"
|
|
drop_class "QSet"
|
|
drop_class "QSetIterator"
|
|
drop_class "QSharedDataPointer"
|
|
drop_class "QSharedData" # where to get QAtomic?
|
|
drop_class "QSharedPointer"
|
|
drop_class "QStack"
|
|
drop_class "QStdWString"
|
|
drop_class "QStringListIterator"
|
|
drop_class "QStringList" # mapped otherwise
|
|
drop_class "QString" # mapped otherwise
|
|
drop_class "QStringRef"
|
|
drop_class "QtAlgorithms"
|
|
drop_class "QtCleanUpFunction"
|
|
drop_class "QtContainerFwd"
|
|
drop_class "QtDebug"
|
|
drop_class "QtEndian"
|
|
drop_class "QTextCodecFactoryInterface"
|
|
drop_class "QTextCodecPlugin"
|
|
drop_class "QTextIStream"
|
|
drop_class "QTextOStream"
|
|
drop_class "QTextStreamFunction"
|
|
drop_class "QTextStreamManipulator"
|
|
drop_class "QtGlobal"
|
|
drop_class "QThreadStorage"
|
|
drop_class "QThreadStorageData"
|
|
drop_class "QtMsgHandler"
|
|
drop_class "QtPlugin"
|
|
drop_class "QtPluginInstanceFunction"
|
|
drop_class "QtPrivate"
|
|
drop_class "QtSharedPointer"
|
|
drop_class "QTypeInfo"
|
|
drop_class "QUuid"
|
|
drop_class "QUpdateLaterEvent"
|
|
drop_class "QVariantComparisonHelper"
|
|
drop_class "QVariantList"
|
|
drop_class "QVariant"
|
|
drop_class "QVariantMap"
|
|
drop_class "QVarLengthArray"
|
|
drop_class "QVector"
|
|
drop_class "QVectorData"
|
|
drop_class "QVectorIterator"
|
|
drop_class "QVectorTypedData"
|
|
|
|
drop_enum_const "QEvent", /CocoaRequestModal/ # not available on WIN
|
|
drop_method :all_classes, /::metaObject/ # messes up the overload scheme since it can be overloaded but is required internally before overloading is effective (on attach). Use staticMetaObject instead.
|
|
drop_method :all_classes, /::qt_/ # internal use only
|
|
drop_method :all_classes, /::d_func/ # internal use only
|
|
drop_method :all_classes, /::connectNotify/ # messes up the overload scheme since it can be overloaded but is required internally before overloading is effective (on attach). Use staticMetaObject instead.
|
|
drop_method "QFont", /QFont::initialize/ # Must not hide Ruby's initialize and is not public
|
|
drop_method "QColormap", /QColormap::initialize/ # Must not hide Ruby's initialize and is not public
|
|
drop_method "QAccessible", /QAccessible::initialize/ # Must not hide Ruby's initialize and is not public
|
|
drop_method "QEasingCurve", /QEasingCurve::setCustomType/ # requires function *
|
|
drop_method "QEasingCurve", /QEasingCurve::customType/ # requires function *
|
|
drop_method "QMetaObject", /QMetaObject::d\(/ # invalid return value (struct)
|
|
drop_method "QMetaObject", /QMetaObject::invokeMethod/ # requires QGenericArgument which is a macro
|
|
drop_method "QMetaObject", /QMetaObject::metacall/ # requires void**
|
|
drop_method "QMetaMethod", /QMetaMethod::invoke/ # requires QGenericArgument which is a macro
|
|
drop_method "QMetaMethod", /QMetaMethod::newInstance/ # requires QGenericArgument which is a macro
|
|
drop_method "QMetaObject", /QMetaObject::activate/ # requires void**
|
|
drop_method "QMetaObject", /QMetaObject::static_metacall/ # requires void**
|
|
drop_method "QMetaObject", /QMetaObject::addGuard/ # requires QObject**
|
|
drop_method "QMetaObject", /QMetaObject::changeGuard/ # requires QObject**
|
|
drop_method "QMetaObject", /QMetaObject::removeGuard/ # requires QObject**
|
|
drop_method "QMetaObject", /QMetaObject::newInstance/ # requires QGenericArgument
|
|
drop_method "QMetaType", /QMetaType::registerStreamOperators/ # requires callbacks
|
|
drop_method "QMetaType", /QMetaType::registerType/ # requires callbacks
|
|
drop_method "QMatrix4x4", /QMatrix4x4::QMatrix4x4.*GenericMatrix/ # GenericMatrix is a template
|
|
drop_method "QMatrix4x4", /QMatrix4x4::normalMatrix/ # return value GenericMatrix is a template
|
|
drop_method "QMatrix4x4", /QMatrix4x4::toGenericMatrix/ # return value GenericMatrix is a template
|
|
drop_method "QCoreApplication", /QCoreApplication::setEventFilter/ # requires callbacks
|
|
drop_method "QCoreApplication", /QCoreApplication::QCoreApplication/ # not required (use instance), required char **
|
|
drop_method "QCoreApplication", /QCoreApplication::argv/ # requires char **
|
|
drop_method "QCoreApplication", /QCoreApplication::argc/ # does not make sense without argv ..
|
|
drop_method "QCoreApplication", /QCoreApplication::compressEvent/ # QPostEventList is missing
|
|
drop_method "", /::operator\s*>>\(QDataStream\s*&/ # implemented through "read" below
|
|
drop_method "", /::operator\s*<<\(QDataStream\s*&/ # implemented through "put" below
|
|
drop_method "QDataStream", /::operator\s*>>/ # implemented through read
|
|
drop_method "QDataStream", /::operator\s*<</ # implemented through put
|
|
drop_method "QDataStream", /QDataStream::readBytes\s*\(\s*char\s*\*\s*&/ # requires "char *&"
|
|
drop_method "QStringMatcher", /QStringMatcher::QStringMatcher\(const\s+QChar\s+\*/ # requires "QChar *", alternative available
|
|
drop_method "QStringMatcher", /QStringMatcher::indexIn\(const\s+QChar\s+\*/ # requires "QChar *", alternative available
|
|
drop_method "QObject", /QObject::findChild/ # template member
|
|
drop_method "QObject", /QObject::findChildren/ # template member
|
|
drop_method "QObject", /QObject::setUserData/ # QObjectUserData not available
|
|
drop_method "QObject", /QObject::userData/ # QObjectUserData not available
|
|
drop_method "QChildEvent", /QChildEvent::child/ # provided through a special implementation
|
|
drop_method "QFile", /QFile::setDecodingFunction/ # uses callbacks
|
|
drop_method "QFile", /QFile::setEncodingFunction/ # uses callbacks
|
|
drop_method "QFile", /QFile::open.*IO_FILE/ # uses internal struct
|
|
drop_method "QPrinter", /QPrinter::printerSelectionOption/ # not available on WIN
|
|
drop_method "QPrinter", /QPrinter::setPrinterSelectionOption/ # not available on WIN
|
|
drop_method "QSessionManager", /QSessionManager::handle/ # not available on WIN
|
|
drop_method "QCoreApplication", /QCoreApplication::watchUnixSignal/ # not available on WIN
|
|
drop_method "QPersistentModelIndex", /QPersistentModelIndex::operator\s+const\s+class\s+QModelIndex/ # implemented specially
|
|
drop_method "QSettings", /QSettings::registerFormat/ # uses callbacks
|
|
drop_method "QSettings", /QSettings::iniCodec/ # requires QTextCodec
|
|
drop_method "QSettings", /QSettings::setIniCodec/ # requires QTextCodec
|
|
drop_method "QAbstractFileEngine", /QAbstractFileEngine::supportsExtension/ # missing classes ExtensionOption etc.
|
|
drop_method "QAbstractFileEngine", /QAbstractFileEngine::extension/ # missing classes ExtensionOption etc.
|
|
drop_method :all_classes, /::qt_check_for_QOBJECT_macro/ # don't include in API!
|
|
drop_method "QUrl", /QUrl::data_ptr/ # QUrlPrivate not available
|
|
drop_method "QFile", /QFile::fileEngine\(\)/ # requires AbstractFileEngine
|
|
drop_method "QTemporaryFile", /QTemporaryFile::fileEngine\(\)/ # requires AbstractFileEngine
|
|
drop_method "QTemporaryFile", /QTemporaryFile::readData\(char\s*\*/ # requires char *, QByteArray alternative available
|
|
drop_method "QTemporaryFile", /QTemporaryFile::readLineData\(char\s*\*/ # requires char *, QByteArray alternative available
|
|
drop_method "QFile", /QFile::map\(/ # requires char * as address
|
|
drop_method "QFile", /QFile::unmap\(/ # requires char * as address
|
|
drop_method "QFile", /QFile::readData\(char\s*\*/ # requires char *, QByteArray alternative available
|
|
drop_method "QFile", /QFile::readLineData\(char\s*\*/ # requires char *, QByteArray alternative available
|
|
drop_method "QIODevice", /QIODevice::getChar\(/ # requires char *, TODO: provide alternative?
|
|
drop_method "QIODevice", /QIODevice::peek\(char\s*\*/ # requires char *, QByteArray alternative available
|
|
drop_method "QIODevice", /QIODevice::read\(char\s*\*/ # requires char *, QByteArray alternative available
|
|
drop_method "QIODevice", /QIODevice::readLine\(char\s*\*/ # requires char *, QByteArray alternative available
|
|
drop_method "QIODevice", /QIODevice::readData\(char\s*\*/ # requires char *, QByteArray alternative available
|
|
drop_method "QIODevice", /QIODevice::readLineData\(char\s*\*/ # requires char *, QByteArray alternative available
|
|
drop_method "QIODevice", /QIODevice::write\(const\s+char\s*\*[^,]*\)/ # clashes with QByteArray version (because of handling of binary data containing 0 characters we prefer write(QByteArray))
|
|
drop_method "QProcess", /QProcess::readData\(/ # requires char *
|
|
drop_method "QProcess", /QProcess::readLineData\(char\s*\*/ # requires char *, QByteArray alternative available
|
|
drop_method "QDataStream", /QDataStream::readRawData\(char\s*\*/ # requires char *
|
|
drop_method "QFile", /QFile::open\(int/ # unsupported file descriptor
|
|
drop_method "QFile", /QFile::decodeName\(const\s+QByteArray/ # clashes with const char * version
|
|
drop_method "QTemporaryFile", /QTemporaryFile::open\(int/ # unsupported file descriptor
|
|
drop_method "QTextStream", /QTextStream::QTextStream\(QByteArray/ # clashes with QString variant
|
|
drop_method "QTextStream", /QTextStream::QTextStream\(const\s*QByteArray/ # clashes with QString variant
|
|
drop_method "QTextStream", /QTextStream::QTextStream\(.*_IO_FILE/ # unsupported IO_FILE
|
|
drop_method "QTextStream", /QTextStream::QTextStream\(.*_IO_FILE/ # unsupported IO_FILE
|
|
drop_method "", /::operator\s*>>\(QTextStream\s*&/ # implemented through read
|
|
drop_method "", /::operator\s*<<\(QTextStream\s*&/ # implemented through put
|
|
drop_method "QTextStream", /::operator\s*>>/ # implemented through read
|
|
drop_method "QTextStream", /::operator\s*<</ # implemented through put
|
|
drop_method "QTextStream", /QTextStream::readData\(char\s*\*/ # requires char *, QByteArray alternative available
|
|
drop_method "QTextStream", /QTextStream::readLineData\(char\s*\*/ # requires char *, QByteArray alternative available
|
|
drop_method "QTextCodec", /QTextCodec::codecForName\(const\s+QByteArray/ # clashes with const char * variant
|
|
drop_method "QTextCodec", /QTextCodec::toUnicode\(const\s+QByteArray/ # clashes with const char * variant
|
|
drop_method "QTextCodec", /QTextCodec::fromUnicode\(const\s+QChar\s+\*/ # requires real QChar *
|
|
drop_method "QTextEncoder", /QTextEncoder::fromUnicode\(const\s+QChar\s+\*/ # requires real QChar *
|
|
drop_method "", /::operator\s*==\(const\s+QVariant\s*&\w+,\s*const\s+QVariantComparisonHelper/ # requires QVariantComparisonHelper
|
|
drop_method "", /::operator\s*!=\(const\s+QVariant\s*&\w+,\s*const\s+QVariantComparisonHelper/ # requires QVariantComparisonHelper
|
|
drop_method "QByteArrayMatcher", /QByteArrayMatcher::indexIn\(const\s+QByteArray/ # clashes with const char * variant
|
|
drop_method "QRegion", /QRegion::setRects/ # gets a new implementation
|
|
drop_method "QTimer", /static\s+void\s+QTimer::singleShot\(/ # requires slots, alternative impl?
|
|
|
|
rename "QLocale", /QLocale::toString\(int i/, "toString_i"
|
|
rename "QLocale", /QLocale::toString\(unsigned int/, "toString_ui"
|
|
rename "QLocale", /QLocale::toString\(short i/, "toString_s"
|
|
rename "QLocale", /QLocale::toString\(unsigned short/, "toString_us"
|
|
rename "QLocale", /QLocale::toString\(qlonglong/, "toString_ll"
|
|
rename "QLocale", /QLocale::toString\(qulonglong/, "toString_ull"
|
|
rename "QLocale", /QLocale::toString\(float/, "toString_f"
|
|
rename "QLocale", /QLocale::toString\(double/, "toString_d"
|
|
|
|
rename "QResource", /QResource::registerResource\(const\s+unsigned\s+char\s+\*/, "registerResource_data"
|
|
rename "QResource", /QResource::registerResource\(const QString/, "registerResource_file"
|
|
rename "QResource", /QResource::unregisterResource\(const\s+unsigned\s+char\s+\*/, "unregisterResource_data"
|
|
rename "QResource", /QResource::unregisterResource\(const QString/, "unregisterResource_file"
|
|
|
|
rename "QProcess", /QProcess::error\(QProcess::ProcessError/, "error_sig" # disambiguator
|
|
rename "QProcess", /QProcess::finished\(int[\s\w]*\)/, "finished_int" # disambiguator finished(int) vs. finished(int, QProcess::ExitStatus)
|
|
|
|
# alternative implementation for QObject::findChild using QObject for T
|
|
add_native_impl("QObject", <<'CODE', <<'DECL')
|
|
QObject *find_child_impl (QObject *object, const QString &name) { return object->findChild<QObject *> (name); }
|
|
CODE
|
|
gsi::method_ext("findChild", &find_child_impl, "@brief Specialisation for findChild (uses QObject as T).")
|
|
DECL
|
|
|
|
# alternative implementation for QChildEvent::child
|
|
# Reason: this method does not supply a true QObject pointer. Instead it will
|
|
# deliver a pointer to an object that is almost destroyed. Normal RTTI will
|
|
# not work on this. Neighter can it be attached an gsi::ObjectBase object.
|
|
add_native_impl("QChildEvent", <<'CODE', <<'DECL')
|
|
|
|
namespace gsi
|
|
{
|
|
gsi::Class<QObject> &qtdecl_QObject ();
|
|
}
|
|
|
|
namespace
|
|
{
|
|
struct DummyQObject { };
|
|
|
|
class RawQObjectClass
|
|
: public gsi::Class<QObject>
|
|
{
|
|
public:
|
|
RawQObjectClass ()
|
|
: gsi::Class<QObject> (gsi::qtdecl_QObject (), "QObject_Raw", gsi::Methods (), "@hide")
|
|
{
|
|
}
|
|
|
|
// Final class - because of missing RTTI, subclassing won't work.
|
|
virtual const gsi::ClassBase *subclass_decl (const void *) const { return this; }
|
|
virtual bool can_upcast (const void *) const { return false; }
|
|
|
|
// Does not bind to a particular type
|
|
virtual bool is_of_type (const std::type_info & /*ti*/) const { return false; }
|
|
virtual const std::type_info &type () const { return typeid (DummyQObject); }
|
|
};
|
|
}
|
|
|
|
static void _init_f_child (qt_gsi::GenericMethod *decl)
|
|
{
|
|
// Make the QChildEvent::child method return a special class which is final
|
|
// and does not try to return a gsi::ObjectBase object.
|
|
static RawQObjectClass s_cls;
|
|
decl->set_return<QObject * > ();
|
|
decl->ret_type ().set_cls (&s_cls);
|
|
}
|
|
|
|
static void _call_f_child (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs & /*args*/, gsi::SerialArgs &ret)
|
|
{
|
|
ret.write<QObject * > ((QObject *)((QChildEvent *)cls)->child ());
|
|
}
|
|
|
|
CODE
|
|
gsi::Methods(new qt_gsi::GenericMethod ("child",
|
|
"@brief Method QObject *QChildEvent::child()\n"
|
|
"NOTE: the object returned by this method is not memory managed. It may be destroyed internally without notice. \n"
|
|
"The returned object shall not be stored or used outside the childEvent handler. "
|
|
"If used outside this handler, the reference might get lost and the application may crash.\n"
|
|
"Furthermore, the object returned will only represent a QObject, not any derived type.\n",
|
|
true, &_init_f_child, &_call_f_child))
|
|
DECL
|
|
|
|
# alternative implementation for QFont::Light, QFont::Bold, QFont::Normal, QFont::DemiBold, QFont::Black
|
|
add_native_impl("QFont", <<'CODE', <<'DECL')
|
|
static unsigned int font_const_light () { return (unsigned int) QFont::Light; }
|
|
static unsigned int font_const_normal () { return (unsigned int) QFont::Normal; }
|
|
static unsigned int font_const_demibold () { return (unsigned int) QFont::DemiBold; }
|
|
static unsigned int font_const_bold () { return (unsigned int) QFont::Bold; }
|
|
static unsigned int font_const_black () { return (unsigned int) QFont::Black; }
|
|
CODE
|
|
gsi::method("Light", &font_const_light, "@brief Font weight constant 'QFont::Light'.") +
|
|
gsi::method("Normal", &font_const_normal, "@brief Font weight constant 'QFont::Normal'.") +
|
|
gsi::method("DemiBold", &font_const_demibold, "@brief Font weight constant 'QFont::DemiBold'.") +
|
|
gsi::method("Bold", &font_const_bold, "@brief Font weight constant 'QFont::Bold'.") +
|
|
gsi::method("Black", &font_const_black, "@brief Font weight constant 'QFont::Black'.")
|
|
DECL
|
|
|
|
# alternative implementation for QRegion::setRects
|
|
add_native_impl("QRegion", <<'CODE', <<'DECL')
|
|
static void f_QRegion_setRects(QRegion *r, const std::vector<QRect> &rects)
|
|
{
|
|
if (! rects.empty ()) {
|
|
return r->setRects (&rects.front (), int (rects.size ()));
|
|
}
|
|
}
|
|
CODE
|
|
gsi::method_ext("setRects", &f_QRegion_setRects, "@brief Adaption of setRects without pointer.")
|
|
DECL
|
|
|
|
# alternative implementation for QPersistentQModelIndex::operator const QModelIndex &
|
|
add_native_impl("QPersistentModelIndex", <<'CODE', <<'DECL')
|
|
static const QModelIndex &castToQModelIndex(const QPersistentModelIndex *m)
|
|
{
|
|
return m->operator const QModelIndex &();
|
|
}
|
|
CODE
|
|
gsi::method_ext("castToQModelIndex", &castToQModelIndex, "@brief Binding for \"operator const QModelIndex &\".")
|
|
DECL
|
|
|
|
# implementation of operator<< and operator>> for QDataStream
|
|
add_native_impl("QDataStream", <<'CODE', <<'DECL')
|
|
static qint8 f_QDataStream_read_qint8(QDataStream *s)
|
|
{
|
|
qint8 v = 0;
|
|
*s >> v;
|
|
return v;
|
|
}
|
|
|
|
static quint8 f_QDataStream_read_quint8(QDataStream *s)
|
|
{
|
|
quint8 v = 0;
|
|
*s >> v;
|
|
return v;
|
|
}
|
|
|
|
static qint16 f_QDataStream_read_qint16(QDataStream *s)
|
|
{
|
|
qint16 v = 0;
|
|
*s >> v;
|
|
return v;
|
|
}
|
|
|
|
static quint16 f_QDataStream_read_quint16(QDataStream *s)
|
|
{
|
|
quint16 v = 0;
|
|
*s >> v;
|
|
return v;
|
|
}
|
|
|
|
static qint32 f_QDataStream_read_qint32(QDataStream *s)
|
|
{
|
|
qint32 v = 0;
|
|
*s >> v;
|
|
return v;
|
|
}
|
|
|
|
static quint32 f_QDataStream_read_quint32(QDataStream *s)
|
|
{
|
|
quint32 v = 0;
|
|
*s >> v;
|
|
return v;
|
|
}
|
|
|
|
static quint64 f_QDataStream_read_quint64(QDataStream *s)
|
|
{
|
|
quint64 v = 0;
|
|
*s >> v;
|
|
return v;
|
|
}
|
|
|
|
static qint64 f_QDataStream_read_qint64(QDataStream *s)
|
|
{
|
|
qint64 v = 0;
|
|
*s >> v;
|
|
return v;
|
|
}
|
|
|
|
static double f_QDataStream_read_double(QDataStream *s)
|
|
{
|
|
double v = 0;
|
|
*s >> v;
|
|
return v;
|
|
}
|
|
|
|
static float f_QDataStream_read_float(QDataStream *s)
|
|
{
|
|
float v = 0;
|
|
*s >> v;
|
|
return v;
|
|
}
|
|
|
|
static bool f_QDataStream_read_bool(QDataStream *s)
|
|
{
|
|
bool v = 0;
|
|
*s >> v;
|
|
return v;
|
|
}
|
|
|
|
static qt_gsi::Converter<class QChar>::target_type f_QDataStream_read_qchar(QDataStream *s)
|
|
{
|
|
QChar v = 0;
|
|
*s >> v;
|
|
return qt_gsi::Converter<class QChar>::toc (v);
|
|
}
|
|
|
|
static qt_gsi::Converter<class QList<int> >::target_type f_QDataStream_read_int_list(QDataStream *s)
|
|
{
|
|
QList<int> v;
|
|
*s >> v;
|
|
return qt_gsi::Converter<class QList<int> >::toc (v);
|
|
}
|
|
|
|
static qt_gsi::Converter<class QVector<int> >::target_type f_QDataStream_read_int_vector(QDataStream *s)
|
|
{
|
|
QVector<int> v;
|
|
*s >> v;
|
|
return qt_gsi::Converter<class QVector<int> >::toc (v);
|
|
}
|
|
|
|
static QString f_QDataStream_read_string(QDataStream *s)
|
|
{
|
|
QString v;
|
|
*s >> v;
|
|
return v;
|
|
}
|
|
|
|
static qt_gsi::Converter<QByteArray>::target_type f_QDataStream_read_bytearray(QDataStream *s)
|
|
{
|
|
QByteArray v;
|
|
*s >> v;
|
|
return qt_gsi::Converter<QByteArray>::toc (v);
|
|
}
|
|
|
|
static QDataStream *f_QDataStream_put_qint8(QDataStream *s, qint8 v)
|
|
{
|
|
*s << v;
|
|
return s;
|
|
}
|
|
|
|
static QDataStream *f_QDataStream_put_quint8(QDataStream *s, quint8 v)
|
|
{
|
|
*s << v;
|
|
return s;
|
|
}
|
|
|
|
static QDataStream *f_QDataStream_put_qint16(QDataStream *s, qint16 v)
|
|
{
|
|
*s << v;
|
|
return s;
|
|
}
|
|
|
|
static QDataStream *f_QDataStream_put_quint16(QDataStream *s, quint16 v)
|
|
{
|
|
*s << v;
|
|
return s;
|
|
}
|
|
|
|
static QDataStream *f_QDataStream_put_qint32(QDataStream *s, qint32 v)
|
|
{
|
|
*s << v;
|
|
return s;
|
|
}
|
|
|
|
static QDataStream *f_QDataStream_put_quint32(QDataStream *s, quint32 v)
|
|
{
|
|
*s << v;
|
|
return s;
|
|
}
|
|
|
|
static QDataStream *f_QDataStream_put_qint64(QDataStream *s, qint64 v)
|
|
{
|
|
*s << v;
|
|
return s;
|
|
}
|
|
|
|
static QDataStream *f_QDataStream_put_quint64(QDataStream *s, quint64 v)
|
|
{
|
|
*s << v;
|
|
return s;
|
|
}
|
|
|
|
static QDataStream *f_QDataStream_put_float(QDataStream *s, float v)
|
|
{
|
|
*s << v;
|
|
return s;
|
|
}
|
|
|
|
static QDataStream *f_QDataStream_put_double(QDataStream *s, double v)
|
|
{
|
|
*s << v;
|
|
return s;
|
|
}
|
|
|
|
static QDataStream *f_QDataStream_put_bool(QDataStream *s, bool v)
|
|
{
|
|
*s << v;
|
|
return s;
|
|
}
|
|
|
|
static QDataStream *f_QDataStream_put_qchar(QDataStream *s, const qt_gsi::Converter<class QChar>::target_type &v)
|
|
{
|
|
*s << qt_gsi::Converter<class QChar>::toq (v);
|
|
return s;
|
|
}
|
|
|
|
static QDataStream *f_QDataStream_put_int_list(QDataStream *s, const qt_gsi::Converter<class QList<int> >::target_type &v)
|
|
{
|
|
*s << qt_gsi::Converter<class QList<int> >::toq (v);
|
|
return s;
|
|
}
|
|
|
|
static QDataStream *f_QDataStream_put_int_vector(QDataStream *s, const qt_gsi::Converter<class QVector<int> >::target_type &v)
|
|
{
|
|
*s << qt_gsi::Converter<class QVector<int> >::toq (v);
|
|
return s;
|
|
}
|
|
|
|
static QDataStream *f_QDataStream_put_string(QDataStream *s, const QString &v)
|
|
{
|
|
*s << v;
|
|
return s;
|
|
}
|
|
|
|
static QDataStream *f_QDataStream_put_bytearray(QDataStream *s, const qt_gsi::Converter<class QByteArray>::target_type &v)
|
|
{
|
|
*s << qt_gsi::Converter<class QByteArray>::toq (v);
|
|
return s;
|
|
}
|
|
|
|
CODE
|
|
gsi::method_ext("read_i8", &f_QDataStream_read_qint8, "@brief Non-ambiguous adaptation of the corresponding operator>>") +
|
|
gsi::method_ext("read_ui8", &f_QDataStream_read_quint8, "@brief Non-ambiguous adaptation of the corresponding operator>>") +
|
|
gsi::method_ext("read_i16", &f_QDataStream_read_qint16, "@brief Non-ambiguous adaptation of the corresponding operator>>") +
|
|
gsi::method_ext("read_ui16", &f_QDataStream_read_quint16, "@brief Non-ambiguous adaptation of the corresponding operator>>") +
|
|
gsi::method_ext("read_i32", &f_QDataStream_read_qint32, "@brief Non-ambiguous adaptation of the corresponding operator>>") +
|
|
gsi::method_ext("read_ui32", &f_QDataStream_read_quint32, "@brief Non-ambiguous adaptation of the corresponding operator>>") +
|
|
gsi::method_ext("read_i64", &f_QDataStream_read_qint64, "@brief Non-ambiguous adaptation of the corresponding operator>>") +
|
|
gsi::method_ext("read_ui64", &f_QDataStream_read_quint64, "@brief Non-ambiguous adaptation of the corresponding operator>>") +
|
|
gsi::method_ext("read_d", &f_QDataStream_read_double, "@brief Non-ambiguous adaptation of the corresponding operator>>") +
|
|
gsi::method_ext("read_f", &f_QDataStream_read_float, "@brief Non-ambiguous adaptation of the corresponding operator>>") +
|
|
gsi::method_ext("read_b", &f_QDataStream_read_bool, "@brief Non-ambiguous adaptation of the corresponding operator>>") +
|
|
gsi::method_ext("read_qc", &f_QDataStream_read_qchar, "@brief Non-ambiguous adaptation of the corresponding operator>>") +
|
|
gsi::method_ext("read_il", &f_QDataStream_read_int_list, "@brief Non-ambiguous adaptation of the corresponding operator>>") +
|
|
gsi::method_ext("read_iv", &f_QDataStream_read_int_vector, "@brief Non-ambiguous adaptation of the corresponding operator>>") +
|
|
gsi::method_ext("read_s", &f_QDataStream_read_string, "@brief Non-ambiguous adaptation of the corresponding operator>>") +
|
|
gsi::method_ext("read_ba", &f_QDataStream_read_bytearray, "@brief Non-ambiguous adaptation of the corresponding operator>>") +
|
|
gsi::method_ext("put_i8", &f_QDataStream_put_qint8, "@brief Non-ambiguous adaptation of the corresponding operator<<") +
|
|
gsi::method_ext("put_ui8", &f_QDataStream_put_quint8, "@brief Non-ambiguous adaptation of the corresponding operator<<") +
|
|
gsi::method_ext("put_i16", &f_QDataStream_put_qint16, "@brief Non-ambiguous adaptation of the corresponding operator<<") +
|
|
gsi::method_ext("put_ui16", &f_QDataStream_put_quint16, "@brief Non-ambiguous adaptation of the corresponding operator<<") +
|
|
gsi::method_ext("put_i32", &f_QDataStream_put_qint32, "@brief Non-ambiguous adaptation of the corresponding operator<<") +
|
|
gsi::method_ext("put_ui32", &f_QDataStream_put_quint32, "@brief Non-ambiguous adaptation of the corresponding operator<<") +
|
|
gsi::method_ext("put_i64", &f_QDataStream_put_qint64, "@brief Non-ambiguous adaptation of the corresponding operator<<") +
|
|
gsi::method_ext("put_ui64", &f_QDataStream_put_quint64, "@brief Non-ambiguous adaptation of the corresponding operator<<") +
|
|
gsi::method_ext("put_d", &f_QDataStream_put_double, "@brief Non-ambiguous adaptation of the corresponding operator<<") +
|
|
gsi::method_ext("put_f", &f_QDataStream_put_float, "@brief Non-ambiguous adaptation of the corresponding operator<<") +
|
|
gsi::method_ext("put_b", &f_QDataStream_put_bool, "@brief Non-ambiguous adaptation of the corresponding operator<<") +
|
|
gsi::method_ext("put_qc", &f_QDataStream_put_qchar, "@brief Non-ambiguous adaptation of the corresponding operator<<") +
|
|
gsi::method_ext("put_il", &f_QDataStream_put_int_list, "@brief Non-ambiguous adaptation of the corresponding operator<<") +
|
|
gsi::method_ext("put_iv", &f_QDataStream_put_int_vector, "@brief Non-ambiguous adaptation of the corresponding operator<<") +
|
|
gsi::method_ext("put_s", &f_QDataStream_put_string, "@brief Non-ambiguous adaptation of the corresponding operator<<") +
|
|
gsi::method_ext("put_ba", &f_QDataStream_put_bytearray, "@brief Non-ambiguous adaptation of the corresponding operator<<")
|
|
DECL
|
|
|
|
# implementation of operator<< and operator>> for QTextStream
|
|
add_native_impl("QTextStream", <<'CODE', <<'DECL')
|
|
static short f_QTextStream_read_s(QTextStream *s)
|
|
{
|
|
short v = 0;
|
|
*s >> v;
|
|
return v;
|
|
}
|
|
|
|
static unsigned short f_QTextStream_read_us(QTextStream *s)
|
|
{
|
|
unsigned short v = 0;
|
|
*s >> v;
|
|
return v;
|
|
}
|
|
|
|
static int f_QTextStream_read_i(QTextStream *s)
|
|
{
|
|
int v = 0;
|
|
*s >> v;
|
|
return v;
|
|
}
|
|
|
|
static unsigned int f_QTextStream_read_ui(QTextStream *s)
|
|
{
|
|
unsigned int v = 0;
|
|
*s >> v;
|
|
return v;
|
|
}
|
|
|
|
static qulonglong f_QTextStream_read_ull(QTextStream *s)
|
|
{
|
|
qulonglong v = 0;
|
|
*s >> v;
|
|
return v;
|
|
}
|
|
|
|
static qlonglong f_QTextStream_read_ll(QTextStream *s)
|
|
{
|
|
qlonglong v = 0;
|
|
*s >> v;
|
|
return v;
|
|
}
|
|
|
|
static double f_QTextStream_read_double(QTextStream *s)
|
|
{
|
|
double v = 0;
|
|
*s >> v;
|
|
return v;
|
|
}
|
|
|
|
static float f_QTextStream_read_float(QTextStream *s)
|
|
{
|
|
float v = 0;
|
|
*s >> v;
|
|
return v;
|
|
}
|
|
|
|
static qt_gsi::Converter<QChar>::target_type f_QTextStream_read_qchar(QTextStream *s)
|
|
{
|
|
QChar v = 0;
|
|
*s >> v;
|
|
return qt_gsi::Converter<QChar>::toc (v);
|
|
}
|
|
|
|
static QString f_QTextStream_read_string(QTextStream *s)
|
|
{
|
|
QString v;
|
|
*s >> v;
|
|
return v;
|
|
}
|
|
|
|
static qt_gsi::Converter<QByteArray>::target_type f_QTextStream_read_bytearray(QTextStream *s)
|
|
{
|
|
QByteArray v;
|
|
*s >> v;
|
|
return qt_gsi::Converter<QByteArray>::toc (v);
|
|
}
|
|
|
|
static QTextStream *f_QTextStream_put_s(QTextStream *s, short v)
|
|
{
|
|
*s << v;
|
|
return s;
|
|
}
|
|
|
|
static QTextStream *f_QTextStream_put_us(QTextStream *s, unsigned short v)
|
|
{
|
|
*s << v;
|
|
return s;
|
|
}
|
|
|
|
static QTextStream *f_QTextStream_put_i(QTextStream *s, int v)
|
|
{
|
|
*s << v;
|
|
return s;
|
|
}
|
|
|
|
static QTextStream *f_QTextStream_put_ui(QTextStream *s, unsigned int v)
|
|
{
|
|
*s << v;
|
|
return s;
|
|
}
|
|
|
|
static QTextStream *f_QTextStream_put_ll(QTextStream *s, qlonglong v)
|
|
{
|
|
*s << v;
|
|
return s;
|
|
}
|
|
|
|
static QTextStream *f_QTextStream_put_ull(QTextStream *s, qulonglong v)
|
|
{
|
|
*s << v;
|
|
return s;
|
|
}
|
|
|
|
static QTextStream *f_QTextStream_put_float(QTextStream *s, float v)
|
|
{
|
|
*s << v;
|
|
return s;
|
|
}
|
|
|
|
static QTextStream *f_QTextStream_put_double(QTextStream *s, double v)
|
|
{
|
|
*s << v;
|
|
return s;
|
|
}
|
|
|
|
static QTextStream *f_QTextStream_put_qchar(QTextStream *s, const qt_gsi::Converter<class QChar>::target_type v)
|
|
{
|
|
*s << qt_gsi::Converter<class QChar>::toq (v);
|
|
return s;
|
|
}
|
|
|
|
static QTextStream *f_QTextStream_put_string(QTextStream *s, const QString &v)
|
|
{
|
|
*s << v;
|
|
return s;
|
|
}
|
|
|
|
static QTextStream *f_QTextStream_put_bytearray(QTextStream *s, const qt_gsi::Converter<class QByteArray>::target_type &v)
|
|
{
|
|
*s << qt_gsi::Converter<class QByteArray>::toq (v);
|
|
return s;
|
|
}
|
|
|
|
CODE
|
|
gsi::method_ext("read_s", &f_QTextStream_read_s, "@brief Non-ambiguous adaptation of the corresponding operator>>") +
|
|
gsi::method_ext("read_us", &f_QTextStream_read_us, "@brief Non-ambiguous adaptation of the corresponding operator>>") +
|
|
gsi::method_ext("read_i", &f_QTextStream_read_i, "@brief Non-ambiguous adaptation of the corresponding operator>>") +
|
|
gsi::method_ext("read_ui", &f_QTextStream_read_ui, "@brief Non-ambiguous adaptation of the corresponding operator>>") +
|
|
gsi::method_ext("read_ull", &f_QTextStream_read_ull, "@brief Non-ambiguous adaptation of the corresponding operator>>") +
|
|
gsi::method_ext("read_ll", &f_QTextStream_read_ll, "@brief Non-ambiguous adaptation of the corresponding operator>>") +
|
|
gsi::method_ext("read_d", &f_QTextStream_read_double, "@brief Non-ambiguous adaptation of the corresponding operator>>") +
|
|
gsi::method_ext("read_f", &f_QTextStream_read_float, "@brief Non-ambiguous adaptation of the corresponding operator>>") +
|
|
gsi::method_ext("read_qc", &f_QTextStream_read_qchar, "@brief Non-ambiguous adaptation of the corresponding operator>>") +
|
|
gsi::method_ext("read_s", &f_QTextStream_read_string, "@brief Non-ambiguous adaptation of the corresponding operator>>") +
|
|
gsi::method_ext("read_ba", &f_QTextStream_read_bytearray, "@brief Non-ambiguous adaptation of the corresponding operator>>") +
|
|
gsi::method_ext("put_s", &f_QTextStream_put_s, "@brief Non-ambiguous adaptation of the corresponding operator<<") +
|
|
gsi::method_ext("put_us", &f_QTextStream_put_us, "@brief Non-ambiguous adaptation of the corresponding operator<<") +
|
|
gsi::method_ext("put_i", &f_QTextStream_put_i, "@brief Non-ambiguous adaptation of the corresponding operator<<") +
|
|
gsi::method_ext("put_ui", &f_QTextStream_put_ui, "@brief Non-ambiguous adaptation of the corresponding operator<<") +
|
|
gsi::method_ext("put_ull", &f_QTextStream_put_ull, "@brief Non-ambiguous adaptation of the corresponding operator<<") +
|
|
gsi::method_ext("put_ll", &f_QTextStream_put_ll, "@brief Non-ambiguous adaptation of the corresponding operator<<") +
|
|
gsi::method_ext("put_d", &f_QTextStream_put_double, "@brief Non-ambiguous adaptation of the corresponding operator<<") +
|
|
gsi::method_ext("put_f", &f_QTextStream_put_float, "@brief Non-ambiguous adaptation of the corresponding operator<<") +
|
|
gsi::method_ext("put_qc", &f_QTextStream_put_qchar, "@brief Non-ambiguous adaptation of the corresponding operator<<") +
|
|
gsi::method_ext("put_s", &f_QTextStream_put_string, "@brief Non-ambiguous adaptation of the corresponding operator<<") +
|
|
gsi::method_ext("put_ba", &f_QTextStream_put_bytearray, "@brief Non-ambiguous adaptation of the corresponding operator<<")
|
|
DECL
|
|
|
|
final_class "QIODevice" # because readData cannot be reimplemented
|
|
final_class "QBuffer" # because readData cannot be reimplemented
|
|
final_class "QFile" # because readData cannot be reimplemented
|
|
final_class "QTemporaryFile" # because readData cannot be reimplemented
|
|
final_class "QProcess" # because readData cannot be reimplemented
|
|
|
|
drop_method "QPolygon", /QPolygon::putPoints\(.*const\s+int\s+\*/ # requires const int *
|
|
drop_method "QPolygon", /QPolygon::setPoints\(.*const\s+int\s+\*/ # requires const int *
|
|
drop_method "QPolygon", /QPolygon::QPolygon\(.*const\s+int\s+\*/ # requires const int *
|
|
no_imports "QPolygon" # base class is a template. Base methods are implemented specifically.
|
|
no_imports "QPolygonF" # base class is a template. Base methods are implemented specifically.
|
|
|
|
# enhance QPolygon by some missing methods because we dropped the base class
|
|
add_native_impl("QPolygon", <<'CODE', <<'DECL')
|
|
|
|
#include "dbPolygon.h"
|
|
|
|
static QPolygon *ctor_QPolygon_from_polygon (const db::Polygon &pts)
|
|
{
|
|
QPolygon *p = new QPolygon ();
|
|
p->reserve (int (pts.hull ().size ()));
|
|
for (db::Polygon::polygon_contour_iterator q = pts.begin_hull (); q != pts.end_hull (); ++q) {
|
|
p->push_back (QPoint ((*q).x (), (*q).y ()));
|
|
}
|
|
return p;
|
|
}
|
|
|
|
static QPolygon *ctor_QPolygon_from_simple_polygon (const db::SimplePolygon &pts)
|
|
{
|
|
QPolygon *p = new QPolygon ();
|
|
p->reserve (int (pts.hull ().size ()));
|
|
for (db::SimplePolygon::polygon_contour_iterator q = pts.begin_hull (); q != pts.end_hull (); ++q) {
|
|
p->push_back (QPoint ((*q).x (), (*q).y ()));
|
|
}
|
|
return p;
|
|
}
|
|
|
|
static QPolygon::const_iterator f_QPolygon_each_begin (const QPolygon *m)
|
|
{
|
|
return m->begin ();
|
|
}
|
|
|
|
static QPolygon::const_iterator f_QPolygon_each_end (const QPolygon *m)
|
|
{
|
|
return m->end ();
|
|
}
|
|
|
|
static QPoint f_QPolygon_at (const QPolygon *m, int i)
|
|
{
|
|
return m->at(i);
|
|
}
|
|
|
|
static QPoint f_QPolygon_front (const QPolygon *m)
|
|
{
|
|
return m->front();
|
|
}
|
|
|
|
static QPoint f_QPolygon_back (const QPolygon *m)
|
|
{
|
|
return m->back();
|
|
}
|
|
|
|
static int f_QPolygon_size (const QPolygon *m)
|
|
{
|
|
return m->size();
|
|
}
|
|
|
|
static void f_QPolygon_clear (QPolygon *m)
|
|
{
|
|
return m->clear();
|
|
}
|
|
|
|
static void f_QPolygon_remove (QPolygon *m, int i)
|
|
{
|
|
return m->remove (i);
|
|
}
|
|
|
|
static void f_QPolygon_insert (QPolygon *m, int i, const QPoint &p)
|
|
{
|
|
return m->insert (i, p);
|
|
}
|
|
|
|
static void f_QPolygon_replace (QPolygon *m, int i, const QPoint &p)
|
|
{
|
|
return m->replace (i, p);
|
|
}
|
|
|
|
static void f_QPolygon_pop_front (QPolygon *m)
|
|
{
|
|
return m->pop_front ();
|
|
}
|
|
|
|
static void f_QPolygon_pop_back (QPolygon *m)
|
|
{
|
|
return m->pop_back ();
|
|
}
|
|
|
|
static void f_QPolygon_push_front (QPolygon *m, const QPoint &p)
|
|
{
|
|
return m->push_front (p);
|
|
}
|
|
|
|
static void f_QPolygon_push_back (QPolygon *m, const QPoint &p)
|
|
{
|
|
return m->push_back (p);
|
|
}
|
|
|
|
static void f_QPolygon_reserve (QPolygon *m, int n)
|
|
{
|
|
return m->reserve (n);
|
|
}
|
|
|
|
static void f_QPolygon_resize (QPolygon *m, int n)
|
|
{
|
|
return m->resize (n);
|
|
}
|
|
|
|
static void f_QPolygon_fill (QPolygon *m, const QPoint &p, int n)
|
|
{
|
|
m->fill (p, n);
|
|
}
|
|
CODE
|
|
gsi::constructor("new", &ctor_QPolygon_from_polygon, "@brief Creates a polygon from the given KLayout Polygon\n@args p\nRemark: holes are not transferred into the QPolygon.") +
|
|
gsi::constructor("new", &ctor_QPolygon_from_simple_polygon, "@brief Creates a polygon from the given KLayout SimplePolygon\n@args p") +
|
|
gsi::iterator_ext ("each", &f_QPolygon_each_begin, &f_QPolygon_each_end, "@brief Iterates over all points of the polygon.") +
|
|
gsi::method_ext("[]", &f_QPolygon_at, "@brief Gets the point at the given position\n@args index") +
|
|
gsi::method_ext("front", &f_QPolygon_front, "@brief Gets the first point") +
|
|
gsi::method_ext("back", &f_QPolygon_back, "@brief Gets the last point") +
|
|
gsi::method_ext("size", &f_QPolygon_size, "@brief Gets the number of points in the polygon") +
|
|
gsi::method_ext("clear", &f_QPolygon_clear, "@brief Empties the polygon") +
|
|
gsi::method_ext("remove", &f_QPolygon_remove, "@brief Removes the point at the given position\n@args index") +
|
|
gsi::method_ext("insert", &f_QPolygon_insert, "@brief Inserts the point after the given position\n@args index, p") +
|
|
gsi::method_ext("replace", &f_QPolygon_replace, "@brief Replaces the point at the given position\n@args index, p") +
|
|
gsi::method_ext("pop_front", &f_QPolygon_pop_front, "@brief Removes the point at the beginning of the list") +
|
|
gsi::method_ext("pop_back", &f_QPolygon_pop_back, "@brief Removes the point at the end of the list") +
|
|
gsi::method_ext("push_front", &f_QPolygon_push_front, "@brief Inserts the point at the beginning of the list\n@args p") +
|
|
gsi::method_ext("push_back", &f_QPolygon_push_back, "@brief Inserts the point at the end of the list\n@args p") +
|
|
gsi::method_ext("reserve", &f_QPolygon_reserve, "@brief Reserve memory for the given number of points\n@args n") +
|
|
gsi::method_ext("resize", &f_QPolygon_resize, "@brief Sets the number of points to the given length\n@args l") +
|
|
gsi::method_ext("fill", &f_QPolygon_fill, "@brief Resizes the polygon to l points and ets all elements to the given point\n@args p,l")
|
|
DECL
|
|
|
|
# enhance QPolygonF by some missing methods because we dropped the base class
|
|
add_native_impl("QPolygonF", <<'CODE', <<'DECL')
|
|
|
|
#include "dbPolygon.h"
|
|
|
|
static QPolygonF *ctor_QPolygonF_from_polygon (const db::DPolygon &pts)
|
|
{
|
|
QPolygonF *p = new QPolygonF ();
|
|
p->reserve (int (pts.hull ().size ()));
|
|
for (db::DPolygon::polygon_contour_iterator q = pts.begin_hull (); q != pts.end_hull (); ++q) {
|
|
p->push_back (QPointF ((*q).x (), (*q).y ()));
|
|
}
|
|
return p;
|
|
}
|
|
|
|
static QPolygonF *ctor_QPolygonF_from_simple_polygon (const db::DSimplePolygon &pts)
|
|
{
|
|
QPolygonF *p = new QPolygonF ();
|
|
p->reserve (int (pts.hull ().size ()));
|
|
for (db::DSimplePolygon::polygon_contour_iterator q = pts.begin_hull (); q != pts.end_hull (); ++q) {
|
|
p->push_back (QPointF ((*q).x (), (*q).y ()));
|
|
}
|
|
return p;
|
|
}
|
|
|
|
static QPolygonF::const_iterator f_QPolygonF_each_begin (const QPolygonF *m)
|
|
{
|
|
return m->begin ();
|
|
}
|
|
|
|
static QPolygonF::const_iterator f_QPolygonF_each_end (const QPolygonF *m)
|
|
{
|
|
return m->end ();
|
|
}
|
|
|
|
static QPointF f_QPolygonF_at (const QPolygonF *m, int i)
|
|
{
|
|
return m->at(i);
|
|
}
|
|
|
|
static QPointF f_QPolygonF_front (const QPolygonF *m)
|
|
{
|
|
return m->front();
|
|
}
|
|
|
|
static QPointF f_QPolygonF_back (const QPolygonF *m)
|
|
{
|
|
return m->back();
|
|
}
|
|
|
|
static int f_QPolygonF_size (const QPolygonF *m)
|
|
{
|
|
return m->size();
|
|
}
|
|
|
|
static void f_QPolygonF_clear (QPolygonF *m)
|
|
{
|
|
return m->clear();
|
|
}
|
|
|
|
static void f_QPolygonF_remove (QPolygonF *m, int i)
|
|
{
|
|
return m->remove (i);
|
|
}
|
|
|
|
static void f_QPolygonF_insert (QPolygonF *m, int i, const QPointF &p)
|
|
{
|
|
return m->insert (i, p);
|
|
}
|
|
|
|
static void f_QPolygonF_replace (QPolygonF *m, int i, const QPointF &p)
|
|
{
|
|
return m->replace (i, p);
|
|
}
|
|
|
|
static void f_QPolygonF_pop_front (QPolygonF *m)
|
|
{
|
|
return m->pop_front ();
|
|
}
|
|
|
|
static void f_QPolygonF_pop_back (QPolygonF *m)
|
|
{
|
|
return m->pop_back ();
|
|
}
|
|
|
|
static void f_QPolygonF_push_front (QPolygonF *m, const QPointF &p)
|
|
{
|
|
return m->push_front (p);
|
|
}
|
|
|
|
static void f_QPolygonF_push_back (QPolygonF *m, const QPointF &p)
|
|
{
|
|
return m->push_back (p);
|
|
}
|
|
|
|
static void f_QPolygonF_reserve (QPolygonF *m, int n)
|
|
{
|
|
return m->reserve (n);
|
|
}
|
|
|
|
static void f_QPolygonF_resize (QPolygonF *m, int n)
|
|
{
|
|
return m->resize (n);
|
|
}
|
|
|
|
static void f_QPolygonF_fill (QPolygonF *m, const QPointF &p, int n)
|
|
{
|
|
m->fill (p, n);
|
|
}
|
|
CODE
|
|
gsi::constructor("new", &ctor_QPolygonF_from_polygon, "@brief Creates a polygon from the given KLayout DPolygon\n@args p\nRemark: holes are not transferred into the QPolygonF.") +
|
|
gsi::constructor("new", &ctor_QPolygonF_from_simple_polygon, "@brief Creates a polygon from the given KLayout DSimplePolygon\n@args p") +
|
|
gsi::iterator_ext ("each", &f_QPolygonF_each_begin, &f_QPolygonF_each_end, "@brief Iterates over all points of the polygon.") +
|
|
gsi::method_ext("[]", &f_QPolygonF_at, "@brief Gets the point at the given position\n@args index") +
|
|
gsi::method_ext("front", &f_QPolygonF_front, "@brief Gets the first point") +
|
|
gsi::method_ext("back", &f_QPolygonF_back, "@brief Gets the last point") +
|
|
gsi::method_ext("size", &f_QPolygonF_size, "@brief Gets the number of points in the polygon") +
|
|
gsi::method_ext("clear", &f_QPolygonF_clear, "@brief Empties the polygon") +
|
|
gsi::method_ext("remove", &f_QPolygonF_remove, "@brief Removes the point at the given position\n@args index") +
|
|
gsi::method_ext("insert", &f_QPolygonF_insert, "@brief Inserts the point after the given position\n@args index, p") +
|
|
gsi::method_ext("replace", &f_QPolygonF_replace, "@brief Replaces the point at the given position\n@args index, p") +
|
|
gsi::method_ext("pop_front", &f_QPolygonF_pop_front, "@brief Removes the point at the beginning of the list") +
|
|
gsi::method_ext("pop_back", &f_QPolygonF_pop_back, "@brief Removes the point at the end of the list") +
|
|
gsi::method_ext("push_front", &f_QPolygonF_push_front, "@brief Inserts the point at the beginning of the list\n@args p") +
|
|
gsi::method_ext("push_back", &f_QPolygonF_push_back, "@brief Inserts the point at the end of the list\n@args p") +
|
|
gsi::method_ext("reserve", &f_QPolygonF_reserve, "@brief Reserve memory for the given number of points\n@args n") +
|
|
gsi::method_ext("resize", &f_QPolygonF_resize, "@brief Sets the number of points to the given length\n@args l") +
|
|
gsi::method_ext("fill", &f_QPolygonF_fill, "@brief Resizes the polygon to l points and ets all elements to the given point\n@args p,l")
|
|
DECL
|
|
|
|
# --------------------------------------------------------------
|
|
# QtGui
|
|
|
|
drop_class "QAccessible2"
|
|
drop_class "QAccessibleBridgePlugin"
|
|
drop_class "QAccessibleBridge" # QAccessibleBridge not supported on Windows:
|
|
drop_class "QAccessibleInterfaceEx"
|
|
drop_class "QAccessibleObjectEx"
|
|
drop_class "QAccessiblePlugin" # difficult because of strange inheritance (through a intermediate struct) and probably never needed:
|
|
drop_class "QAccessibleWidgetEx"
|
|
drop_class "QBrushData"
|
|
drop_class "QCopChannel"
|
|
drop_class "QCustomRasterPaintDevice"
|
|
drop_class "QDecoration"
|
|
drop_class "QDecorationDefault"
|
|
drop_class "QDecorationFactory"
|
|
drop_class "QDecorationPlugin"
|
|
drop_class "QDirectPainter"
|
|
drop_class "QDrawBorderPixmap"
|
|
drop_class "QDrawPixmaps"
|
|
drop_class "QFontEngineInfo"
|
|
drop_class "QFontEnginePlugin"
|
|
drop_class "QGenericMatrix"
|
|
drop_class "QGtkStyle" # not available on WIN
|
|
drop_class "QIconEngineFactoryInterface"
|
|
drop_class "QIconEngineFactoryInterfaceV2"
|
|
drop_class "QIconEngineV2", /AvailableSizesArgument/
|
|
drop_class "QImageIOHandlerFactoryInterface"
|
|
drop_class "QInputContextFactoryInterface"
|
|
drop_class "QItemEditorCreator" # is a template
|
|
drop_class "QKbdDriverFactory"
|
|
drop_class "QKbdDriverPlugin"
|
|
drop_class "QKeyEventTransition"
|
|
drop_class "QMacCocoaViewContainer"
|
|
drop_class "QMacNativeWidget"
|
|
drop_class "QMacPasteboardMime"
|
|
drop_class "QMacStyle"
|
|
drop_class "QMdi"
|
|
drop_class "QMouseDriverFactory"
|
|
drop_class "QMouseDriverPlugin"
|
|
drop_class "QMouseEventTransition"
|
|
drop_class "QPainterPathPrivate"
|
|
drop_class "QPictureIO"
|
|
drop_class "QPixmapCache", /Key/
|
|
drop_class "QProxyScreen"
|
|
drop_class "QProxyScreenCursor"
|
|
drop_class "QProxyStyle"
|
|
drop_class "QRasterPaintEngine"
|
|
drop_class "QScreen"
|
|
drop_class "QScreenCursor"
|
|
drop_class "QScreenDriverFactory"
|
|
drop_class "QScreenDriverPlugin"
|
|
drop_class "QSessionManager" # Not available always:
|
|
drop_class "QStandardItemEditorCreator" # is a template
|
|
drop_class "QStyleFactoryInterface"
|
|
drop_class "QStyleOptionDockWidgetV2"
|
|
drop_class "QStyleOptionTabWidgetFrameV2"
|
|
drop_class "QSymbianEvent"
|
|
drop_class "QTextFrameLayoutData"
|
|
drop_class "QTileRules"
|
|
drop_class "QWidgetData"
|
|
drop_class "QWidgetItemV2"
|
|
drop_class "QWindowsVistaStyle" # not available on Unix?
|
|
drop_class "QWindowsXPStyle" # not available on Unix?
|
|
drop_class "QWSCalibratedMouseHandler"
|
|
drop_class "QWSClient"
|
|
drop_class "QWSEmbedWidget"
|
|
drop_class "QWSEvent"
|
|
drop_class "QWSInputMethod"
|
|
drop_class "QWSKeyboardHandler"
|
|
drop_class "QWSMouseHandler"
|
|
drop_class "QWSPointerCalibrationData"
|
|
drop_class "QWSScreenSaver"
|
|
drop_class "QWSServer"
|
|
drop_class "QWSWindow"
|
|
|
|
rename :all_classes, /::create\(/, "qt_create" # clashes with GSI/Ruby
|
|
rename :all_classes, /::destroy\(/, "qt_destroy" # clashes with GSI/Ruby
|
|
rename :all_classes, /::raise\(/, "qt_raise" # clashes with Ruby "raise" keyword
|
|
|
|
# depedencies from operators are not derived automatically currently:
|
|
include "QPoint", [ "<QPoint>", "<QMatrix>", "<QMatrix4x4>" ]
|
|
include "QPointF", [ "<QPointF>", "<QMatrix>", "<QMatrix4x4>" ]
|
|
include "QVector3D", [ "<QVector3D>", "<QVector2D>", "<QMatrix4x4>" ]
|
|
include "QVector4D", [ "<QVector4D>", "<QVector2D>", "<QMatrix4x4>" ]
|
|
include "QAction", [ "<QAction>", "<QGraphicsWidget>", "<QMenu>" ]
|
|
include "QCursor", [ "<QCursor>", "<QScreen>", "<QBitmap>" ]
|
|
include "QGraphicsItem", [ "<QGraphicsItem>", "<QGraphicsTransform>", "<QGraphicsScene>", "<QStyleOptionGraphicsItem>", "<QGraphicsEffect>", "<QGraphicsWidget>", "<QGraphicsSceneContextMenuEvent>", "<QGraphicsSceneDragDropEvent>", "<QGraphicsSceneHoverEvent>", "<QGraphicsSceneMouseEvent>", "<QGraphicsSceneWheelEvent>", "<QPainter>" ]
|
|
include "QGraphicsScene", [ "<QGraphicsScene>", "<QGraphicsView>", "<QGraphicsItem>", "<QGraphicsWidget>", "<QGraphicsEllipseItem>", "<QGraphicsLineItem>", "<QGraphicsPathItem>", "<QGraphicsPixmapItem>", "<QGraphicsPolygonItem>", "<QGraphicsRectItem>", "<QGraphicsSimpleTextItem>", "<QGraphicsTextItem>", "<QGraphicsProxyWidget>", "<QGraphicsItemGroup>", "<QStyle>", "<QGraphicsSceneContextMenuEvent>", "<QGraphicsSceneDragDropEvent>", "<QGraphicsSceneHelpEvent>", "<QGraphicsSceneMouseEvent>", "<QGraphicsSceneWheelEvent>" ]
|
|
include "QGuiApplication", [ "<QGuiApplication>", "<QScreen>", "<QSessionManager>", "<QClipboard>", "<QWindow>", "<QStyleHints>" ]
|
|
include "QApplication", [ "<QApplication>", "<QSessionManager>", "<QDesktopWidget>", "<QStyle>", "<QScreen>", "<QLocale>", "<QClipboard>", "<QInputContext>" ]
|
|
include "QTextStream", [ "<QTextStream>", "<QIODevice>", "<QLocale>", "<QTextCodec>", "<QDomNode>", "<QSplitter>" ]
|
|
include "QWindow", [ "<QWindow>", "<QScreen>" ]
|
|
include "QOffscreenSurface", [ "<QOffscreenSurface>", "<QScreen>" ]
|
|
include "QScreenOrientationChangeEvent", [ "<QScreenOrientationChangeEvent>", "<QScreen>" ]
|
|
|
|
drop_method :all_classes, /::devType\(/ # not required
|
|
drop_method "QAbstractPageSetupDialog", /QAbstractPageSetupDialog::QAbstractPageSetupDialog\(QAbstractPageSetupDialogPrivate/
|
|
drop_method "QClipboardEvent", /QClipboardEvent::data/
|
|
drop_method "QClipboardEvent", /QClipboardEvent::QClipboardEvent\(QEventPrivate/
|
|
drop_method "QCursor", /QCursor::QCursor\s*\(\s*Qt::HANDLE/ # not available on WIN
|
|
drop_method "QApplication", /QApplication::compressEvent/ # QPostEventList is missing
|
|
drop_method "QWidget", /QWidget::painters/ # whatever that is, it's not a method ..
|
|
drop_method "QWidget", /QWidget::handle/ # not available on WIN
|
|
drop_method "QPixmap", /QPixmap::handle/ # not available on WIN
|
|
drop_method "QPixmap", /QPixmap::fromX11Pixmap/ # not available on WIN
|
|
drop_method "QTabletEvent", /QTabletEvent::QTabletEvent/ # TODO: too many arguments
|
|
drop_method "QGraphicsProxyWidget", /QGraphicsProxyWidget::setGeometry\(double/ # not available as override (private or protected inheritance?)
|
|
drop_method :all_classes, /::x11/ # no X11 stuff
|
|
drop_method "QPixmap", /QPixmap::QPixmap\(const\s+char\s+\*\s*const\s*\w*\s*\[\s*\]/ # no const char *[] - TODO: provide differen implementation?
|
|
drop_method "QImage", /QImage::QImage\(const\s+char\s+\*\s*const\s*xpm\s*\[\s*\]/ # no const char *[] - TODO: provide differen implementation?
|
|
drop_method "QImage", /QImage::QImage\(const\s+char\s+\*\s*fileName/ # not available for QT_NO_CAST_TO_ASCII
|
|
drop_method "QAccessibleInterface", /QAccessibleInterface::imageInterface/ # Interface is not officially available
|
|
drop_method "QAccessibleInterface", /QAccessibleInterface::actionInterface/ # Interface is not officially available
|
|
drop_method "QAccessible", /QAccessible::installFactory/ # requires function ptr
|
|
drop_method "QAccessible", /QAccessible::removeFactory/ # requires function ptr
|
|
drop_method "QAccessible", /QAccessible::installRootObjectHandler/ # requires function ptr
|
|
drop_method "QAccessible", /QAccessible::installUpdateHandler/ # requires function ptr
|
|
drop_method "QPixmapCache", /QPixmapCache::find\s*\(\s*const\s+QPixmapCache::Key/ # requires Key subclass
|
|
drop_method "QPixmapCache", /QPixmapCache::insert\s*\(\s*const\s+QPixmap\s+\&pixmap\s*\)/ # requires Key subclass
|
|
drop_method "QPixmapCache", /QPixmapCache::remove\s*\(\s*const\s+QPixmapCache::Key/ # requires Key subclass
|
|
drop_method "QPixmapCache", /QPixmapCache::replace\s*\(\s*const\s+QPixmapCache::Key/ # requires Key subclass
|
|
drop_method "QGraphicsItem", /QGraphicsItem::isBlockedByModalPanel/ # requires QGraphicsItem **
|
|
drop_method "QGraphicsEffect", /QGraphicsEffect::source\s*\(\s*\)/ # requires QGraphicsEffectSource, not an official method
|
|
drop_method "QGraphicsScene", /QGraphicsScene::drawItems/ # requires QGraphicsItem *[], TODO: provide an alternative!
|
|
drop_method "QGraphicsView", /QGraphicsView::drawItems/ # requires QGraphicsItem *[], TODO: provide an alternative!
|
|
# drop_method "QGtkStyle", /QGtkStyle::QGtkStyle\s*\(\s*QGtkStylePrivate/ # requires QGtkStylePrivate
|
|
drop_method :all_classes, /::data_ptr/ # no private data
|
|
drop_method "QTextList", /QTextList::setFormat\(const\s+QTextFormat\s+/ # got mixed in somehow(?). Not part of API
|
|
drop_method "QTextTable", /QTextTable::setFormat\(const\s+QTextFormat\s+/ # got mixed in somehow(?). Not part of API
|
|
drop_method "QTextTableCell", /QTextTableCell::begin/ # requires template type return value (TODO: provide alternative?)
|
|
drop_method "QTextTableCell", /QTextTableCell::end/ # requires template type return value
|
|
drop_method "QRegion", /QRegion::handle/ # requires XRegion
|
|
drop_method "QFont", /QFont::freetypeFace/ # required FT_FACE struct
|
|
def_alias "QFont", /toString\(/, "to_s"
|
|
drop_method "QPixmap", /QPixmap::QPixmap\(QPixmapData/ # QPixmapData not available
|
|
drop_method "QPixmap", /QPixmap::pixmapData/ # QPixmapData not available
|
|
drop_method "QImage", /^\s*unsigned\s+char\s+\*\s*QImage::bits/ # TODO: requires non-const char *
|
|
drop_method "QImage", /^\s*unsigned\s+char\s+\*\s*QImage::scanLine/ # TODO: requires non-const char *
|
|
drop_method "QImage", /QImage::QImage\(unsigned\s+char\s+\*data/ # TODO: requires non-const char *
|
|
drop_method "QImage", /QImage::text\(const\s+QString/ # clashes with const char *version
|
|
drop_method "QTextDocument", /QTextDocument::appendUndoItem/ # requires QAbstractUndoItem which is not available
|
|
drop_method "QAccessibleInterface", /QAccessibleInterface::editableTextInterface/ # requires QAccessibleEditableTextInterface which is not available
|
|
drop_method "QAccessibleInterface", /QAccessibleInterface::tableInterface/ # requires QAccessibleTableInterface which is not available
|
|
drop_method "QAccessibleInterface", /QAccessibleInterface::textInterface/ # requires QAccessibleTextInterface which is not available
|
|
drop_method "QAccessibleInterface", /QAccessibleInterface::valueInterface/ # requires QAccessibleValueInterface which is not available
|
|
drop_method "QAccessibleObject", /QAccessibleObject::navigate/ # requires QAccessibleInterface **
|
|
drop_method "QAccessibleWidget", /QAccessibleWidget::navigate/ # requires QAccessibleInterface **
|
|
drop_method "QAccessibleInterface", /QAccessibleInterface::navigate/ # requires QAccessibleInterface **
|
|
drop_method "QAccessibleApplication", /QAccessibleApplication::navigate/ # requires QAccessibleInterface **
|
|
drop_method "QTextCursor", /QTextCursor::QTextCursor\(QTextCursorPrivate/ # Private data not available
|
|
drop_method "QTextCursor", /QTextCursor::QTextCursor\(QTextCursorPrivate/ # Private data not available
|
|
drop_method "QTextBlock", /QTextBlock::QTextBlock\(QTextDocumentPrivate/ # Private data not available
|
|
drop_method "QTextBlock", /QTextBlock::docHandle/ # Private data not available
|
|
drop_method "QTextCursor", /QTextCursor::QTextCursor\(QTextDocumentPrivate/ # Private data not available
|
|
drop_method "QTextDocument", /QTextDocument::docHandle/ # Private data not available
|
|
drop_method "QTextObject", /QTextObject::docHandle/ # Private data not available
|
|
drop_method "QTextFragment", /QTextFragment::QTextFragment\(const\s+QTextDocumentPrivate/ # Private data not available
|
|
drop_method "QTextInlineObject", /QTextInlineObject::QTextInlineObject\(int.*QTextEngine/ # QTextEngine not available
|
|
drop_method "QTextLayout", /QTextLayout::engine/ # QTextEngine not available
|
|
drop_method "QTextFrame", /QTextFrame::layoutData/ # QTextFrameLayoutData not available
|
|
drop_method "QTextFrame", /QTextFrame::begin/ # iterator not available
|
|
drop_method "QTextFrame", /QTextFrame::end/ # iterator not available
|
|
drop_method "QTextFrame", /QTextFrame::setLayoutData/ # QTextFrameLayoutData not available
|
|
drop_method "QWidget", /QWidget::windowSurface/ # QWindowSurface not available
|
|
drop_method "QWidget", /QWidget::setWindowSurface/ # QWindowSurface not available
|
|
drop_method "QFont", /QFont::resolve\s*\(\s*unsigned\s+int/ # internal? Messes up the generation (non-const?)
|
|
drop_method "QFont", /QFont::resolve\s*\(\s*\)/ # internal? Messes up the generation (non-const?)
|
|
drop_method "QPalette", /QPalette::resolve\s*\(\s*unsigned\s+int/ # internal? Messes up the generation (non-const?)
|
|
drop_method "QPalette", /QPalette::resolve\s*\(\s*\)/ # internal? Messes up the generation (non-const?)
|
|
drop_method "QMessageBox", /QMessageBox::warning.*int\s+\w+\s*,\s*int\s+\w+\s*\)/ # obsolete
|
|
drop_method "QMessageBox", /QMessageBox::question.*int\s+\w+\s*,\s*int\s+\w+\s*\)/ # obsolete
|
|
drop_method "QMessageBox", /QMessageBox::information.*int\s+\w+\s*,\s*int\s+\w+\s*\)/ # obsolete
|
|
drop_method "QMessageBox", /QMessageBox::critical.*int\s+\w+\s*,\s*int\s+\w+\s*\)/ # obsolete
|
|
drop_method "QMessageBox", /QMessageBox::standardIcon/ # obsolete
|
|
drop_method "QMessageBox", /QMessageBox::warning.*QMessageBox::StandardButton\s+\w+,\s*QMessageBox::StandardButton\s+\w+\s*\)/ # clashes with enum version
|
|
drop_method "QMessageBox", /QMessageBox::question.*QMessageBox::StandardButton\s+\w+,\s*QMessageBox::StandardButton\s+\w+\s*\)/ # clashes with enum version
|
|
drop_method "QMessageBox", /QMessageBox::critical.*QMessageBox::StandardButton\s+\w+,\s*QMessageBox::StandardButton\s+\w+\s*\)/ # clashes with enum version
|
|
drop_method "QMessageBox", /QMessageBox::information.*QMessageBox::StandardButton\s+\w+,\s*QMessageBox::StandardButton\s+\w+\s*\)/ # clashes with enum version
|
|
drop_method "QTreeWidgetItem", /::QTreeWidgetItem\(const\s+QTreeWidgetItem\s*&/ # will hide the parent-constructor otherwise. Use dup/copy protocol instead.
|
|
|
|
drop_method "QPainter", /QPainter::drawRects.*QRect\s+\*/ # requires pointers, alternative available
|
|
drop_method "QPainter", /QPainter::drawRects.*QRectF\s+\*/ # requires pointers, alternative available
|
|
drop_method "QPainter", /QPainter::drawConvexPolygon.*QPoint\s+\*/ # requires pointers, alternative available
|
|
drop_method "QPainter", /QPainter::drawConvexPolygon.*QPointF\s+\*/ # requires pointers, alternative available
|
|
drop_method "QPainter", /QPainter::drawPoints.*QPoint\s+\*/ # requires pointers, alternative available
|
|
drop_method "QPainter", /QPainter::drawPoints.*QPointF\s+\*/ # requires pointers, alternative available
|
|
drop_method "QPainter", /QPainter::drawPolygon.*QPoint\s+\*/ # requires pointers, alternative available
|
|
drop_method "QPainter", /QPainter::drawPolygon.*QPointF\s+\*/ # requires pointers, alternative available
|
|
drop_method "QPainter", /QPainter::drawPolyline.*QPoint\s+\*/ # requires pointers, alternative available
|
|
drop_method "QPainter", /QPainter::drawPolyline.*QPointF\s+\*/ # requires pointers, alternative available
|
|
drop_method "QPaintEngine", /QPaintEngine::drawRects.*QRect\s+\*/ # requires pointers, alternative available
|
|
drop_method "QPaintEngine", /QPaintEngine::drawRects.*QRectF\s+\*/ # requires pointers, alternative available
|
|
drop_method "QPaintEngine", /QPaintEngine::drawLines.*QLine\s+\*/ # requires pointers, alternative available
|
|
drop_method "QPaintEngine", /QPaintEngine::drawLines.*QLineF\s+\*/ # requires pointers, alternative available
|
|
drop_method "QPaintEngine", /QPaintEngine::drawPoints.*QPoint\s+\*/ # requires pointers, alternative available
|
|
drop_method "QPaintEngine", /QPaintEngine::drawPoints.*QPointF\s+\*/ # requires pointers, alternative available
|
|
drop_method "QPaintEngine", /QPaintEngine::drawPolygon.*QPoint\s+\*/ # requires pointers, alternative available
|
|
drop_method "QPaintEngine", /QPaintEngine::drawPolygon.*QPointF\s+\*/ # requires pointers, alternative available
|
|
drop_method "QPaintEngine", /QPaintEngine::fix_neg_rect/ # ??
|
|
rename "QPainter", /QPainter::drawRects.*QVector<QRect>/, "drawRects_i"
|
|
rename "QPainter", /QPainter::drawRects.*QVector<QRectF>/, "drawRects_f"
|
|
drop_method "QPainter", /QPainter::drawLines.*QLine\s+\*/
|
|
drop_method "QPainter", /QPainter::drawLines.*QLineF\s+\*/
|
|
drop_method "QPainter", /QPainter::drawLines.*QPoint\s+\*/
|
|
drop_method "QPainter", /QPainter::drawLines.*QPointF\s+\*/
|
|
rename "QPainter", /QPainter::drawLines.*QVector<QPoint>/, "drawLines_ip"
|
|
rename "QPainter", /QPainter::drawLines.*QVector<QPointF>/, "drawLines_fp"
|
|
rename "QPainter", /QPainter::drawLines.*QVector<QLine>/, "drawLines_i"
|
|
rename "QPainter", /QPainter::drawLines.*QVector<QLineF>/, "drawLines_f"
|
|
drop_method "QColor", /QColor::QColor\(const\s+QString/ # clashes with const char * version
|
|
drop_method "QColor", /QColor::allowX11ColorNames/ # not available in WIN
|
|
drop_method "QColor", /QColor::setAllowX11ColorNames/ # not available in WIN
|
|
drop_method "Qimage", /Qimage::text\(const\s+QString/ # clashes with const char * version
|
|
rename "QDialogButtonBox", /QDialogButtonBox::QDialogButtonBox\(QFlags/, "new_buttons"
|
|
rename "QIcon", /QIcon::pixmap\(int\s+extent/, "pixmap_ext"
|
|
rename "QKeySequence", /QKeySequence::QKeySequence\(QKeySequence::StandardKey/, "new_std"
|
|
keep_arg "QCoreApplication", /::postEvent/, 1 # will take ownership of event
|
|
keep_arg "QBoxLayout", /::addLayout/, 0 # will take ownership of layout
|
|
keep_arg "QGridLayout", /::addLayout/, 0 # will take ownership of layout
|
|
keep_arg "QLayout", /::addChildLayout/, 0 # will take ownership of layout
|
|
keep_arg "QLayout", /::addItem/, 0 # will take ownership of item
|
|
keep_arg "QTreeWidgetItem", /::addChild\(/, 0 # will take ownership of the child
|
|
keep_arg "QTreeWidgetItem", /::addChildren\(/, 0 # will take ownership of the children
|
|
keep_arg "QTreeWidgetItem", /::insertChild\(/, 1 # will take ownership of the child
|
|
keep_arg "QTreeWidgetItem", /::insertChildren\(/, 1 # will take ownership of the children
|
|
keep_arg "QGraphicsScene", /::addItem\(/, 0 # will take ownership of the children
|
|
keep_arg "QListWidget", /::addItem\(QListWidgetItem/, 0 # will take ownership of the child
|
|
keep_arg "QListWidget", /::insertItem\(int.*QListWidgetItem/, 1 # will take ownership of the child
|
|
keep_arg "QTreeWidget", /::addTopLevelItem\(/, 0 # will take ownership of the child
|
|
keep_arg "QTreeWidget", /::addTopLevelItems\(/, 0 # will take ownership of the child
|
|
keep_arg "QTreeWidget", /::insertTopLevelItem\(/, 1 # will take ownership of the child
|
|
keep_arg "QTreeWidget", /::insertTopLevelItems\(/, 1 # will take ownership of the child
|
|
keep_arg "QTableWidget", /::setItem\(/, 2 # will take ownership of the child
|
|
keep_arg "QGraphicsItemGroup", /::addToGroup\(/, 0 # will take ownership of the child
|
|
keep_arg "QGraphicsScene", /::addItem\(/, 0 # will take ownership of the item
|
|
# constructors with "owner" arguments:
|
|
# (NOTE: QObject and QGraphicsItem is handled per specific base-class implementation)
|
|
owner_arg "QTreeWidgetItem", /::QTreeWidgetItem\(QTreeWidgetItem\s+\*/, 0 # will construct a new object owned by arg #0
|
|
owner_arg "QTreeWidgetItem", /::QTreeWidgetItem\(QTreeWidget\s+\*/, 0 # will construct a new object owned by arg #0
|
|
owner_arg "QListWidgetItem", /::QListWidgetItem\(QListWidget\s+\*/, 0 # will construct a new object owned by arg #0
|
|
# this would make sense, but the pointer is const: so how can setItemPrototype take
|
|
# over ownership of it?
|
|
# keep_arg "QTableWidget", /::setItemPrototype\(/, 0 # will take ownership of the child
|
|
return_new "QLayout", /::takeAt/ # returns a free object
|
|
return_new "QBoxLayout", /::takeAt/ # returns a free object
|
|
return_new "QFormLayout", /::takeAt/ # returns a free object
|
|
return_new "QGridLayout", /::takeAt/ # returns a free object
|
|
return_new "QStackedLayout", /::takeAt/ # returns a free object
|
|
return_new "QStandardItem", /::take/ # returns a free object
|
|
return_new "QStandardItemModel", /::take/ # returns a free object
|
|
return_new "QTreeWidgetItem", /::take/ # returns a free object
|
|
return_new "QTableWidget", /::take/ # returns a free object
|
|
return_new "QTreeWidget", /::take/ # returns a free object
|
|
return_new "QListWidget", /::take/ # returns a free object
|
|
return_new "QScrollArea", /::takeWidget\(/ # returns a free object
|
|
|
|
rename "QPrintDialog", /QPrintDialog::accepted\(QPrinter/, "accepted_sig"
|
|
|
|
# special implementations:
|
|
|
|
drop_method "QApplication", /QApplication::QApplication/ # geht nicht wegen char** und wird auch nicht gebraucht wegen singleton
|
|
|
|
# provide a dummy application for the constructor for test purposes
|
|
add_native_impl("QApplication", <<'CODE', <<'DECL')
|
|
static QApplication *ctor_QApplication()
|
|
{
|
|
static char *(dummy_argv[]) = { (char *)"undefined_application" };
|
|
int argc = 1;
|
|
return new QApplication (argc, dummy_argv);
|
|
}
|
|
CODE
|
|
gsi::constructor("new_app", &ctor_QApplication, "@brief Creates a new QApplication object\n\nThis implementation is provided for test purposes only. It is not required usually to create a QApplication object. Use the object provided by QApplication::instance instead.")
|
|
DECL
|
|
|
|
no_imports "QItemSelection" # base class is a template. TODO: provide a solution (i.e. additional manual declarations)
|
|
no_imports "QPageSetupDialog" # base class is a QAbstractPageSetupDialog which is not readily available
|
|
# QAccessibleBridge not supported on Windows
|
|
# no_imports "QAccessibleBridgePlugin","QAccessibleBridgeFactoryInterface" # base class is a QAbstractPageSetupDialog which is not readily available
|
|
# no_imports "QAccessiblePlugin","QAccessibleFactoryInterface" # base class is a QAbstractPageSetupDialog which is not readily available
|
|
no_imports "QIconEnginePlugin","QIconEngineFactoryInterface" # base class is not readily available
|
|
no_imports "QIconEnginePluginV2","QIconEngineFactoryInterfaceV2" # base class is not readily available
|
|
no_imports "QImageIOPlugin","QImageIOHandlerFactoryInterface" # base class is not readily available
|
|
no_imports "QInputContextPlugin","QInputContextFactoryInterface" # base class is not readily available
|
|
no_imports "QStylePlugin","QStyleFactoryInterface" # base class is not readily available
|
|
|
|
final_class "QAccessible" # because navigate cannot be implemented
|
|
# QAccessibleBridge not supported on Windows
|
|
# final_class "QAccessibleBridge" # because navigate cannot be implemented
|
|
# final_class "QAccessibleBridgePlugin" # because navigate cannot be implemented
|
|
final_class "QAccessibleEvent" # because navigate cannot be implemented
|
|
final_class "QAccessibleInterface" # because navigate cannot be implemented
|
|
final_class "QAccessibleObject" # because navigate cannot be implemented
|
|
# Strange inheritance (through a intermediate struct) and probably never needed:
|
|
# final_class "QAccessiblePlugin" # because navigate cannot be implemented
|
|
final_class "QAccessibleWidget" # because navigate cannot be implemented
|
|
|
|
# --------------------------------------------------------------
|
|
# QtXml
|
|
drop_method "QXmlAttributes", /QXmlAttributes::value\(\s*const\s+QLatin1String/ # QLatin1String not available
|
|
drop_method "QXmlAttributes", /QXmlAttributes::index\(\s*const\s+QLatin1String/ # QLatin1String not available
|
|
drop_method "QXmlInputSource", /QXmlInputSource::setData\(.*QByteArray/ # clashes with QString version
|
|
drop_method "QXmlEntityResolver", /QXmlEntityResolver::resolveEntity/ # requires pointer return value
|
|
drop_method "QXmlDefaultHandler", /QXmlDefaultHandler::resolveEntity/ # requires pointer return value
|
|
rename "QDomElement", /QDomElement::setAttribute\(.*qulonglong/, "setAttribute_ull|attribute_ull="
|
|
rename "QDomElement", /QDomElement::setAttribute\(.*qlonglong/, "setAttribute_ll|attribute_ll="
|
|
rename "QDomElement", /QDomElement::setAttribute\(.*unsigned int/, "setAttribute_ui|attribute_ui="
|
|
rename "QDomElement", /QDomElement::setAttribute\(.*int value/, "setAttribute_i|attribute_i="
|
|
rename "QDomElement", /QDomElement::setAttribute\(.*double value/, "setAttribute_d|attribute_d="
|
|
rename "QDomElement", /QDomElement::setAttribute\(.*float value/, "setAttribute_f|attribute_f="
|
|
rename "QDomElement", /QDomElement::setAttributeNS\(.*qulonglong/, "setAttributeNS_ull|attributeNS_ull="
|
|
rename "QDomElement", /QDomElement::setAttributeNS\(.*qlonglong/, "setAttributeNS_ll|attributeNS_ll="
|
|
rename "QDomElement", /QDomElement::setAttributeNS\(.*unsigned int/, "setAttributeNS_ui|attributeNS_ui="
|
|
rename "QDomElement", /QDomElement::setAttributeNS\(.*int value/, "setAttributeNS_i|attributeNS_i="
|
|
rename "QDomElement", /QDomElement::setAttributeNS\(.*double value/, "setAttributeNS_d|attributeNS_d="
|
|
rename "QDomElement", /QDomElement::setAttributeNS\(.*float value/, "setAttributeNS_f|attributeNS_f="
|
|
drop_method "QDomDocument", /QDomDocument::setContent\(const\s+QByteArray/ # clashes with QString version
|
|
|
|
# --------------------------------------------------------------
|
|
# QtNetwork
|
|
|
|
drop_method "QUrlInfo", /QUrlInfo::QUrlInfo\(.*permissions/ # too many arguments (13)
|
|
drop_method "QHostAddress", /QHostAddress::QHostAddress\(\s*quint8\s*\*/ # requires char *, a string version is available for IPv6
|
|
drop_method "QHostAddress", /QHostAddress::QHostAddress\(\s*const\s+QIPv6Address/ # requires QIPv6Address struct, a string version is available for IPv6
|
|
drop_method "QHostAddress", /QHostAddress::QHostAddress\(\s*const\s+sockaddr/ # requires sockaddr struct, a string version is available for IPv6
|
|
drop_method "QHostAddress", /QHostAddress::setAddress\(\s*quint8\s*\*/ # requires char *, a string version is available for IPv6
|
|
drop_method "QHostAddress", /QHostAddress::setAddress\(\s*const\s+QIPv6Address/ # requires QIPv6Address struct, a string version is available for IPv6
|
|
drop_method "QHostAddress", /QHostAddress::setAddress\(\s*const\s+sockaddr/ # requires sockaddr struct, a string version is available for IPv6
|
|
drop_method "QHostAddress", /QHostAddress::toIPv6Address\(/ # requires QIPv6Address struct
|
|
def_alias "QHostAddress", /toString\(/, "to_s"
|
|
drop_method "QNetworkCacheMetaData", /QNetworkCacheMetaData::attributes/ # requires Hash
|
|
drop_method "QNetworkCacheMetaData", /QNetworkCacheMetaData::setAttributes/ # requires Hash
|
|
drop_method "QSslCertificate", /QSslCertificate::alternateSubjectNames/ # requires MultiMap
|
|
drop_method "QFtp", /QFtp::read\(/ # requires char * - readAll may be an alternative. TODO: implement a real alternative!
|
|
drop_method "QUdpSocket", /QUdpSocket::readDatagram/ # requires "char *" - TODO: provide an alternative, because otherwise there is none!
|
|
|
|
rename "QHostAddress", /::QHostAddress\(quint/, "new_ip4" # disambiguator
|
|
rename "QHostAddress", /::QHostAddress\(QHostAddress::SpecialAddress/, "new_special" # disambiguator
|
|
rename "QLocalSocket", /::error\(QLocalSocket::LocalSocketError/, "error_sig" # disambiguator
|
|
rename "QNetworkReply", /::error\(QNetworkReply::NetworkError/, "error_sig" # disambiguator
|
|
rename "QAbstractSocket", /::error\(QAbstractSocket::SocketError/, "error_sig" # disambiguator
|
|
rename "QSslSocket", /::sslErrors\(const\s+QList/, "sslErrors_sig" # disambiguator
|
|
|
|
final_class "QAbstractSocket" # because readData cannot be reimplemented
|
|
final_class "QTcpSocket" # because readData cannot be reimplemented
|
|
final_class "QUdpSocket" # because readData cannot be reimplemented
|
|
final_class "QLocalSocket" # because readData cannot be reimplemented
|
|
final_class "QNetworkReply" # because readData cannot be reimplemented
|
|
final_class "QSslSocket" # because readData cannot be reimplemented
|
|
|
|
# --------------------------------------------------------------
|
|
# QtSql
|
|
|
|
include "QSql", [ "<QtSql>" ]
|
|
|
|
drop_class "QSqlDriverCreator" # is a template
|
|
drop_class "QSqlDriverPlugin" # not required ?
|
|
|
|
# --------------------------------------------------------------
|
|
# QtDesigner
|
|
|
|
drop_method "QFormBuilder", /QFormBuilder::customWidgets\(\s*\)/ # Requires QDesignerCustomWidgetInterface which is not (yet) available
|
|
|
|
no_copy_ctor "QAbstractFormBuilder"
|
|
no_copy_ctor "QFormBuilder"
|
|
|
|
final_class "QAbstractFormBuilder" # requires a lot of Dom* classes
|
|
final_class "QFormBuilder" # requires a lot of Dom* classes
|
|
|
|
# --------------------------------------------------------------
|
|
|
|
no_default_ctor "QDirIterator"
|
|
no_default_ctor "QUnixPrintWidget"
|
|
no_default_ctor "QToolBarChangeEvent"
|
|
no_default_ctor "QClipboardEvent"
|
|
no_default_ctor "QDragResponseEvent"
|
|
no_default_ctor "QAbstractPageSetupDialog"
|
|
no_default_ctor "QSqlResult"
|
|
no_default_ctor "QCryptographicHash"
|
|
no_default_ctor "QAbstractPrintDialog"
|
|
no_default_ctor "QSyntaxHighlighter"
|
|
no_default_ctor "QAbstractTextDocumentLayout"
|
|
no_default_ctor "QAccessibleEvent"
|
|
no_default_ctor "QAccessibleWidget"
|
|
no_default_ctor "QTouchEvent"
|
|
no_default_ctor "QAction"
|
|
no_default_ctor "QActionEvent"
|
|
no_default_ctor "QActionGroup"
|
|
no_default_ctor "QApplication"
|
|
no_default_ctor "QBoxLayout"
|
|
no_default_ctor "QClipboard"
|
|
no_default_ctor "QContextMenuEvent"
|
|
no_default_ctor "QDoubleValidator"
|
|
no_default_ctor "QDrag"
|
|
no_default_ctor "QDragEnterEvent"
|
|
no_default_ctor "QDragMoveEvent"
|
|
no_default_ctor "QDropEvent"
|
|
no_default_ctor "QFileOpenEvent"
|
|
no_default_ctor "QFocusEvent"
|
|
no_default_ctor "QFontInfo"
|
|
no_default_ctor "QFontMetrics"
|
|
no_default_ctor "QFontMetricsF"
|
|
no_default_ctor "QGraphicsSceneEvent"
|
|
no_default_ctor "QGestureEvent"
|
|
no_default_ctor "QGraphicsAnchor"
|
|
no_default_ctor "QHeaderView"
|
|
no_default_ctor "QHelpEvent"
|
|
no_default_ctor "QHoverEvent"
|
|
no_default_ctor "QInputEvent"
|
|
no_default_ctor "QItemSelectionModel"
|
|
no_default_ctor "QKeyEvent"
|
|
no_default_ctor "QMouseEvent"
|
|
no_default_ctor "QMoveEvent"
|
|
no_default_ctor "QPaintEvent"
|
|
no_default_ctor "QPlainTextDocumentLayout"
|
|
no_default_ctor "QRegExpValidator"
|
|
no_default_ctor "QResizeEvent"
|
|
no_default_ctor "QRubberBand"
|
|
no_default_ctor "QSessionManager"
|
|
no_default_ctor "QShortcut"
|
|
no_default_ctor "QShortcutEvent"
|
|
no_default_ctor "QSizeGrip"
|
|
no_default_ctor "QSound"
|
|
no_default_ctor "QSpacerItem"
|
|
no_default_ctor "QSplitterHandle"
|
|
no_default_ctor "QStatusTipEvent"
|
|
no_default_ctor "QTabletEvent"
|
|
no_default_ctor "QTextBlockGroup"
|
|
no_default_ctor "QTextFrame"
|
|
no_default_ctor "QTextList"
|
|
no_default_ctor "QTextObject"
|
|
no_default_ctor "QTextTable"
|
|
no_default_ctor "QTreeWidgetItemIterator"
|
|
no_default_ctor "QWhatsThisClickedEvent"
|
|
no_default_ctor "QWheelEvent"
|
|
no_default_ctor "QWidgetAction"
|
|
no_default_ctor "QWidgetItem"
|
|
no_default_ctor "QWindowStateChangeEvent"
|
|
no_default_ctor "QChildEvent"
|
|
no_default_ctor "QCoreApplication"
|
|
no_default_ctor "QDynamicPropertyChangeEvent"
|
|
no_default_ctor "QEvent"
|
|
no_default_ctor "QReadLocker"
|
|
no_default_ctor "QSocketNotifier"
|
|
no_default_ctor "QTimerEvent"
|
|
no_default_ctor "QWriteLocker"
|
|
no_default_ctor "QTextDecoder"
|
|
no_default_ctor "QTextEncoder"
|
|
no_default_ctor "QColormap"
|
|
no_default_ctor "QToolTip"
|
|
no_default_ctor "QWhatsThis"
|
|
no_default_ctor "QLibraryInfo"
|
|
no_default_ctor "QAbstractSocket"
|
|
no_default_ctor "QInputMethodEvent::Attribute"
|
|
|
|
no_copy_ctor "QGraphicsLayoutItem"
|
|
no_copy_ctor "QCDEStyle"
|
|
no_copy_ctor "QMotifStyle"
|
|
no_copy_ctor "QWindowsStyle"
|
|
no_copy_ctor "QCleanlooksStyle"
|
|
# no_copy_ctor "QGtkStyle"
|
|
no_copy_ctor "QDateTimeEdit"
|
|
no_copy_ctor "QDateEdit"
|
|
no_copy_ctor "QLayout"
|
|
no_copy_ctor "QDialog"
|
|
no_copy_ctor "QAbstractPageSetupDialog"
|
|
no_copy_ctor "QAbstractTextDocumentLayout"
|
|
no_copy_ctor "QPageSetupDialog"
|
|
no_copy_ctor "QPainterPathStroker"
|
|
no_copy_ctor "QGraphicsSceneContextMenuEvent"
|
|
no_copy_ctor "QGraphicsSceneDragDropEvent"
|
|
no_copy_ctor "QGraphicsSceneHelpEvent"
|
|
no_copy_ctor "QGraphicsSceneHoverEvent"
|
|
no_copy_ctor "QGraphicsSceneMouseEvent"
|
|
no_copy_ctor "QGraphicsSceneMoveEvent"
|
|
no_copy_ctor "QGraphicsSceneResizeEvent"
|
|
no_copy_ctor "QGraphicsSceneWheelEvent"
|
|
no_copy_ctor "QGraphicsSceneEvent"
|
|
no_copy_ctor "QPlainTextDocumentLayout"
|
|
no_copy_ctor "QPrintDialog"
|
|
no_copy_ctor "QPrintPreviewDialog"
|
|
no_copy_ctor "QPrintPreviewWidget"
|
|
no_copy_ctor "QStandardItem"
|
|
no_copy_ctor "QTimeEdit"
|
|
no_copy_ctor "QEventLoop"
|
|
no_copy_ctor "QFileSystemWatcher"
|
|
no_copy_ctor "QResource"
|
|
no_copy_ctor "QThread"
|
|
no_copy_ctor "QRubberBand"
|
|
no_copy_ctor "QSound"
|
|
no_copy_ctor "QCoreApplication"
|
|
no_copy_ctor "QLayout"
|
|
no_copy_ctor "QSessionManager"
|
|
no_copy_ctor "QShortcut"
|
|
no_copy_ctor "QFormLayout"
|
|
no_copy_ctor "QXmlParseException"
|
|
no_copy_ctor "QNetworkAccessManager"
|
|
|
|
# --------------------------------------------------------------
|
|
# events and properties
|
|
# NOTE: to generate these files use scripts/mkqtdecl/mkqtdecl_extract_props.rb
|
|
# and scripts/mkqtdecl/mkqtdecl_extract_signals.rb
|
|
|
|
load "mkqtdecl.events"
|
|
load "mkqtdecl.properties"
|
|
|