/**************************************************************************** | |
** | |
** 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$ | |
** GNU Lesser General Public License Usage | |
** 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. | |
** | |
** GNU General Public License Usage | |
** Alternatively, this file may be used under the terms of the GNU General | |
** Public License version 3.0 as published by the Free Software Foundation | |
** and appearing in the file LICENSE.GPL included in the packaging of this | |
** file. Please review the following information to ensure the GNU General | |
** Public License version 3.0 requirements will be met: | |
** http://www.gnu.org/copyleft/gpl.html. | |
** | |
** Other Usage | |
** Alternatively, this file may be used in accordance with the terms and | |
** conditions contained in a signed written agreement between you and Nokia. | |
** | |
** | |
** | |
** | |
** | |
** $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 |