Updated Qt declaration files for MSVC

scripts/mkqtdecl_common/produce.rb

@@ -1784,6 +1784,9 @@ END
       m.find { |bd| bd.virtual && bd.type.init == "0" } != nil
     end
 
+    # gets the operator= if there is one
+    eq_op = (all_methods_by_name["operator="] || [])[0]
+
     # collect used enums in order to generate forward converter declarations
     # ("used" implies argument types and defined enums)
     used_ed = {}
@@ -2306,8 +2309,27 @@ END
     end
 
     if !is_child_class
+
+      # forward decl
+      @ext_decls << "#{struct.kind.to_s} #{cls};\n\n"
+
+      # type traits included ...
+      tt = "namespace tl { template <> struct type_traits<#{cls}> : public type_traits<void> {\n"
+      if !conf.has_copy_ctor?(cls) || is_abstract || (eq_op && eq_op.visibility == :private)
+        tt += "  typedef tl::false_tag has_copy_constructor;\n"
+      end
+      if !conf.has_default_ctor?(cls) || is_abstract
+        tt += "  typedef tl::false_tag has_default_constructor;\n"
+      end
+      if (dtor = struct.get_dtor) && dtor.visibility != :public
+        tt += "  typedef tl::false_tag has_public_destructor;\n"
+      end
+      tt += "}; }\n\n"
+      @ext_decls << tt
+
       # only for top-level classes external declarations are produced currently
-      @ext_decls << "#{struct.kind.to_s} #{cls};\nnamespace gsi { GSI_#{modn.upcase}_PUBLIC gsi::Class<#{cls}> &qtdecl_#{clsn} (); }\n\n"
+      @ext_decls << "namespace gsi { GSI_#{modn.upcase}_PUBLIC gsi::Class<#{cls}> &qtdecl_#{clsn} (); }\n\n"
+
     end
 
     ofile.puts("")
@@ -3170,6 +3192,7 @@ l.each_with_index do |decl_obj,i|
 end
 
 puts("Producing ..")
+
 if cls_list
   cls_list.split(",").each do |cs|
     bp.produce_cpp(conf, cs)

src/gsiqt/qt4/QtCore/gsiQtExternals.h

@@ -34,222 +34,569 @@
 #include "gsiQtCoreCommon.h"
 
 class QAbstractItemModel;
+
+namespace tl { template <> struct type_traits<QAbstractItemModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QAbstractItemModel> &qtdecl_QAbstractItemModel (); }
 
 class QAbstractListModel;
+
+namespace tl { template <> struct type_traits<QAbstractListModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QAbstractListModel> &qtdecl_QAbstractListModel (); }
 
 class QAbstractTableModel;
+
+namespace tl { template <> struct type_traits<QAbstractTableModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QAbstractTableModel> &qtdecl_QAbstractTableModel (); }
 
 class QBasicTimer;
+
+namespace tl { template <> struct type_traits<QBasicTimer> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QBasicTimer> &qtdecl_QBasicTimer (); }
 
 class QBuffer;
+
+namespace tl { template <> struct type_traits<QBuffer> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QBuffer> &qtdecl_QBuffer (); }
 
 class QByteArrayMatcher;
+
+namespace tl { template <> struct type_traits<QByteArrayMatcher> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QByteArrayMatcher> &qtdecl_QByteArrayMatcher (); }
 
 class QChildEvent;
+
+namespace tl { template <> struct type_traits<QChildEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QChildEvent> &qtdecl_QChildEvent (); }
 
 class QCoreApplication;
+
+namespace tl { template <> struct type_traits<QCoreApplication> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QCoreApplication> &qtdecl_QCoreApplication (); }
 
 class QCryptographicHash;
+
+namespace tl { template <> struct type_traits<QCryptographicHash> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QCryptographicHash> &qtdecl_QCryptographicHash (); }
 
 class QDataStream;
+
+namespace tl { template <> struct type_traits<QDataStream> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QDataStream> &qtdecl_QDataStream (); }
 
 class QDate;
+
+namespace tl { template <> struct type_traits<QDate> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QDate> &qtdecl_QDate (); }
 
 class QDateTime;
+
+namespace tl { template <> struct type_traits<QDateTime> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QDateTime> &qtdecl_QDateTime (); }
 
 class QDir;
+
+namespace tl { template <> struct type_traits<QDir> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QDir> &qtdecl_QDir (); }
 
 class QDynamicPropertyChangeEvent;
+
+namespace tl { template <> struct type_traits<QDynamicPropertyChangeEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QDynamicPropertyChangeEvent> &qtdecl_QDynamicPropertyChangeEvent (); }
 
 class QEasingCurve;
+
+namespace tl { template <> struct type_traits<QEasingCurve> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QEasingCurve> &qtdecl_QEasingCurve (); }
 
 class QEvent;
+
+namespace tl { template <> struct type_traits<QEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QEvent> &qtdecl_QEvent (); }
 
 class QEventLoop;
+
+namespace tl { template <> struct type_traits<QEventLoop> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QEventLoop> &qtdecl_QEventLoop (); }
 
 struct QFactoryInterface;
+
+namespace tl { template <> struct type_traits<QFactoryInterface> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QFactoryInterface> &qtdecl_QFactoryInterface (); }
 
 class QFile;
+
+namespace tl { template <> struct type_traits<QFile> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QFile> &qtdecl_QFile (); }
 
 class QFileInfo;
+
+namespace tl { template <> struct type_traits<QFileInfo> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QFileInfo> &qtdecl_QFileInfo (); }
 
 class QFileSystemWatcher;
+
+namespace tl { template <> struct type_traits<QFileSystemWatcher> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QFileSystemWatcher> &qtdecl_QFileSystemWatcher (); }
 
 class QIODevice;
+
+namespace tl { template <> struct type_traits<QIODevice> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QIODevice> &qtdecl_QIODevice (); }
 
 class QLibrary;
+
+namespace tl { template <> struct type_traits<QLibrary> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QLibrary> &qtdecl_QLibrary (); }
 
 class QLibraryInfo;
+
+namespace tl { template <> struct type_traits<QLibraryInfo> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QLibraryInfo> &qtdecl_QLibraryInfo (); }
 
 class QLine;
+
+namespace tl { template <> struct type_traits<QLine> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QLine> &qtdecl_QLine (); }
 
 class QLineF;
+
+namespace tl { template <> struct type_traits<QLineF> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QLineF> &qtdecl_QLineF (); }
 
 class QLocale;
+
+namespace tl { template <> struct type_traits<QLocale> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QLocale> &qtdecl_QLocale (); }
 
 class QMargins;
+
+namespace tl { template <> struct type_traits<QMargins> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QMargins> &qtdecl_QMargins (); }
 
 class QMetaClassInfo;
+
+namespace tl { template <> struct type_traits<QMetaClassInfo> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QMetaClassInfo> &qtdecl_QMetaClassInfo (); }
 
 class QMetaEnum;
+
+namespace tl { template <> struct type_traits<QMetaEnum> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QMetaEnum> &qtdecl_QMetaEnum (); }
 
 class QMetaMethod;
+
+namespace tl { template <> struct type_traits<QMetaMethod> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QMetaMethod> &qtdecl_QMetaMethod (); }
 
 struct QMetaObject;
+
+namespace tl { template <> struct type_traits<QMetaObject> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QMetaObject> &qtdecl_QMetaObject (); }
 
 class QMetaProperty;
+
+namespace tl { template <> struct type_traits<QMetaProperty> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QMetaProperty> &qtdecl_QMetaProperty (); }
 
 class QMetaType;
+
+namespace tl { template <> struct type_traits<QMetaType> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QMetaType> &qtdecl_QMetaType (); }
 
 class QMimeData;
+
+namespace tl { template <> struct type_traits<QMimeData> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QMimeData> &qtdecl_QMimeData (); }
 
 class QModelIndex;
+
+namespace tl { template <> struct type_traits<QModelIndex> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QModelIndex> &qtdecl_QModelIndex (); }
 
 class QMutex;
+
+namespace tl { template <> struct type_traits<QMutex> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QMutex> &qtdecl_QMutex (); }
 
 class QObject;
+
+namespace tl { template <> struct type_traits<QObject> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QObject> &qtdecl_QObject (); }
 
 class QPersistentModelIndex;
+
+namespace tl { template <> struct type_traits<QPersistentModelIndex> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QPersistentModelIndex> &qtdecl_QPersistentModelIndex (); }
 
 class QPluginLoader;
+
+namespace tl { template <> struct type_traits<QPluginLoader> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QPluginLoader> &qtdecl_QPluginLoader (); }
 
 class QPoint;
+
+namespace tl { template <> struct type_traits<QPoint> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QPoint> &qtdecl_QPoint (); }
 
 class QPointF;
+
+namespace tl { template <> struct type_traits<QPointF> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QPointF> &qtdecl_QPointF (); }
 
 class QProcess;
+
+namespace tl { template <> struct type_traits<QProcess> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QProcess> &qtdecl_QProcess (); }
 
 class QProcessEnvironment;
+
+namespace tl { template <> struct type_traits<QProcessEnvironment> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QProcessEnvironment> &qtdecl_QProcessEnvironment (); }
 
 class QReadLocker;
+
+namespace tl { template <> struct type_traits<QReadLocker> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QReadLocker> &qtdecl_QReadLocker (); }
 
 class QReadWriteLock;
+
+namespace tl { template <> struct type_traits<QReadWriteLock> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QReadWriteLock> &qtdecl_QReadWriteLock (); }
 
 class QRect;
+
+namespace tl { template <> struct type_traits<QRect> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QRect> &qtdecl_QRect (); }
 
 class QRectF;
+
+namespace tl { template <> struct type_traits<QRectF> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QRectF> &qtdecl_QRectF (); }
 
 class QRegExp;
+
+namespace tl { template <> struct type_traits<QRegExp> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QRegExp> &qtdecl_QRegExp (); }
 
 class QResource;
+
+namespace tl { template <> struct type_traits<QResource> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QResource> &qtdecl_QResource (); }
 
 class QSemaphore;
+
+namespace tl { template <> struct type_traits<QSemaphore> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QSemaphore> &qtdecl_QSemaphore (); }
 
 class QSettings;
+
+namespace tl { template <> struct type_traits<QSettings> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QSettings> &qtdecl_QSettings (); }
 
 class QSignalMapper;
+
+namespace tl { template <> struct type_traits<QSignalMapper> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QSignalMapper> &qtdecl_QSignalMapper (); }
 
 class QSize;
+
+namespace tl { template <> struct type_traits<QSize> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QSize> &qtdecl_QSize (); }
 
 class QSizeF;
+
+namespace tl { template <> struct type_traits<QSizeF> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QSizeF> &qtdecl_QSizeF (); }
 
 class QSocketNotifier;
+
+namespace tl { template <> struct type_traits<QSocketNotifier> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QSocketNotifier> &qtdecl_QSocketNotifier (); }
 
 class QStringMatcher;
+
+namespace tl { template <> struct type_traits<QStringMatcher> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QStringMatcher> &qtdecl_QStringMatcher (); }
 
 class QSysInfo;
+
+namespace tl { template <> struct type_traits<QSysInfo> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QSysInfo> &qtdecl_QSysInfo (); }
 
 class QSystemLocale;
+
+namespace tl { template <> struct type_traits<QSystemLocale> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QSystemLocale> &qtdecl_QSystemLocale (); }
 
 class QTemporaryFile;
+
+namespace tl { template <> struct type_traits<QTemporaryFile> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QTemporaryFile> &qtdecl_QTemporaryFile (); }
 
 class QTextCodec;
+
+namespace tl { template <> struct type_traits<QTextCodec> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+  typedef tl::false_tag has_public_destructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QTextCodec> &qtdecl_QTextCodec (); }
 
 class QTextDecoder;
+
+namespace tl { template <> struct type_traits<QTextDecoder> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QTextDecoder> &qtdecl_QTextDecoder (); }
 
 class QTextEncoder;
+
+namespace tl { template <> struct type_traits<QTextEncoder> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QTextEncoder> &qtdecl_QTextEncoder (); }
 
 class QTextStream;
+
+namespace tl { template <> struct type_traits<QTextStream> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QTextStream> &qtdecl_QTextStream (); }
 
 class QThread;
+
+namespace tl { template <> struct type_traits<QThread> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QThread> &qtdecl_QThread (); }
 
 class QTime;
+
+namespace tl { template <> struct type_traits<QTime> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QTime> &qtdecl_QTime (); }
 
 class QTimeLine;
+
+namespace tl { template <> struct type_traits<QTimeLine> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QTimeLine> &qtdecl_QTimeLine (); }
 
 class QTimer;
+
+namespace tl { template <> struct type_traits<QTimer> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QTimer> &qtdecl_QTimer (); }
 
 class QTimerEvent;
+
+namespace tl { template <> struct type_traits<QTimerEvent> : public type_traits<void> {
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QTimerEvent> &qtdecl_QTimerEvent (); }
 
 class QTranslator;
+
+namespace tl { template <> struct type_traits<QTranslator> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QTranslator> &qtdecl_QTranslator (); }
 
 class QUrl;
+
+namespace tl { template <> struct type_traits<QUrl> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QUrl> &qtdecl_QUrl (); }
 
 class QWaitCondition;
+
+namespace tl { template <> struct type_traits<QWaitCondition> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QWaitCondition> &qtdecl_QWaitCondition (); }
 
 class QWriteLocker;
+
+namespace tl { template <> struct type_traits<QWriteLocker> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTCORE_PUBLIC gsi::Class<QWriteLocker> &qtdecl_QWriteLocker (); }
 
 

src/gsiqt/qt4/QtDesigner/gsiQtExternals.h

@@ -34,9 +34,19 @@
 #include "gsiQtDesignerCommon.h"
 
 class QAbstractFormBuilder;
+
+namespace tl { template <> struct type_traits<QAbstractFormBuilder> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTDESIGNER_PUBLIC gsi::Class<QAbstractFormBuilder> &qtdecl_QAbstractFormBuilder (); }
 
 class QFormBuilder;
+
+namespace tl { template <> struct type_traits<QFormBuilder> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTDESIGNER_PUBLIC gsi::Class<QFormBuilder> &qtdecl_QFormBuilder (); }
 
 

src/gsiqt/qt4/QtNetwork/gsiQtExternals.h

@@ -34,96 +34,238 @@
 #include "gsiQtNetworkCommon.h"
 
 class QAbstractNetworkCache;
+
+namespace tl { template <> struct type_traits<QAbstractNetworkCache> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QAbstractNetworkCache> &qtdecl_QAbstractNetworkCache (); }
 
 class QAbstractSocket;
+
+namespace tl { template <> struct type_traits<QAbstractSocket> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QAbstractSocket> &qtdecl_QAbstractSocket (); }
 
 class QAuthenticator;
+
+namespace tl { template <> struct type_traits<QAuthenticator> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QAuthenticator> &qtdecl_QAuthenticator (); }
 
 class QFtp;
+
+namespace tl { template <> struct type_traits<QFtp> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QFtp> &qtdecl_QFtp (); }
 
 class QHostAddress;
+
+namespace tl { template <> struct type_traits<QHostAddress> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QHostAddress> &qtdecl_QHostAddress (); }
 
 class QHostInfo;
+
+namespace tl { template <> struct type_traits<QHostInfo> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QHostInfo> &qtdecl_QHostInfo (); }
 
 class QIPv6Address;
+
+namespace tl { template <> struct type_traits<QIPv6Address> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QIPv6Address> &qtdecl_QIPv6Address (); }
 
 class QLocalServer;
+
+namespace tl { template <> struct type_traits<QLocalServer> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QLocalServer> &qtdecl_QLocalServer (); }
 
 class QLocalSocket;
+
+namespace tl { template <> struct type_traits<QLocalSocket> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QLocalSocket> &qtdecl_QLocalSocket (); }
 
 class QNetworkAccessManager;
+
+namespace tl { template <> struct type_traits<QNetworkAccessManager> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkAccessManager> &qtdecl_QNetworkAccessManager (); }
 
 class QNetworkAddressEntry;
+
+namespace tl { template <> struct type_traits<QNetworkAddressEntry> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkAddressEntry> &qtdecl_QNetworkAddressEntry (); }
 
 class QNetworkCacheMetaData;
+
+namespace tl { template <> struct type_traits<QNetworkCacheMetaData> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkCacheMetaData> &qtdecl_QNetworkCacheMetaData (); }
 
 class QNetworkCookie;
+
+namespace tl { template <> struct type_traits<QNetworkCookie> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkCookie> &qtdecl_QNetworkCookie (); }
 
 class QNetworkCookieJar;
+
+namespace tl { template <> struct type_traits<QNetworkCookieJar> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkCookieJar> &qtdecl_QNetworkCookieJar (); }
 
 class QNetworkDiskCache;
+
+namespace tl { template <> struct type_traits<QNetworkDiskCache> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkDiskCache> &qtdecl_QNetworkDiskCache (); }
 
 class QNetworkInterface;
+
+namespace tl { template <> struct type_traits<QNetworkInterface> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkInterface> &qtdecl_QNetworkInterface (); }
 
 class QNetworkProxy;
+
+namespace tl { template <> struct type_traits<QNetworkProxy> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkProxy> &qtdecl_QNetworkProxy (); }
 
 class QNetworkProxyFactory;
+
+namespace tl { template <> struct type_traits<QNetworkProxyFactory> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkProxyFactory> &qtdecl_QNetworkProxyFactory (); }
 
 class QNetworkProxyQuery;
+
+namespace tl { template <> struct type_traits<QNetworkProxyQuery> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkProxyQuery> &qtdecl_QNetworkProxyQuery (); }
 
 class QNetworkReply;
+
+namespace tl { template <> struct type_traits<QNetworkReply> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkReply> &qtdecl_QNetworkReply (); }
 
 class QNetworkRequest;
+
+namespace tl { template <> struct type_traits<QNetworkRequest> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkRequest> &qtdecl_QNetworkRequest (); }
 
 class QSslCertificate;
+
+namespace tl { template <> struct type_traits<QSslCertificate> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QSslCertificate> &qtdecl_QSslCertificate (); }
 
 class QSslCipher;
+
+namespace tl { template <> struct type_traits<QSslCipher> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QSslCipher> &qtdecl_QSslCipher (); }
 
 class QSslConfiguration;
+
+namespace tl { template <> struct type_traits<QSslConfiguration> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QSslConfiguration> &qtdecl_QSslConfiguration (); }
 
 class QSslError;
+
+namespace tl { template <> struct type_traits<QSslError> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QSslError> &qtdecl_QSslError (); }
 
 class QSslKey;
+
+namespace tl { template <> struct type_traits<QSslKey> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QSslKey> &qtdecl_QSslKey (); }
 
 class QSslSocket;
+
+namespace tl { template <> struct type_traits<QSslSocket> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QSslSocket> &qtdecl_QSslSocket (); }
 
 class QTcpServer;
+
+namespace tl { template <> struct type_traits<QTcpServer> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QTcpServer> &qtdecl_QTcpServer (); }
 
 class QTcpSocket;
+
+namespace tl { template <> struct type_traits<QTcpSocket> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QTcpSocket> &qtdecl_QTcpSocket (); }
 
 class QUdpSocket;
+
+namespace tl { template <> struct type_traits<QUdpSocket> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QUdpSocket> &qtdecl_QUdpSocket (); }
 
 class QUrlInfo;
+
+namespace tl { template <> struct type_traits<QUrlInfo> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QUrlInfo> &qtdecl_QUrlInfo (); }
 
 

src/gsiqt/qt4/QtSql/gsiQtExternals.h

@@ -34,42 +34,103 @@
 #include "gsiQtSqlCommon.h"
 
 class QSqlDatabase;
+
+namespace tl { template <> struct type_traits<QSqlDatabase> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlDatabase> &qtdecl_QSqlDatabase (); }
 
 class QSqlDriver;
+
+namespace tl { template <> struct type_traits<QSqlDriver> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlDriver> &qtdecl_QSqlDriver (); }
 
 class QSqlDriverCreatorBase;
+
+namespace tl { template <> struct type_traits<QSqlDriverCreatorBase> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlDriverCreatorBase> &qtdecl_QSqlDriverCreatorBase (); }
 
 class QSqlError;
+
+namespace tl { template <> struct type_traits<QSqlError> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlError> &qtdecl_QSqlError (); }
 
 class QSqlField;
+
+namespace tl { template <> struct type_traits<QSqlField> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlField> &qtdecl_QSqlField (); }
 
 class QSqlIndex;
+
+namespace tl { template <> struct type_traits<QSqlIndex> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlIndex> &qtdecl_QSqlIndex (); }
 
 class QSqlQuery;
+
+namespace tl { template <> struct type_traits<QSqlQuery> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlQuery> &qtdecl_QSqlQuery (); }
 
 class QSqlQueryModel;
+
+namespace tl { template <> struct type_traits<QSqlQueryModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlQueryModel> &qtdecl_QSqlQueryModel (); }
 
 class QSqlRecord;
+
+namespace tl { template <> struct type_traits<QSqlRecord> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlRecord> &qtdecl_QSqlRecord (); }
 
 class QSqlRelation;
+
+namespace tl { template <> struct type_traits<QSqlRelation> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlRelation> &qtdecl_QSqlRelation (); }
 
 class QSqlRelationalTableModel;
+
+namespace tl { template <> struct type_traits<QSqlRelationalTableModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlRelationalTableModel> &qtdecl_QSqlRelationalTableModel (); }
 
 class QSqlResult;
+
+namespace tl { template <> struct type_traits<QSqlResult> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlResult> &qtdecl_QSqlResult (); }
 
 class QSqlTableModel;
+
+namespace tl { template <> struct type_traits<QSqlTableModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlTableModel> &qtdecl_QSqlTableModel (); }
 
 

src/gsiqt/qt4/QtXml/gsiQtExternals.h

@@ -34,96 +34,240 @@
 #include "gsiQtXmlCommon.h"
 
 class QDomAttr;
+
+namespace tl { template <> struct type_traits<QDomAttr> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomAttr> &qtdecl_QDomAttr (); }
 
 class QDomCDATASection;
+
+namespace tl { template <> struct type_traits<QDomCDATASection> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomCDATASection> &qtdecl_QDomCDATASection (); }
 
 class QDomCharacterData;
+
+namespace tl { template <> struct type_traits<QDomCharacterData> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomCharacterData> &qtdecl_QDomCharacterData (); }
 
 class QDomComment;
+
+namespace tl { template <> struct type_traits<QDomComment> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomComment> &qtdecl_QDomComment (); }
 
 class QDomDocument;
+
+namespace tl { template <> struct type_traits<QDomDocument> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomDocument> &qtdecl_QDomDocument (); }
 
 class QDomDocumentFragment;
+
+namespace tl { template <> struct type_traits<QDomDocumentFragment> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomDocumentFragment> &qtdecl_QDomDocumentFragment (); }
 
 class QDomDocumentType;
+
+namespace tl { template <> struct type_traits<QDomDocumentType> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomDocumentType> &qtdecl_QDomDocumentType (); }
 
 class QDomElement;
+
+namespace tl { template <> struct type_traits<QDomElement> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomElement> &qtdecl_QDomElement (); }
 
 class QDomEntity;
+
+namespace tl { template <> struct type_traits<QDomEntity> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomEntity> &qtdecl_QDomEntity (); }
 
 class QDomEntityReference;
+
+namespace tl { template <> struct type_traits<QDomEntityReference> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomEntityReference> &qtdecl_QDomEntityReference (); }
 
 class QDomImplementation;
+
+namespace tl { template <> struct type_traits<QDomImplementation> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomImplementation> &qtdecl_QDomImplementation (); }
 
 class QDomNamedNodeMap;
+
+namespace tl { template <> struct type_traits<QDomNamedNodeMap> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomNamedNodeMap> &qtdecl_QDomNamedNodeMap (); }
 
 class QDomNode;
+
+namespace tl { template <> struct type_traits<QDomNode> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomNode> &qtdecl_QDomNode (); }
 
 class QDomNodeList;
+
+namespace tl { template <> struct type_traits<QDomNodeList> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomNodeList> &qtdecl_QDomNodeList (); }
 
 class QDomNotation;
+
+namespace tl { template <> struct type_traits<QDomNotation> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomNotation> &qtdecl_QDomNotation (); }
 
 class QDomProcessingInstruction;
+
+namespace tl { template <> struct type_traits<QDomProcessingInstruction> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomProcessingInstruction> &qtdecl_QDomProcessingInstruction (); }
 
 class QDomText;
+
+namespace tl { template <> struct type_traits<QDomText> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomText> &qtdecl_QDomText (); }
 
 class QXmlAttributes;
+
+namespace tl { template <> struct type_traits<QXmlAttributes> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlAttributes> &qtdecl_QXmlAttributes (); }
 
 class QXmlContentHandler;
+
+namespace tl { template <> struct type_traits<QXmlContentHandler> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlContentHandler> &qtdecl_QXmlContentHandler (); }
 
 class QXmlDTDHandler;
+
+namespace tl { template <> struct type_traits<QXmlDTDHandler> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlDTDHandler> &qtdecl_QXmlDTDHandler (); }
 
 class QXmlDeclHandler;
+
+namespace tl { template <> struct type_traits<QXmlDeclHandler> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlDeclHandler> &qtdecl_QXmlDeclHandler (); }
 
 class QXmlDefaultHandler;
+
+namespace tl { template <> struct type_traits<QXmlDefaultHandler> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlDefaultHandler> &qtdecl_QXmlDefaultHandler (); }
 
 class QXmlEntityResolver;
+
+namespace tl { template <> struct type_traits<QXmlEntityResolver> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlEntityResolver> &qtdecl_QXmlEntityResolver (); }
 
 class QXmlErrorHandler;
+
+namespace tl { template <> struct type_traits<QXmlErrorHandler> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlErrorHandler> &qtdecl_QXmlErrorHandler (); }
 
 class QXmlInputSource;
+
+namespace tl { template <> struct type_traits<QXmlInputSource> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlInputSource> &qtdecl_QXmlInputSource (); }
 
 class QXmlLexicalHandler;
+
+namespace tl { template <> struct type_traits<QXmlLexicalHandler> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlLexicalHandler> &qtdecl_QXmlLexicalHandler (); }
 
 class QXmlLocator;
+
+namespace tl { template <> struct type_traits<QXmlLocator> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlLocator> &qtdecl_QXmlLocator (); }
 
 class QXmlNamespaceSupport;
+
+namespace tl { template <> struct type_traits<QXmlNamespaceSupport> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlNamespaceSupport> &qtdecl_QXmlNamespaceSupport (); }
 
 class QXmlParseException;
+
+namespace tl { template <> struct type_traits<QXmlParseException> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlParseException> &qtdecl_QXmlParseException (); }
 
 class QXmlReader;
+
+namespace tl { template <> struct type_traits<QXmlReader> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlReader> &qtdecl_QXmlReader (); }
 
 class QXmlSimpleReader;
+
+namespace tl { template <> struct type_traits<QXmlSimpleReader> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlSimpleReader> &qtdecl_QXmlSimpleReader (); }
 
 

src/gsiqt/qt5/QtDesigner/gsiQtExternals.h

@@ -34,15 +34,37 @@
 #include "gsiQtDesignerCommon.h"
 
 class QAbstractExtensionFactory;
+
+namespace tl { template <> struct type_traits<QAbstractExtensionFactory> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTDESIGNER_PUBLIC gsi::Class<QAbstractExtensionFactory> &qtdecl_QAbstractExtensionFactory (); }
 
 class QAbstractExtensionManager;
+
+namespace tl { template <> struct type_traits<QAbstractExtensionManager> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTDESIGNER_PUBLIC gsi::Class<QAbstractExtensionManager> &qtdecl_QAbstractExtensionManager (); }
 
 class QAbstractFormBuilder;
+
+namespace tl { template <> struct type_traits<QAbstractFormBuilder> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTDESIGNER_PUBLIC gsi::Class<QAbstractFormBuilder> &qtdecl_QAbstractFormBuilder (); }
 
 class QFormBuilder;
+
+namespace tl { template <> struct type_traits<QFormBuilder> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTDESIGNER_PUBLIC gsi::Class<QFormBuilder> &qtdecl_QFormBuilder (); }
 
 

src/gsiqt/qt5/QtMultimedia/gsiQtExternals.h

@@ -34,279 +34,789 @@
 #include "gsiQtMultimediaCommon.h"
 
 class QAbstractAudioDeviceInfo;
+
+namespace tl { template <> struct type_traits<QAbstractAudioDeviceInfo> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAbstractAudioDeviceInfo> &qtdecl_QAbstractAudioDeviceInfo (); }
 
 class QAbstractAudioInput;
+
+namespace tl { template <> struct type_traits<QAbstractAudioInput> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAbstractAudioInput> &qtdecl_QAbstractAudioInput (); }
 
 class QAbstractAudioOutput;
+
+namespace tl { template <> struct type_traits<QAbstractAudioOutput> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAbstractAudioOutput> &qtdecl_QAbstractAudioOutput (); }
 
 class QAbstractVideoBuffer;
+
+namespace tl { template <> struct type_traits<QAbstractVideoBuffer> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAbstractVideoBuffer> &qtdecl_QAbstractVideoBuffer (); }
 
 class QAbstractVideoFilter;
+
+namespace tl { template <> struct type_traits<QAbstractVideoFilter> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAbstractVideoFilter> &qtdecl_QAbstractVideoFilter (); }
 
 class QAbstractVideoSurface;
+
+namespace tl { template <> struct type_traits<QAbstractVideoSurface> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAbstractVideoSurface> &qtdecl_QAbstractVideoSurface (); }
 
 class QAudioBuffer;
+
+namespace tl { template <> struct type_traits<QAudioBuffer> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAudioBuffer> &qtdecl_QAudioBuffer (); }
 
 class QAudioDecoder;
+
+namespace tl { template <> struct type_traits<QAudioDecoder> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAudioDecoder> &qtdecl_QAudioDecoder (); }
 
 class QAudioDecoderControl;
+
+namespace tl { template <> struct type_traits<QAudioDecoderControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAudioDecoderControl> &qtdecl_QAudioDecoderControl (); }
 
 class QAudioDeviceInfo;
+
+namespace tl { template <> struct type_traits<QAudioDeviceInfo> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAudioDeviceInfo> &qtdecl_QAudioDeviceInfo (); }
 
 class QAudioEncoderSettings;
+
+namespace tl { template <> struct type_traits<QAudioEncoderSettings> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAudioEncoderSettings> &qtdecl_QAudioEncoderSettings (); }
 
 class QAudioEncoderSettingsControl;
+
+namespace tl { template <> struct type_traits<QAudioEncoderSettingsControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAudioEncoderSettingsControl> &qtdecl_QAudioEncoderSettingsControl (); }
 
 class QAudioFormat;
+
+namespace tl { template <> struct type_traits<QAudioFormat> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAudioFormat> &qtdecl_QAudioFormat (); }
 
 class QAudioInput;
+
+namespace tl { template <> struct type_traits<QAudioInput> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAudioInput> &qtdecl_QAudioInput (); }
 
 class QAudioInputSelectorControl;
+
+namespace tl { template <> struct type_traits<QAudioInputSelectorControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAudioInputSelectorControl> &qtdecl_QAudioInputSelectorControl (); }
 
 class QAudioOutput;
+
+namespace tl { template <> struct type_traits<QAudioOutput> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAudioOutput> &qtdecl_QAudioOutput (); }
 
 class QAudioOutputSelectorControl;
+
+namespace tl { template <> struct type_traits<QAudioOutputSelectorControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAudioOutputSelectorControl> &qtdecl_QAudioOutputSelectorControl (); }
 
 class QAudioProbe;
+
+namespace tl { template <> struct type_traits<QAudioProbe> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAudioProbe> &qtdecl_QAudioProbe (); }
 
 class QAudioRecorder;
+
+namespace tl { template <> struct type_traits<QAudioRecorder> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAudioRecorder> &qtdecl_QAudioRecorder (); }
 
 struct QAudioSystemFactoryInterface;
+
+namespace tl { template <> struct type_traits<QAudioSystemFactoryInterface> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAudioSystemFactoryInterface> &qtdecl_QAudioSystemFactoryInterface (); }
 
 class QAudioSystemPlugin;
+
+namespace tl { template <> struct type_traits<QAudioSystemPlugin> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QAudioSystemPlugin> &qtdecl_QAudioSystemPlugin (); }
 
 class QCamera;
+
+namespace tl { template <> struct type_traits<QCamera> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCamera> &qtdecl_QCamera (); }
 
 class QCameraCaptureBufferFormatControl;
+
+namespace tl { template <> struct type_traits<QCameraCaptureBufferFormatControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraCaptureBufferFormatControl> &qtdecl_QCameraCaptureBufferFormatControl (); }
 
 class QCameraCaptureDestinationControl;
+
+namespace tl { template <> struct type_traits<QCameraCaptureDestinationControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraCaptureDestinationControl> &qtdecl_QCameraCaptureDestinationControl (); }
 
 class QCameraControl;
+
+namespace tl { template <> struct type_traits<QCameraControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraControl> &qtdecl_QCameraControl (); }
 
 class QCameraExposure;
+
+namespace tl { template <> struct type_traits<QCameraExposure> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+  typedef tl::false_tag has_public_destructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraExposure> &qtdecl_QCameraExposure (); }
 
 class QCameraExposureControl;
+
+namespace tl { template <> struct type_traits<QCameraExposureControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraExposureControl> &qtdecl_QCameraExposureControl (); }
 
 class QCameraFeedbackControl;
+
+namespace tl { template <> struct type_traits<QCameraFeedbackControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraFeedbackControl> &qtdecl_QCameraFeedbackControl (); }
 
 class QCameraFlashControl;
+
+namespace tl { template <> struct type_traits<QCameraFlashControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraFlashControl> &qtdecl_QCameraFlashControl (); }
 
 class QCameraFocus;
+
+namespace tl { template <> struct type_traits<QCameraFocus> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+  typedef tl::false_tag has_public_destructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraFocus> &qtdecl_QCameraFocus (); }
 
 class QCameraFocusControl;
+
+namespace tl { template <> struct type_traits<QCameraFocusControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraFocusControl> &qtdecl_QCameraFocusControl (); }
 
 class QCameraFocusZone;
+
+namespace tl { template <> struct type_traits<QCameraFocusZone> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraFocusZone> &qtdecl_QCameraFocusZone (); }
 
 class QCameraImageCapture;
+
+namespace tl { template <> struct type_traits<QCameraImageCapture> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraImageCapture> &qtdecl_QCameraImageCapture (); }
 
 class QCameraImageCaptureControl;
+
+namespace tl { template <> struct type_traits<QCameraImageCaptureControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraImageCaptureControl> &qtdecl_QCameraImageCaptureControl (); }
 
 class QCameraImageProcessing;
+
+namespace tl { template <> struct type_traits<QCameraImageProcessing> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+  typedef tl::false_tag has_public_destructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraImageProcessing> &qtdecl_QCameraImageProcessing (); }
 
 class QCameraImageProcessingControl;
+
+namespace tl { template <> struct type_traits<QCameraImageProcessingControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraImageProcessingControl> &qtdecl_QCameraImageProcessingControl (); }
 
 class QCameraInfo;
+
+namespace tl { template <> struct type_traits<QCameraInfo> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraInfo> &qtdecl_QCameraInfo (); }
 
 class QCameraInfoControl;
+
+namespace tl { template <> struct type_traits<QCameraInfoControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraInfoControl> &qtdecl_QCameraInfoControl (); }
 
 class QCameraLocksControl;
+
+namespace tl { template <> struct type_traits<QCameraLocksControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraLocksControl> &qtdecl_QCameraLocksControl (); }
 
 class QCameraViewfinderSettings;
+
+namespace tl { template <> struct type_traits<QCameraViewfinderSettings> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraViewfinderSettings> &qtdecl_QCameraViewfinderSettings (); }
 
 class QCameraViewfinderSettingsControl;
+
+namespace tl { template <> struct type_traits<QCameraViewfinderSettingsControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraViewfinderSettingsControl> &qtdecl_QCameraViewfinderSettingsControl (); }
 
 class QCameraViewfinderSettingsControl2;
+
+namespace tl { template <> struct type_traits<QCameraViewfinderSettingsControl2> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraViewfinderSettingsControl2> &qtdecl_QCameraViewfinderSettingsControl2 (); }
 
 class QCameraZoomControl;
+
+namespace tl { template <> struct type_traits<QCameraZoomControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QCameraZoomControl> &qtdecl_QCameraZoomControl (); }
 
 class QGraphicsVideoItem;
+
+namespace tl { template <> struct type_traits<QGraphicsVideoItem> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QGraphicsVideoItem> &qtdecl_QGraphicsVideoItem (); }
 
 class QImageEncoderControl;
+
+namespace tl { template <> struct type_traits<QImageEncoderControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QImageEncoderControl> &qtdecl_QImageEncoderControl (); }
 
 class QImageEncoderSettings;
+
+namespace tl { template <> struct type_traits<QImageEncoderSettings> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QImageEncoderSettings> &qtdecl_QImageEncoderSettings (); }
 
 class QMediaAudioProbeControl;
+
+namespace tl { template <> struct type_traits<QMediaAudioProbeControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaAudioProbeControl> &qtdecl_QMediaAudioProbeControl (); }
 
 class QMediaAvailabilityControl;
+
+namespace tl { template <> struct type_traits<QMediaAvailabilityControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaAvailabilityControl> &qtdecl_QMediaAvailabilityControl (); }
 
 class QMediaBindableInterface;
+
+namespace tl { template <> struct type_traits<QMediaBindableInterface> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaBindableInterface> &qtdecl_QMediaBindableInterface (); }
 
 class QMediaContainerControl;
+
+namespace tl { template <> struct type_traits<QMediaContainerControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaContainerControl> &qtdecl_QMediaContainerControl (); }
 
 class QMediaContent;
+
+namespace tl { template <> struct type_traits<QMediaContent> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaContent> &qtdecl_QMediaContent (); }
 
 class QMediaControl;
+
+namespace tl { template <> struct type_traits<QMediaControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaControl> &qtdecl_QMediaControl (); }
 
 class QMediaGaplessPlaybackControl;
+
+namespace tl { template <> struct type_traits<QMediaGaplessPlaybackControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaGaplessPlaybackControl> &qtdecl_QMediaGaplessPlaybackControl (); }
 
 class QMediaNetworkAccessControl;
+
+namespace tl { template <> struct type_traits<QMediaNetworkAccessControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaNetworkAccessControl> &qtdecl_QMediaNetworkAccessControl (); }
 
 class QMediaObject;
+
+namespace tl { template <> struct type_traits<QMediaObject> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaObject> &qtdecl_QMediaObject (); }
 
 class QMediaPlayer;
+
+namespace tl { template <> struct type_traits<QMediaPlayer> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaPlayer> &qtdecl_QMediaPlayer (); }
 
 class QMediaPlayerControl;
+
+namespace tl { template <> struct type_traits<QMediaPlayerControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaPlayerControl> &qtdecl_QMediaPlayerControl (); }
 
 class QMediaPlaylist;
+
+namespace tl { template <> struct type_traits<QMediaPlaylist> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaPlaylist> &qtdecl_QMediaPlaylist (); }
 
 class QMediaRecorder;
+
+namespace tl { template <> struct type_traits<QMediaRecorder> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaRecorder> &qtdecl_QMediaRecorder (); }
 
 class QMediaRecorderControl;
+
+namespace tl { template <> struct type_traits<QMediaRecorderControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaRecorderControl> &qtdecl_QMediaRecorderControl (); }
 
 class QMediaResource;
+
+namespace tl { template <> struct type_traits<QMediaResource> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaResource> &qtdecl_QMediaResource (); }
 
 class QMediaService;
+
+namespace tl { template <> struct type_traits<QMediaService> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaService> &qtdecl_QMediaService (); }
 
 struct QMediaServiceCameraInfoInterface;
+
+namespace tl { template <> struct type_traits<QMediaServiceCameraInfoInterface> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaServiceCameraInfoInterface> &qtdecl_QMediaServiceCameraInfoInterface (); }
 
 struct QMediaServiceDefaultDeviceInterface;
+
+namespace tl { template <> struct type_traits<QMediaServiceDefaultDeviceInterface> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaServiceDefaultDeviceInterface> &qtdecl_QMediaServiceDefaultDeviceInterface (); }
 
 struct QMediaServiceFeaturesInterface;
+
+namespace tl { template <> struct type_traits<QMediaServiceFeaturesInterface> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaServiceFeaturesInterface> &qtdecl_QMediaServiceFeaturesInterface (); }
 
 struct QMediaServiceProviderFactoryInterface;
+
+namespace tl { template <> struct type_traits<QMediaServiceProviderFactoryInterface> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaServiceProviderFactoryInterface> &qtdecl_QMediaServiceProviderFactoryInterface (); }
 
 class QMediaServiceProviderHint;
+
+namespace tl { template <> struct type_traits<QMediaServiceProviderHint> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaServiceProviderHint> &qtdecl_QMediaServiceProviderHint (); }
 
 class QMediaServiceProviderPlugin;
+
+namespace tl { template <> struct type_traits<QMediaServiceProviderPlugin> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaServiceProviderPlugin> &qtdecl_QMediaServiceProviderPlugin (); }
 
 struct QMediaServiceSupportedDevicesInterface;
+
+namespace tl { template <> struct type_traits<QMediaServiceSupportedDevicesInterface> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaServiceSupportedDevicesInterface> &qtdecl_QMediaServiceSupportedDevicesInterface (); }
 
 struct QMediaServiceSupportedFormatsInterface;
+
+namespace tl { template <> struct type_traits<QMediaServiceSupportedFormatsInterface> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaServiceSupportedFormatsInterface> &qtdecl_QMediaServiceSupportedFormatsInterface (); }
 
 class QMediaStreamsControl;
+
+namespace tl { template <> struct type_traits<QMediaStreamsControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaStreamsControl> &qtdecl_QMediaStreamsControl (); }
 
 class QMediaTimeInterval;
+
+namespace tl { template <> struct type_traits<QMediaTimeInterval> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaTimeInterval> &qtdecl_QMediaTimeInterval (); }
 
 class QMediaTimeRange;
+
+namespace tl { template <> struct type_traits<QMediaTimeRange> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaTimeRange> &qtdecl_QMediaTimeRange (); }
 
 class QMediaVideoProbeControl;
+
+namespace tl { template <> struct type_traits<QMediaVideoProbeControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMediaVideoProbeControl> &qtdecl_QMediaVideoProbeControl (); }
 
 class QMetaDataReaderControl;
+
+namespace tl { template <> struct type_traits<QMetaDataReaderControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMetaDataReaderControl> &qtdecl_QMetaDataReaderControl (); }
 
 class QMetaDataWriterControl;
+
+namespace tl { template <> struct type_traits<QMetaDataWriterControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QMetaDataWriterControl> &qtdecl_QMetaDataWriterControl (); }
 
 class QRadioData;
+
+namespace tl { template <> struct type_traits<QRadioData> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QRadioData> &qtdecl_QRadioData (); }
 
 class QRadioDataControl;
+
+namespace tl { template <> struct type_traits<QRadioDataControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QRadioDataControl> &qtdecl_QRadioDataControl (); }
 
 class QRadioTuner;
+
+namespace tl { template <> struct type_traits<QRadioTuner> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QRadioTuner> &qtdecl_QRadioTuner (); }
 
 class QRadioTunerControl;
+
+namespace tl { template <> struct type_traits<QRadioTunerControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QRadioTunerControl> &qtdecl_QRadioTunerControl (); }
 
 class QSound;
+
+namespace tl { template <> struct type_traits<QSound> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QSound> &qtdecl_QSound (); }
 
 class QSoundEffect;
+
+namespace tl { template <> struct type_traits<QSoundEffect> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QSoundEffect> &qtdecl_QSoundEffect (); }
 
 class QVideoDeviceSelectorControl;
+
+namespace tl { template <> struct type_traits<QVideoDeviceSelectorControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QVideoDeviceSelectorControl> &qtdecl_QVideoDeviceSelectorControl (); }
 
 class QVideoEncoderSettings;
+
+namespace tl { template <> struct type_traits<QVideoEncoderSettings> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QVideoEncoderSettings> &qtdecl_QVideoEncoderSettings (); }
 
 class QVideoEncoderSettingsControl;
+
+namespace tl { template <> struct type_traits<QVideoEncoderSettingsControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QVideoEncoderSettingsControl> &qtdecl_QVideoEncoderSettingsControl (); }
 
 class QVideoFilterRunnable;
+
+namespace tl { template <> struct type_traits<QVideoFilterRunnable> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QVideoFilterRunnable> &qtdecl_QVideoFilterRunnable (); }
 
 class QVideoFrame;
+
+namespace tl { template <> struct type_traits<QVideoFrame> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QVideoFrame> &qtdecl_QVideoFrame (); }
 
 class QVideoProbe;
+
+namespace tl { template <> struct type_traits<QVideoProbe> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QVideoProbe> &qtdecl_QVideoProbe (); }
 
 class QVideoRendererControl;
+
+namespace tl { template <> struct type_traits<QVideoRendererControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QVideoRendererControl> &qtdecl_QVideoRendererControl (); }
 
 class QVideoSurfaceFormat;
+
+namespace tl { template <> struct type_traits<QVideoSurfaceFormat> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QVideoSurfaceFormat> &qtdecl_QVideoSurfaceFormat (); }
 
 class QVideoWidget;
+
+namespace tl { template <> struct type_traits<QVideoWidget> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QVideoWidget> &qtdecl_QVideoWidget (); }
 
 class QVideoWindowControl;
+
+namespace tl { template <> struct type_traits<QVideoWindowControl> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTMULTIMEDIA_PUBLIC gsi::Class<QVideoWindowControl> &qtdecl_QVideoWindowControl (); }
 
 

src/gsiqt/qt5/QtNetwork/gsiQtExternals.h

@@ -34,132 +34,326 @@
 #include "gsiQtNetworkCommon.h"
 
 class QAbstractNetworkCache;
+
+namespace tl { template <> struct type_traits<QAbstractNetworkCache> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QAbstractNetworkCache> &qtdecl_QAbstractNetworkCache (); }
 
 class QAbstractSocket;
+
+namespace tl { template <> struct type_traits<QAbstractSocket> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QAbstractSocket> &qtdecl_QAbstractSocket (); }
 
 class QAuthenticator;
+
+namespace tl { template <> struct type_traits<QAuthenticator> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QAuthenticator> &qtdecl_QAuthenticator (); }
 
 class QDnsDomainNameRecord;
+
+namespace tl { template <> struct type_traits<QDnsDomainNameRecord> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QDnsDomainNameRecord> &qtdecl_QDnsDomainNameRecord (); }
 
 class QDnsHostAddressRecord;
+
+namespace tl { template <> struct type_traits<QDnsHostAddressRecord> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QDnsHostAddressRecord> &qtdecl_QDnsHostAddressRecord (); }
 
 class QDnsLookup;
+
+namespace tl { template <> struct type_traits<QDnsLookup> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QDnsLookup> &qtdecl_QDnsLookup (); }
 
 class QDnsMailExchangeRecord;
+
+namespace tl { template <> struct type_traits<QDnsMailExchangeRecord> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QDnsMailExchangeRecord> &qtdecl_QDnsMailExchangeRecord (); }
 
 class QDnsServiceRecord;
+
+namespace tl { template <> struct type_traits<QDnsServiceRecord> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QDnsServiceRecord> &qtdecl_QDnsServiceRecord (); }
 
 class QDnsTextRecord;
+
+namespace tl { template <> struct type_traits<QDnsTextRecord> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QDnsTextRecord> &qtdecl_QDnsTextRecord (); }
 
 class QHostAddress;
+
+namespace tl { template <> struct type_traits<QHostAddress> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QHostAddress> &qtdecl_QHostAddress (); }
 
 class QHostInfo;
+
+namespace tl { template <> struct type_traits<QHostInfo> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QHostInfo> &qtdecl_QHostInfo (); }
 
 class QHttpMultiPart;
+
+namespace tl { template <> struct type_traits<QHttpMultiPart> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QHttpMultiPart> &qtdecl_QHttpMultiPart (); }
 
 class QHttpPart;
+
+namespace tl { template <> struct type_traits<QHttpPart> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QHttpPart> &qtdecl_QHttpPart (); }
 
 class QIPv6Address;
+
+namespace tl { template <> struct type_traits<QIPv6Address> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QIPv6Address> &qtdecl_QIPv6Address (); }
 
 class QLocalServer;
+
+namespace tl { template <> struct type_traits<QLocalServer> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QLocalServer> &qtdecl_QLocalServer (); }
 
 class QLocalSocket;
+
+namespace tl { template <> struct type_traits<QLocalSocket> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QLocalSocket> &qtdecl_QLocalSocket (); }
 
 class QNetworkAccessManager;
+
+namespace tl { template <> struct type_traits<QNetworkAccessManager> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkAccessManager> &qtdecl_QNetworkAccessManager (); }
 
 class QNetworkAddressEntry;
+
+namespace tl { template <> struct type_traits<QNetworkAddressEntry> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkAddressEntry> &qtdecl_QNetworkAddressEntry (); }
 
 class QNetworkCacheMetaData;
+
+namespace tl { template <> struct type_traits<QNetworkCacheMetaData> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkCacheMetaData> &qtdecl_QNetworkCacheMetaData (); }
 
 class QNetworkConfiguration;
+
+namespace tl { template <> struct type_traits<QNetworkConfiguration> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkConfiguration> &qtdecl_QNetworkConfiguration (); }
 
 class QNetworkConfigurationManager;
+
+namespace tl { template <> struct type_traits<QNetworkConfigurationManager> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkConfigurationManager> &qtdecl_QNetworkConfigurationManager (); }
 
 class QNetworkCookie;
+
+namespace tl { template <> struct type_traits<QNetworkCookie> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkCookie> &qtdecl_QNetworkCookie (); }
 
 class QNetworkCookieJar;
+
+namespace tl { template <> struct type_traits<QNetworkCookieJar> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkCookieJar> &qtdecl_QNetworkCookieJar (); }
 
 class QNetworkDiskCache;
+
+namespace tl { template <> struct type_traits<QNetworkDiskCache> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkDiskCache> &qtdecl_QNetworkDiskCache (); }
 
 class QNetworkInterface;
+
+namespace tl { template <> struct type_traits<QNetworkInterface> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkInterface> &qtdecl_QNetworkInterface (); }
 
 class QNetworkProxy;
+
+namespace tl { template <> struct type_traits<QNetworkProxy> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkProxy> &qtdecl_QNetworkProxy (); }
 
 class QNetworkProxyFactory;
+
+namespace tl { template <> struct type_traits<QNetworkProxyFactory> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkProxyFactory> &qtdecl_QNetworkProxyFactory (); }
 
 class QNetworkProxyQuery;
+
+namespace tl { template <> struct type_traits<QNetworkProxyQuery> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkProxyQuery> &qtdecl_QNetworkProxyQuery (); }
 
 class QNetworkReply;
+
+namespace tl { template <> struct type_traits<QNetworkReply> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkReply> &qtdecl_QNetworkReply (); }
 
 class QNetworkRequest;
+
+namespace tl { template <> struct type_traits<QNetworkRequest> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkRequest> &qtdecl_QNetworkRequest (); }
 
 class QNetworkSession;
+
+namespace tl { template <> struct type_traits<QNetworkSession> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QNetworkSession> &qtdecl_QNetworkSession (); }
 
 class QSslCertificate;
+
+namespace tl { template <> struct type_traits<QSslCertificate> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QSslCertificate> &qtdecl_QSslCertificate (); }
 
 class QSslCertificateExtension;
+
+namespace tl { template <> struct type_traits<QSslCertificateExtension> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QSslCertificateExtension> &qtdecl_QSslCertificateExtension (); }
 
 class QSslCipher;
+
+namespace tl { template <> struct type_traits<QSslCipher> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QSslCipher> &qtdecl_QSslCipher (); }
 
 class QSslConfiguration;
+
+namespace tl { template <> struct type_traits<QSslConfiguration> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QSslConfiguration> &qtdecl_QSslConfiguration (); }
 
 class QSslEllipticCurve;
+
+namespace tl { template <> struct type_traits<QSslEllipticCurve> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QSslEllipticCurve> &qtdecl_QSslEllipticCurve (); }
 
 class QSslError;
+
+namespace tl { template <> struct type_traits<QSslError> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QSslError> &qtdecl_QSslError (); }
 
 class QSslKey;
+
+namespace tl { template <> struct type_traits<QSslKey> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QSslKey> &qtdecl_QSslKey (); }
 
 class QSslPreSharedKeyAuthenticator;
+
+namespace tl { template <> struct type_traits<QSslPreSharedKeyAuthenticator> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QSslPreSharedKeyAuthenticator> &qtdecl_QSslPreSharedKeyAuthenticator (); }
 
 class QSslSocket;
+
+namespace tl { template <> struct type_traits<QSslSocket> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QSslSocket> &qtdecl_QSslSocket (); }
 
 class QTcpServer;
+
+namespace tl { template <> struct type_traits<QTcpServer> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QTcpServer> &qtdecl_QTcpServer (); }
 
 class QTcpSocket;
+
+namespace tl { template <> struct type_traits<QTcpSocket> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QTcpSocket> &qtdecl_QTcpSocket (); }
 
 class QUdpSocket;
+
+namespace tl { template <> struct type_traits<QUdpSocket> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTNETWORK_PUBLIC gsi::Class<QUdpSocket> &qtdecl_QUdpSocket (); }
 
 

src/gsiqt/qt5/QtPrintSupport/gsiQtExternals.h

@@ -34,27 +34,68 @@
 #include "gsiQtPrintSupportCommon.h"
 
 class QAbstractPrintDialog;
+
+namespace tl { template <> struct type_traits<QAbstractPrintDialog> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTPRINTSUPPORT_PUBLIC gsi::Class<QAbstractPrintDialog> &qtdecl_QAbstractPrintDialog (); }
 
 class QPageSetupDialog;
+
+namespace tl { template <> struct type_traits<QPageSetupDialog> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTPRINTSUPPORT_PUBLIC gsi::Class<QPageSetupDialog> &qtdecl_QPageSetupDialog (); }
 
 class QPrintDialog;
+
+namespace tl { template <> struct type_traits<QPrintDialog> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTPRINTSUPPORT_PUBLIC gsi::Class<QPrintDialog> &qtdecl_QPrintDialog (); }
 
 class QPrintEngine;
+
+namespace tl { template <> struct type_traits<QPrintEngine> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTPRINTSUPPORT_PUBLIC gsi::Class<QPrintEngine> &qtdecl_QPrintEngine (); }
 
 class QPrintPreviewDialog;
+
+namespace tl { template <> struct type_traits<QPrintPreviewDialog> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTPRINTSUPPORT_PUBLIC gsi::Class<QPrintPreviewDialog> &qtdecl_QPrintPreviewDialog (); }
 
 class QPrintPreviewWidget;
+
+namespace tl { template <> struct type_traits<QPrintPreviewWidget> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTPRINTSUPPORT_PUBLIC gsi::Class<QPrintPreviewWidget> &qtdecl_QPrintPreviewWidget (); }
 
 class QPrinter;
+
+namespace tl { template <> struct type_traits<QPrinter> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTPRINTSUPPORT_PUBLIC gsi::Class<QPrinter> &qtdecl_QPrinter (); }
 
 class QPrinterInfo;
+
+namespace tl { template <> struct type_traits<QPrinterInfo> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTPRINTSUPPORT_PUBLIC gsi::Class<QPrinterInfo> &qtdecl_QPrinterInfo (); }
 
 

src/gsiqt/qt5/QtSql/gsiQtExternals.h

@@ -34,42 +34,103 @@
 #include "gsiQtSqlCommon.h"
 
 class QSqlDatabase;
+
+namespace tl { template <> struct type_traits<QSqlDatabase> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlDatabase> &qtdecl_QSqlDatabase (); }
 
 class QSqlDriver;
+
+namespace tl { template <> struct type_traits<QSqlDriver> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlDriver> &qtdecl_QSqlDriver (); }
 
 class QSqlDriverCreatorBase;
+
+namespace tl { template <> struct type_traits<QSqlDriverCreatorBase> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlDriverCreatorBase> &qtdecl_QSqlDriverCreatorBase (); }
 
 class QSqlError;
+
+namespace tl { template <> struct type_traits<QSqlError> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlError> &qtdecl_QSqlError (); }
 
 class QSqlField;
+
+namespace tl { template <> struct type_traits<QSqlField> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlField> &qtdecl_QSqlField (); }
 
 class QSqlIndex;
+
+namespace tl { template <> struct type_traits<QSqlIndex> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlIndex> &qtdecl_QSqlIndex (); }
 
 class QSqlQuery;
+
+namespace tl { template <> struct type_traits<QSqlQuery> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlQuery> &qtdecl_QSqlQuery (); }
 
 class QSqlQueryModel;
+
+namespace tl { template <> struct type_traits<QSqlQueryModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlQueryModel> &qtdecl_QSqlQueryModel (); }
 
 class QSqlRecord;
+
+namespace tl { template <> struct type_traits<QSqlRecord> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlRecord> &qtdecl_QSqlRecord (); }
 
 class QSqlRelation;
+
+namespace tl { template <> struct type_traits<QSqlRelation> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlRelation> &qtdecl_QSqlRelation (); }
 
 class QSqlRelationalTableModel;
+
+namespace tl { template <> struct type_traits<QSqlRelationalTableModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlRelationalTableModel> &qtdecl_QSqlRelationalTableModel (); }
 
 class QSqlResult;
+
+namespace tl { template <> struct type_traits<QSqlResult> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlResult> &qtdecl_QSqlResult (); }
 
 class QSqlTableModel;
+
+namespace tl { template <> struct type_traits<QSqlTableModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTSQL_PUBLIC gsi::Class<QSqlTableModel> &qtdecl_QSqlTableModel (); }
 
 

src/gsiqt/qt5/QtSvg/gsiQtExternals.h

@@ -34,15 +34,35 @@
 #include "gsiQtSvgCommon.h"
 
 class QGraphicsSvgItem;
+
+namespace tl { template <> struct type_traits<QGraphicsSvgItem> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTSVG_PUBLIC gsi::Class<QGraphicsSvgItem> &qtdecl_QGraphicsSvgItem (); }
 
 class QSvgGenerator;
+
+namespace tl { template <> struct type_traits<QSvgGenerator> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTSVG_PUBLIC gsi::Class<QSvgGenerator> &qtdecl_QSvgGenerator (); }
 
 class QSvgRenderer;
+
+namespace tl { template <> struct type_traits<QSvgRenderer> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTSVG_PUBLIC gsi::Class<QSvgRenderer> &qtdecl_QSvgRenderer (); }
 
 class QSvgWidget;
+
+namespace tl { template <> struct type_traits<QSvgWidget> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTSVG_PUBLIC gsi::Class<QSvgWidget> &qtdecl_QSvgWidget (); }
 
 

src/gsiqt/qt5/QtXml/gsiQtExternals.h

@@ -34,96 +34,240 @@
 #include "gsiQtXmlCommon.h"
 
 class QDomAttr;
+
+namespace tl { template <> struct type_traits<QDomAttr> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomAttr> &qtdecl_QDomAttr (); }
 
 class QDomCDATASection;
+
+namespace tl { template <> struct type_traits<QDomCDATASection> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomCDATASection> &qtdecl_QDomCDATASection (); }
 
 class QDomCharacterData;
+
+namespace tl { template <> struct type_traits<QDomCharacterData> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomCharacterData> &qtdecl_QDomCharacterData (); }
 
 class QDomComment;
+
+namespace tl { template <> struct type_traits<QDomComment> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomComment> &qtdecl_QDomComment (); }
 
 class QDomDocument;
+
+namespace tl { template <> struct type_traits<QDomDocument> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomDocument> &qtdecl_QDomDocument (); }
 
 class QDomDocumentFragment;
+
+namespace tl { template <> struct type_traits<QDomDocumentFragment> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomDocumentFragment> &qtdecl_QDomDocumentFragment (); }
 
 class QDomDocumentType;
+
+namespace tl { template <> struct type_traits<QDomDocumentType> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomDocumentType> &qtdecl_QDomDocumentType (); }
 
 class QDomElement;
+
+namespace tl { template <> struct type_traits<QDomElement> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomElement> &qtdecl_QDomElement (); }
 
 class QDomEntity;
+
+namespace tl { template <> struct type_traits<QDomEntity> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomEntity> &qtdecl_QDomEntity (); }
 
 class QDomEntityReference;
+
+namespace tl { template <> struct type_traits<QDomEntityReference> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomEntityReference> &qtdecl_QDomEntityReference (); }
 
 class QDomImplementation;
+
+namespace tl { template <> struct type_traits<QDomImplementation> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomImplementation> &qtdecl_QDomImplementation (); }
 
 class QDomNamedNodeMap;
+
+namespace tl { template <> struct type_traits<QDomNamedNodeMap> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomNamedNodeMap> &qtdecl_QDomNamedNodeMap (); }
 
 class QDomNode;
+
+namespace tl { template <> struct type_traits<QDomNode> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomNode> &qtdecl_QDomNode (); }
 
 class QDomNodeList;
+
+namespace tl { template <> struct type_traits<QDomNodeList> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomNodeList> &qtdecl_QDomNodeList (); }
 
 class QDomNotation;
+
+namespace tl { template <> struct type_traits<QDomNotation> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomNotation> &qtdecl_QDomNotation (); }
 
 class QDomProcessingInstruction;
+
+namespace tl { template <> struct type_traits<QDomProcessingInstruction> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomProcessingInstruction> &qtdecl_QDomProcessingInstruction (); }
 
 class QDomText;
+
+namespace tl { template <> struct type_traits<QDomText> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QDomText> &qtdecl_QDomText (); }
 
 class QXmlAttributes;
+
+namespace tl { template <> struct type_traits<QXmlAttributes> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlAttributes> &qtdecl_QXmlAttributes (); }
 
 class QXmlContentHandler;
+
+namespace tl { template <> struct type_traits<QXmlContentHandler> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlContentHandler> &qtdecl_QXmlContentHandler (); }
 
 class QXmlDTDHandler;
+
+namespace tl { template <> struct type_traits<QXmlDTDHandler> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlDTDHandler> &qtdecl_QXmlDTDHandler (); }
 
 class QXmlDeclHandler;
+
+namespace tl { template <> struct type_traits<QXmlDeclHandler> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlDeclHandler> &qtdecl_QXmlDeclHandler (); }
 
 class QXmlDefaultHandler;
+
+namespace tl { template <> struct type_traits<QXmlDefaultHandler> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlDefaultHandler> &qtdecl_QXmlDefaultHandler (); }
 
 class QXmlEntityResolver;
+
+namespace tl { template <> struct type_traits<QXmlEntityResolver> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlEntityResolver> &qtdecl_QXmlEntityResolver (); }
 
 class QXmlErrorHandler;
+
+namespace tl { template <> struct type_traits<QXmlErrorHandler> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlErrorHandler> &qtdecl_QXmlErrorHandler (); }
 
 class QXmlInputSource;
+
+namespace tl { template <> struct type_traits<QXmlInputSource> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlInputSource> &qtdecl_QXmlInputSource (); }
 
 class QXmlLexicalHandler;
+
+namespace tl { template <> struct type_traits<QXmlLexicalHandler> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlLexicalHandler> &qtdecl_QXmlLexicalHandler (); }
 
 class QXmlLocator;
+
+namespace tl { template <> struct type_traits<QXmlLocator> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlLocator> &qtdecl_QXmlLocator (); }
 
 class QXmlNamespaceSupport;
+
+namespace tl { template <> struct type_traits<QXmlNamespaceSupport> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlNamespaceSupport> &qtdecl_QXmlNamespaceSupport (); }
 
 class QXmlParseException;
+
+namespace tl { template <> struct type_traits<QXmlParseException> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlParseException> &qtdecl_QXmlParseException (); }
 
 class QXmlReader;
+
+namespace tl { template <> struct type_traits<QXmlReader> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlReader> &qtdecl_QXmlReader (); }
 
 class QXmlSimpleReader;
+
+namespace tl { template <> struct type_traits<QXmlSimpleReader> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTXML_PUBLIC gsi::Class<QXmlSimpleReader> &qtdecl_QXmlSimpleReader (); }
 
 

src/gsiqt/qt5/QtXmlPatterns/gsiQtExternals.h

@@ -34,51 +34,131 @@
 #include "gsiQtXmlPatternsCommon.h"
 
 class QAbstractMessageHandler;
+
+namespace tl { template <> struct type_traits<QAbstractMessageHandler> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXMLPATTERNS_PUBLIC gsi::Class<QAbstractMessageHandler> &qtdecl_QAbstractMessageHandler (); }
 
 class QAbstractUriResolver;
+
+namespace tl { template <> struct type_traits<QAbstractUriResolver> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXMLPATTERNS_PUBLIC gsi::Class<QAbstractUriResolver> &qtdecl_QAbstractUriResolver (); }
 
 class QAbstractXmlNodeModel;
+
+namespace tl { template <> struct type_traits<QAbstractXmlNodeModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXMLPATTERNS_PUBLIC gsi::Class<QAbstractXmlNodeModel> &qtdecl_QAbstractXmlNodeModel (); }
 
 class QAbstractXmlReceiver;
+
+namespace tl { template <> struct type_traits<QAbstractXmlReceiver> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXMLPATTERNS_PUBLIC gsi::Class<QAbstractXmlReceiver> &qtdecl_QAbstractXmlReceiver (); }
 
 class QSimpleXmlNodeModel;
+
+namespace tl { template <> struct type_traits<QSimpleXmlNodeModel> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXMLPATTERNS_PUBLIC gsi::Class<QSimpleXmlNodeModel> &qtdecl_QSimpleXmlNodeModel (); }
 
 class QSourceLocation;
+
+namespace tl { template <> struct type_traits<QSourceLocation> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXMLPATTERNS_PUBLIC gsi::Class<QSourceLocation> &qtdecl_QSourceLocation (); }
 
 class QXmlFormatter;
+
+namespace tl { template <> struct type_traits<QXmlFormatter> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXMLPATTERNS_PUBLIC gsi::Class<QXmlFormatter> &qtdecl_QXmlFormatter (); }
 
 class QXmlItem;
+
+namespace tl { template <> struct type_traits<QXmlItem> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXMLPATTERNS_PUBLIC gsi::Class<QXmlItem> &qtdecl_QXmlItem (); }
 
 class QXmlName;
+
+namespace tl { template <> struct type_traits<QXmlName> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXMLPATTERNS_PUBLIC gsi::Class<QXmlName> &qtdecl_QXmlName (); }
 
 class QXmlNamePool;
+
+namespace tl { template <> struct type_traits<QXmlNamePool> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXMLPATTERNS_PUBLIC gsi::Class<QXmlNamePool> &qtdecl_QXmlNamePool (); }
 
 class QXmlNodeModelIndex;
+
+namespace tl { template <> struct type_traits<QXmlNodeModelIndex> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXMLPATTERNS_PUBLIC gsi::Class<QXmlNodeModelIndex> &qtdecl_QXmlNodeModelIndex (); }
 
 class QXmlQuery;
+
+namespace tl { template <> struct type_traits<QXmlQuery> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXMLPATTERNS_PUBLIC gsi::Class<QXmlQuery> &qtdecl_QXmlQuery (); }
 
 class QXmlResultItems;
+
+namespace tl { template <> struct type_traits<QXmlResultItems> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTXMLPATTERNS_PUBLIC gsi::Class<QXmlResultItems> &qtdecl_QXmlResultItems (); }
 
 class QXmlSchema;
+
+namespace tl { template <> struct type_traits<QXmlSchema> : public type_traits<void> {
+}; }
+
 namespace gsi { GSI_QTXMLPATTERNS_PUBLIC gsi::Class<QXmlSchema> &qtdecl_QXmlSchema (); }
 
 class QXmlSchemaValidator;
+
+namespace tl { template <> struct type_traits<QXmlSchemaValidator> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+}; }
+
 namespace gsi { GSI_QTXMLPATTERNS_PUBLIC gsi::Class<QXmlSchemaValidator> &qtdecl_QXmlSchemaValidator (); }
 
 class QXmlSerializer;
+
+namespace tl { template <> struct type_traits<QXmlSerializer> : public type_traits<void> {
+  typedef tl::false_tag has_copy_constructor;
+  typedef tl::false_tag has_default_constructor;
+}; }
+
 namespace gsi { GSI_QTXMLPATTERNS_PUBLIC gsi::Class<QXmlSerializer> &qtdecl_QXmlSerializer (); }