Initial import from the monolithic Qt.

This is the beginning of revision history for this module. If you
want to look at revision history older than this, please refer to the
Qt Git wiki for how to use Git history grafting. At the time of
writing, this wiki is located here:

http://qt.gitorious.org/qt/pages/GitIntroductionWithQt

If you have already performed the grafting and you don't see any
history beyond this commit, try running "git log" with the "--follow"
argument.

Branched from the monolithic repo, Qt master branch, at commit
896db169ea224deb96c59ce8af800d019de63f12

1 files changed, 828 insertions, 0 deletions

diff --git a/src/gui/kernel/qguivariant.cpp b/src/gui/kernel/qguivariant.cpp
new file mode 100644
index 0000000000..badff80834
--- /dev/null
+++ b/src/gui/kernel/qguivariant.cpp
@@ -0,0 +1,828 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qvariant.h"
+
+#include "qbitmap.h"
+#include "qbrush.h"
+#include "qcolor.h"
+#include "qcursor.h"
+#include "qdatastream.h"
+#include "qdebug.h"
+#include "qfont.h"
+#include "qicon.h"
+#include "qimage.h"
+#include "qkeysequence.h"
+#include "qtransform.h"
+#include "qmatrix.h"
+#include "qpalette.h"
+#include "qpen.h"
+#include "qpixmap.h"
+#include "qpolygon.h"
+#include "qregion.h"
+#include "qsizepolicy.h"
+#include "qtextformat.h"
+#include "qmatrix4x4.h"
+#include "qvector2d.h"
+#include "qvector3d.h"
+#include "qvector4d.h"
+#include "qquaternion.h"
+
+#include "private/qvariant_p.h"
+
+QT_BEGIN_NAMESPACE
+
+#ifdef QT3_SUPPORT
+extern QDataStream &qt_stream_out_qcolorgroup(QDataStream &s, const QColorGroup &g);
+extern QDataStream &qt_stream_in_qcolorgroup(QDataStream &s, QColorGroup &g);
+#endif
+
+Q_CORE_EXPORT const QVariant::Handler *qcoreVariantHandler();
+
+static void construct(QVariant::Private *x, const void *copy)
+{
+    switch (x->type) {
+    case QVariant::Bitmap:
+        v_construct<QBitmap>(x, copy);
+        break;
+    case QVariant::Region:
+        v_construct<QRegion>(x, copy);
+        break;
+    case QVariant::Polygon:
+        v_construct<QPolygon>(x, copy);
+        break;
+    case QVariant::Font:
+        v_construct<QFont>(x, copy);
+        break;
+    case QVariant::Pixmap:
+        v_construct<QPixmap>(x, copy);
+        break;
+    case QVariant::Image:
+        v_construct<QImage>(x, copy);
+        break;
+    case QVariant::Brush:
+        v_construct<QBrush>(x, copy);
+        break;
+    case QVariant::Color:
+        v_construct<QColor>(x, copy);
+        break;
+    case QVariant::Palette:
+        v_construct<QPalette>(x, copy);
+        break;
+#ifdef QT3_SUPPORT
+    case QVariant::ColorGroup:
+        v_construct<QColorGroup>(x, copy);
+        break;
+#endif
+#ifndef QT_NO_ICON
+    case QVariant::Icon:
+        v_construct<QIcon>(x, copy);
+        break;
+#endif
+    case QVariant::Matrix:
+        v_construct<QMatrix>(x, copy);
+        break;
+    case QVariant::Transform:
+        v_construct<QTransform>(x, copy);
+        break;
+    case QVariant::TextFormat:
+        v_construct<QTextFormat>(x, copy);
+        break;
+    case QVariant::TextLength:
+        v_construct<QTextLength>(x, copy);
+        break;
+#ifndef QT_NO_SHORTCUT
+    case QVariant::KeySequence:
+        v_construct<QKeySequence>(x, copy);
+        break;
+#endif
+    case QVariant::Pen:
+        v_construct<QPen>(x, copy);
+        break;
+    case QVariant::SizePolicy:
+        v_construct<QSizePolicy>(x, copy);
+        break;
+#ifndef QT_NO_CURSOR
+    case QVariant::Cursor:
+        v_construct<QCursor>(x, copy);
+        break;
+#endif
+    case 62: {
+        // small 'trick' to let a QVariant(Qt::blue) create a variant
+        // of type QColor
+        x->type = QVariant::Color;
+        QColor color(*reinterpret_cast<const Qt::GlobalColor *>(copy));
+        v_construct<QColor>(x, &color);
+        break;
+    }
+#ifndef QT_NO_MATRIX4X4
+    case QVariant::Matrix4x4:
+        v_construct<QMatrix4x4>(x, copy);
+        break;
+#endif
+#ifndef QT_NO_VECTOR2D
+    case QVariant::Vector2D:
+        v_construct<QVector2D>(x, copy);
+        break;
+#endif
+#ifndef QT_NO_VECTOR3D
+    case QVariant::Vector3D:
+        v_construct<QVector3D>(x, copy);
+        break;
+#endif
+#ifndef QT_NO_VECTOR4D
+    case QVariant::Vector4D:
+        v_construct<QVector4D>(x, copy);
+        break;
+#endif
+#ifndef QT_NO_QUATERNION
+    case QVariant::Quaternion:
+        v_construct<QQuaternion>(x, copy);
+        break;
+#endif
+    default:
+        qcoreVariantHandler()->construct(x, copy);
+        return;
+    }
+    x->is_null = !copy;
+}
+
+static void clear(QVariant::Private *d)
+{
+    switch (d->type) {
+    case QVariant::Bitmap:
+        v_clear<QBitmap>(d);
+        break;
+    case QVariant::Cursor:
+        v_clear<QCursor>(d);
+        break;
+    case QVariant::Region:
+        v_clear<QRegion>(d);
+        break;
+    case QVariant::Polygon:
+        v_clear<QPolygon>(d);
+        break;
+    case QVariant::Font:
+        v_clear<QFont>(d);
+        break;
+    case QVariant::Pixmap:
+        v_clear<QPixmap>(d);
+        break;
+    case QVariant::Image:
+        v_clear<QImage>(d);
+        break;
+    case QVariant::Brush:
+        v_clear<QBrush>(d);
+        break;
+    case QVariant::Color:
+        v_clear<QColor>(d);
+        break;
+    case QVariant::Palette:
+        v_clear<QPalette>(d);
+        break;
+#ifdef QT3_SUPPORT
+    case QVariant::ColorGroup:
+        v_clear<QColorGroup>(d);
+        break;
+#endif
+#ifndef QT_NO_ICON
+    case QVariant::Icon:
+        v_clear<QIcon>(d);
+        break;
+#endif
+    case QVariant::Matrix:
+        v_clear<QMatrix>(d);
+        break;
+    case QVariant::Transform:
+        v_clear<QTransform>(d);
+        break;
+    case QVariant::TextFormat:
+        v_clear<QTextFormat>(d);
+        break;
+    case QVariant::TextLength:
+        v_clear<QTextLength>(d);
+        break;
+    case QVariant::SizePolicy:
+        v_clear<QSizePolicy>(d);
+        break;
+#ifndef QT_NO_SHORTCUT
+    case QVariant::KeySequence:
+        v_clear<QKeySequence>(d);
+        break;
+#endif
+    case QVariant::Pen:
+        v_clear<QPen>(d);
+        break;
+#ifndef QT_NO_MATRIX4X4
+    case QVariant::Matrix4x4:
+        v_clear<QMatrix4x4>(d);
+        break;
+#endif
+#ifndef QT_NO_VECTOR2D
+    case QVariant::Vector2D:
+        v_clear<QVector2D>(d);
+        break;
+#endif
+#ifndef QT_NO_VECTOR3D
+    case QVariant::Vector3D:
+        v_clear<QVector3D>(d);
+        break;
+#endif
+#ifndef QT_NO_VECTOR4D
+    case QVariant::Vector4D:
+        v_clear<QVector4D>(d);
+        break;
+#endif
+#ifndef QT_NO_QUATERNION
+    case QVariant::Quaternion:
+        v_clear<QVector4D>(d);
+        break;
+#endif
+    default:
+        qcoreVariantHandler()->clear(d);
+        return;
+    }
+
+    d->type = QVariant::Invalid;
+    d->is_null = true;
+    d->is_shared = false;
+}
+
+
+static bool isNull(const QVariant::Private *d)
+{
+    switch(d->type) {
+    case QVariant::Bitmap:
+        return v_cast<QBitmap>(d)->isNull();
+    case QVariant::Region:
+        return v_cast<QRegion>(d)->isEmpty();
+    case QVariant::Polygon:
+        return v_cast<QPolygon>(d)->isEmpty();
+    case QVariant::Pixmap:
+        return v_cast<QPixmap>(d)->isNull();
+    case QVariant::Image:
+        return v_cast<QImage>(d)->isNull();
+#ifndef QT_NO_ICON
+    case QVariant::Icon:
+        return v_cast<QIcon>(d)->isNull();
+#endif
+    case QVariant::Matrix:
+    case QVariant::TextFormat:
+    case QVariant::TextLength:
+    case QVariant::Cursor:
+    case QVariant::StringList:
+    case QVariant::Font:
+    case QVariant::Brush:
+    case QVariant::Color:
+    case QVariant::Palette:
+#ifdef QT3_SUPPORT
+    case QVariant::ColorGroup:
+#endif
+    case QVariant::SizePolicy:
+#ifndef QT_NO_SHORTCUT
+    case QVariant::KeySequence:
+#endif
+    case QVariant::Pen:
+#ifndef QT_NO_MATRIX4X4
+    case QVariant::Matrix4x4:
+#endif
+        break;
+#ifndef QT_NO_VECTOR2D
+    case QVariant::Vector2D:
+        return v_cast<QVector2D>(d)->isNull();
+#endif
+#ifndef QT_NO_VECTOR3D
+    case QVariant::Vector3D:
+        return v_cast<QVector3D>(d)->isNull();
+#endif
+#ifndef QT_NO_VECTOR4D
+    case QVariant::Vector4D:
+        return v_cast<QVector4D>(d)->isNull();
+#endif
+#ifndef QT_NO_QUATERNION
+    case QVariant::Quaternion:
+        return v_cast<QQuaternion>(d)->isNull();
+#endif
+    default:
+        return qcoreVariantHandler()->isNull(d);
+    }
+    return d->is_null;
+}
+
+static bool compare(const QVariant::Private *a, const QVariant::Private *b)
+{
+    Q_ASSERT(a->type == b->type);
+    switch(a->type) {
+    case QVariant::Cursor:
+#ifndef QT_NO_CURSOR
+        return v_cast<QCursor>(a)->shape() == v_cast<QCursor>(b)->shape();
+#endif
+    case QVariant::Bitmap:
+        return v_cast<QBitmap>(a)->cacheKey()
+            == v_cast<QBitmap>(b)->cacheKey();
+    case QVariant::Polygon:
+        return *v_cast<QPolygon>(a) == *v_cast<QPolygon>(b);
+    case QVariant::Region:
+        return *v_cast<QRegion>(a) == *v_cast<QRegion>(b);
+    case QVariant::Font:
+        return *v_cast<QFont>(a) == *v_cast<QFont>(b);
+    case QVariant::Pixmap:
+        return v_cast<QPixmap>(a)->cacheKey() == v_cast<QPixmap>(b)->cacheKey();
+    case QVariant::Image:
+        return *v_cast<QImage>(a) == *v_cast<QImage>(b);
+    case QVariant::Brush:
+        return *v_cast<QBrush>(a) == *v_cast<QBrush>(b);
+    case QVariant::Color:
+        return *v_cast<QColor>(a) == *v_cast<QColor>(b);
+    case QVariant::Palette:
+        return *v_cast<QPalette>(a) == *v_cast<QPalette>(b);
+#ifdef QT3_SUPPORT
+    case QVariant::ColorGroup:
+        return *v_cast<QColorGroup>(a) == *v_cast<QColorGroup>(b);
+#endif
+#ifndef QT_NO_ICON
+    case QVariant::Icon:
+        /* QIcon::operator==() cannot be reasonably implemented for QIcon,
+         * so we always return false. */
+        return false;
+#endif
+    case QVariant::Matrix:
+        return *v_cast<QMatrix>(a) == *v_cast<QMatrix>(b);
+    case QVariant::Transform:
+        return *v_cast<QTransform>(a) == *v_cast<QTransform>(b);
+    case QVariant::TextFormat:
+        return *v_cast<QTextFormat>(a) == *v_cast<QTextFormat>(b);
+    case QVariant::TextLength:
+        return *v_cast<QTextLength>(a) == *v_cast<QTextLength>(b);
+    case QVariant::SizePolicy:
+        return *v_cast<QSizePolicy>(a) == *v_cast<QSizePolicy>(b);
+#ifndef QT_NO_SHORTCUT
+    case QVariant::KeySequence:
+        return *v_cast<QKeySequence>(a) == *v_cast<QKeySequence>(b);
+#endif
+    case QVariant::Pen:
+        return *v_cast<QPen>(a) == *v_cast<QPen>(b);
+#ifndef QT_NO_MATRIX4X4
+    case QVariant::Matrix4x4:
+        return *v_cast<QMatrix4x4>(a) == *v_cast<QMatrix4x4>(b);
+#endif
+#ifndef QT_NO_VECTOR2D
+    case QVariant::Vector2D:
+        return *v_cast<QVector2D>(a) == *v_cast<QVector2D>(b);
+#endif
+#ifndef QT_NO_VECTOR3D
+    case QVariant::Vector3D:
+        return *v_cast<QVector3D>(a) == *v_cast<QVector3D>(b);
+#endif
+#ifndef QT_NO_VECTOR4D
+    case QVariant::Vector4D:
+        return *v_cast<QVector4D>(a) == *v_cast<QVector4D>(b);
+#endif
+#ifndef QT_NO_QUATERNION
+    case QVariant::Quaternion:
+        return *v_cast<QQuaternion>(a) == *v_cast<QQuaternion>(b);
+#endif
+    default:
+        break;
+    }
+    return qcoreVariantHandler()->compare(a, b);
+}
+
+
+
+static bool convert(const QVariant::Private *d, QVariant::Type t,
+                 void *result, bool *ok)
+{
+    switch (t) {
+    case QVariant::ByteArray:
+        if (d->type == QVariant::Color) {
+            *static_cast<QByteArray *>(result) = v_cast<QColor>(d)->name().toLatin1();
+            return true;
+        }
+        break;
+    case QVariant::String: {
+        QString *str = static_cast<QString *>(result);
+        switch (d->type) {
+#ifndef QT_NO_SHORTCUT
+        case QVariant::KeySequence:
+            *str = QString(*v_cast<QKeySequence>(d));
+            return true;
+#endif
+        case QVariant::Font:
+            *str = v_cast<QFont>(d)->toString();
+            return true;
+        case QVariant::Color:
+            *str = v_cast<QColor>(d)->name();
+            return true;
+        default:
+            break;
+        }
+        break;
+    }
+    case QVariant::Pixmap:
+        if (d->type == QVariant::Image) {
+            *static_cast<QPixmap *>(result) = QPixmap::fromImage(*v_cast<QImage>(d));
+            return true;
+        } else if (d->type == QVariant::Bitmap) {
+            *static_cast<QPixmap *>(result) = *v_cast<QBitmap>(d);
+            return true;
+        } else if (d->type == QVariant::Brush) {
+            if (v_cast<QBrush>(d)->style() == Qt::TexturePattern) {
+                *static_cast<QPixmap *>(result) = v_cast<QBrush>(d)->texture();
+                return true;
+            }
+        }
+        break;
+    case QVariant::Image:
+        if (d->type == QVariant::Pixmap) {
+            *static_cast<QImage *>(result) = v_cast<QPixmap>(d)->toImage();
+            return true;
+        } else if (d->type == QVariant::Bitmap) {
+            *static_cast<QImage *>(result) = v_cast<QBitmap>(d)->toImage();
+            return true;
+        }
+        break;
+    case QVariant::Bitmap:
+        if (d->type == QVariant::Pixmap) {
+            *static_cast<QBitmap *>(result) = *v_cast<QPixmap>(d);
+            return true;
+        } else if (d->type == QVariant::Image) {
+            *static_cast<QBitmap *>(result) = QBitmap::fromImage(*v_cast<QImage>(d));
+            return true;
+        }
+        break;
+#ifndef QT_NO_SHORTCUT
+    case QVariant::Int:
+        if (d->type == QVariant::KeySequence) {
+            *static_cast<int *>(result) = (int)(*(v_cast<QKeySequence>(d)));
+            return true;
+        }
+        break;
+#endif
+    case QVariant::Font:
+        if (d->type == QVariant::String) {
+            QFont *f = static_cast<QFont *>(result);
+            f->fromString(*v_cast<QString>(d));
+            return true;
+        }
+        break;
+    case QVariant::Color:
+        if (d->type == QVariant::String) {
+            static_cast<QColor *>(result)->setNamedColor(*v_cast<QString>(d));
+            return static_cast<QColor *>(result)->isValid();
+        } else if (d->type == QVariant::ByteArray) {
+            static_cast<QColor *>(result)->setNamedColor(QString::fromLatin1(
+                                *v_cast<QByteArray>(d)));
+            return true;
+        } else if (d->type == QVariant::Brush) {
+            if (v_cast<QBrush>(d)->style() == Qt::SolidPattern) {
+                *static_cast<QColor *>(result) = v_cast<QBrush>(d)->color();
+                return true;
+            }
+        }
+        break;
+    case QVariant::Brush:
+        if (d->type == QVariant::Color) {
+            *static_cast<QBrush *>(result) = QBrush(*v_cast<QColor>(d));
+            return true;
+        } else if (d->type == QVariant::Pixmap) {
+            *static_cast<QBrush *>(result) = QBrush(*v_cast<QPixmap>(d));
+            return true;
+        }
+        break;
+#ifndef QT_NO_SHORTCUT
+    case QVariant::KeySequence: {
+        QKeySequence *seq = static_cast<QKeySequence *>(result);
+        switch (d->type) {
+        case QVariant::String:
+            *seq = QKeySequence(*v_cast<QString>(d));
+            return true;
+        case QVariant::Int:
+            *seq = QKeySequence(d->data.i);
+            return true;
+        default:
+            break;
+        }
+    }
+#endif
+    default:
+        break;
+    }
+    return qcoreVariantHandler()->convert(d, t, result, ok);
+}
+
+#if !defined(QT_NO_DEBUG_STREAM) && !defined(Q_BROKEN_DEBUG_STREAM)
+static void streamDebug(QDebug dbg, const QVariant &v)
+{
+    switch(v.type()) {
+    case QVariant::Cursor:
+#ifndef QT_NO_CURSOR
+//        dbg.nospace() << qvariant_cast<QCursor>(v); //FIXME
+#endif
+        break;
+    case QVariant::Bitmap:
+//        dbg.nospace() << qvariant_cast<QBitmap>(v); //FIXME
+        break;
+    case QVariant::Polygon:
+        dbg.nospace() << qvariant_cast<QPolygon>(v);
+        break;
+    case QVariant::Region:
+        dbg.nospace() << qvariant_cast<QRegion>(v);
+        break;
+    case QVariant::Font:
+//        dbg.nospace() << qvariant_cast<QFont>(v);  //FIXME
+        break;
+    case QVariant::Matrix:
+        dbg.nospace() << qvariant_cast<QMatrix>(v);
+        break;
+    case QVariant::Transform:
+        dbg.nospace() << qvariant_cast<QTransform>(v);
+        break;
+    case QVariant::Pixmap:
+//        dbg.nospace() << qvariant_cast<QPixmap>(v); //FIXME
+        break;
+    case QVariant::Image:
+//        dbg.nospace() << qvariant_cast<QImage>(v); //FIXME
+        break;
+    case QVariant::Brush:
+        dbg.nospace() << qvariant_cast<QBrush>(v);
+        break;
+    case QVariant::Color:
+        dbg.nospace() << qvariant_cast<QColor>(v);
+        break;
+    case QVariant::Palette:
+//        dbg.nospace() << qvariant_cast<QPalette>(v); //FIXME
+        break;
+#ifndef QT_NO_ICON
+    case QVariant::Icon:
+//        dbg.nospace() << qvariant_cast<QIcon>(v); // FIXME
+        break;
+#endif
+    case QVariant::SizePolicy:
+//        dbg.nospace() << qvariant_cast<QSizePolicy>(v); //FIXME
+        break;
+#ifndef QT_NO_SHORTCUT
+    case QVariant::KeySequence:
+        dbg.nospace() << qvariant_cast<QKeySequence>(v);
+        break;
+#endif
+    case QVariant::Pen:
+        dbg.nospace() << qvariant_cast<QPen>(v);
+        break;
+#ifndef QT_NO_MATRIX4X4
+    case QVariant::Matrix4x4:
+        dbg.nospace() << qvariant_cast<QMatrix4x4>(v);
+        break;
+#endif
+#ifndef QT_NO_VECTOR2D
+    case QVariant::Vector2D:
+        dbg.nospace() << qvariant_cast<QVector2D>(v);
+        break;
+#endif
+#ifndef QT_NO_VECTOR3D
+    case QVariant::Vector3D:
+        dbg.nospace() << qvariant_cast<QVector3D>(v);
+        break;
+#endif
+#ifndef QT_NO_VECTOR4D
+    case QVariant::Vector4D:
+        dbg.nospace() << qvariant_cast<QVector4D>(v);
+        break;
+#endif
+#ifndef QT_NO_QUATERNION
+    case QVariant::Quaternion:
+        dbg.nospace() << qvariant_cast<QQuaternion>(v);
+        break;
+#endif
+    default:
+        qcoreVariantHandler()->debugStream(dbg, v);
+        break;
+    }
+}
+#endif
+
+const QVariant::Handler qt_gui_variant_handler = {
+    construct,
+    clear,
+    isNull,
+#ifndef QT_NO_DATASTREAM
+    0,
+    0,
+#endif
+    compare,
+    convert,
+    0,
+#if !defined(QT_NO_DEBUG_STREAM) && !defined(Q_BROKEN_DEBUG_STREAM)
+    streamDebug
+#else
+    0
+#endif
+};
+
+struct QMetaTypeGuiHelper
+{
+    QMetaType::Constructor constr;
+    QMetaType::Destructor destr;
+#ifndef QT_NO_DATASTREAM
+    QMetaType::SaveOperator saveOp;
+    QMetaType::LoadOperator loadOp;
+#endif
+};
+
+extern Q_CORE_EXPORT const QMetaTypeGuiHelper *qMetaTypeGuiHelper;
+
+
+#ifdef QT_NO_DATASTREAM
+#  define Q_DECL_METATYPE_HELPER(TYPE) \
+     typedef void *(*QConstruct##TYPE)(const TYPE *); \
+     static const QConstruct##TYPE qConstruct##TYPE = qMetaTypeConstructHelper<TYPE>; \
+     typedef void (*QDestruct##TYPE)(TYPE *); \
+     static const QDestruct##TYPE qDestruct##TYPE = qMetaTypeDeleteHelper<TYPE>;
+#else
+#  define Q_DECL_METATYPE_HELPER(TYPE) \
+     typedef void *(*QConstruct##TYPE)(const TYPE *); \
+     static const QConstruct##TYPE qConstruct##TYPE = qMetaTypeConstructHelper<TYPE>; \
+     typedef void (*QDestruct##TYPE)(TYPE *); \
+     static const QDestruct##TYPE qDestruct##TYPE = qMetaTypeDeleteHelper<TYPE>; \
+     typedef void (*QSave##TYPE)(QDataStream &, const TYPE *); \
+     static const QSave##TYPE qSave##TYPE = qMetaTypeSaveHelper<TYPE>; \
+     typedef void (*QLoad##TYPE)(QDataStream &, TYPE *); \
+     static const QLoad##TYPE qLoad##TYPE = qMetaTypeLoadHelper<TYPE>;
+#endif
+
+#ifdef QT3_SUPPORT
+Q_DECL_METATYPE_HELPER(QColorGroup)
+#endif
+Q_DECL_METATYPE_HELPER(QFont)
+Q_DECL_METATYPE_HELPER(QPixmap)
+Q_DECL_METATYPE_HELPER(QBrush)
+Q_DECL_METATYPE_HELPER(QColor)
+Q_DECL_METATYPE_HELPER(QPalette)
+#ifndef QT_NO_ICON
+Q_DECL_METATYPE_HELPER(QIcon)
+#endif
+Q_DECL_METATYPE_HELPER(QImage)
+Q_DECL_METATYPE_HELPER(QPolygon)
+Q_DECL_METATYPE_HELPER(QRegion)
+Q_DECL_METATYPE_HELPER(QBitmap)
+#ifndef QT_NO_CURSOR
+Q_DECL_METATYPE_HELPER(QCursor)
+#endif
+Q_DECL_METATYPE_HELPER(QSizePolicy)
+#ifndef QT_NO_SHORTCUT
+Q_DECL_METATYPE_HELPER(QKeySequence)
+#endif
+Q_DECL_METATYPE_HELPER(QPen)
+Q_DECL_METATYPE_HELPER(QTextLength)
+Q_DECL_METATYPE_HELPER(QTextFormat)
+Q_DECL_METATYPE_HELPER(QMatrix)
+Q_DECL_METATYPE_HELPER(QTransform)
+#ifndef QT_NO_MATRIX4X4
+Q_DECL_METATYPE_HELPER(QMatrix4x4)
+#endif
+#ifndef QT_NO_VECTOR2D
+Q_DECL_METATYPE_HELPER(QVector2D)
+#endif
+#ifndef QT_NO_VECTOR3D
+Q_DECL_METATYPE_HELPER(QVector3D)
+#endif
+#ifndef QT_NO_VECTOR4D
+Q_DECL_METATYPE_HELPER(QVector4D)
+#endif
+#ifndef QT_NO_QUATERNION
+Q_DECL_METATYPE_HELPER(QQuaternion)
+#endif
+
+#ifdef QT_NO_DATASTREAM
+#  define Q_IMPL_METATYPE_HELPER(TYPE) \
+     { reinterpret_cast<QMetaType::Constructor>(qConstruct##TYPE), \
+       reinterpret_cast<QMetaType::Destructor>(qDestruct##TYPE) }
+#else
+#  define Q_IMPL_METATYPE_HELPER(TYPE) \
+     { reinterpret_cast<QMetaType::Constructor>(qConstruct##TYPE), \
+       reinterpret_cast<QMetaType::Destructor>(qDestruct##TYPE), \
+       reinterpret_cast<QMetaType::SaveOperator>(qSave##TYPE), \
+       reinterpret_cast<QMetaType::LoadOperator>(qLoad##TYPE) \
+     }
+#endif
+
+static const QMetaTypeGuiHelper qVariantGuiHelper[] = {
+#ifdef QT3_SUPPORT
+    Q_IMPL_METATYPE_HELPER(QColorGroup),
+#else
+    {0, 0, 0, 0},
+#endif
+    Q_IMPL_METATYPE_HELPER(QFont),
+    Q_IMPL_METATYPE_HELPER(QPixmap),
+    Q_IMPL_METATYPE_HELPER(QBrush),
+    Q_IMPL_METATYPE_HELPER(QColor),
+    Q_IMPL_METATYPE_HELPER(QPalette),
+#ifdef QT_NO_ICON
+    {0, 0, 0, 0},
+#else
+    Q_IMPL_METATYPE_HELPER(QIcon),
+#endif
+    Q_IMPL_METATYPE_HELPER(QImage),
+    Q_IMPL_METATYPE_HELPER(QPolygon),
+    Q_IMPL_METATYPE_HELPER(QRegion),
+    Q_IMPL_METATYPE_HELPER(QBitmap),
+#ifdef QT_NO_CURSOR
+    {0, 0, 0, 0},
+#else
+    Q_IMPL_METATYPE_HELPER(QCursor),
+#endif
+    Q_IMPL_METATYPE_HELPER(QSizePolicy),
+#ifdef QT_NO_SHORTCUT
+    {0, 0, 0, 0},
+#else
+    Q_IMPL_METATYPE_HELPER(QKeySequence),
+#endif
+    Q_IMPL_METATYPE_HELPER(QPen),
+    Q_IMPL_METATYPE_HELPER(QTextLength),
+    Q_IMPL_METATYPE_HELPER(QTextFormat),
+    Q_IMPL_METATYPE_HELPER(QMatrix),
+    Q_IMPL_METATYPE_HELPER(QTransform),
+#ifndef QT_NO_MATRIX4X4
+    Q_IMPL_METATYPE_HELPER(QMatrix4x4),
+#else
+    {0, 0, 0, 0},
+#endif
+#ifndef QT_NO_VECTOR2D
+    Q_IMPL_METATYPE_HELPER(QVector2D),
+#else
+    {0, 0, 0, 0},
+#endif
+#ifndef QT_NO_VECTOR3D
+    Q_IMPL_METATYPE_HELPER(QVector3D),
+#else
+    {0, 0, 0, 0},
+#endif
+#ifndef QT_NO_VECTOR4D
+    Q_IMPL_METATYPE_HELPER(QVector4D),
+#else
+    {0, 0, 0, 0},
+#endif
+#ifndef QT_NO_QUATERNION
+    Q_IMPL_METATYPE_HELPER(QQuaternion)
+#else
+    {0, 0, 0, 0}
+#endif
+};
+
+static const QVariant::Handler *qt_guivariant_last_handler = 0;
+int qRegisterGuiVariant()
+{
+    qt_guivariant_last_handler = QVariant::handler;
+    QVariant::handler = &qt_gui_variant_handler;
+    qMetaTypeGuiHelper = qVariantGuiHelper;
+    return 1;
+}
+Q_CONSTRUCTOR_FUNCTION(qRegisterGuiVariant)
+
+int qUnregisterGuiVariant()
+{
+    QVariant::handler = qt_guivariant_last_handler;
+    qMetaTypeGuiHelper = 0;
+    return 1;
+}
+Q_DESTRUCTOR_FUNCTION(qUnregisterGuiVariant)
+
+QT_END_NAMESPACE