src/gui/kernel/qguivariant.cpp File Reference

#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 "qmatrix.h"
#include "qpalette.h"
#include "qpen.h"
#include "qpixmap.h"
#include "qpolygon.h"
#include "qregion.h"
#include "qsizepolicy.h"
#include "qtextformat.h"
#include "private/qvariant_p.h"

Include dependency graph for qguivariant.cpp:

Go to the source code of this file.

Classes

struct  QMetaTypeGuiHelper

Defines

#define Q_VARIANT_DECL_IMPORT
#define Q_DECL_METATYPE_HELPER(TYPE)
#define Q_IMPL_METATYPE_HELPER(TYPE)

Functions

Q_CORE_EXPORT const QVariant::Handler * qcoreVariantHandler ()
static void construct (QVariant::Private *x, const void *copy)
static void clear (QVariant::Private *d)
static bool isNull (const QVariant::Private *d)
static bool compare (const QVariant::Private *a, const QVariant::Private *b)
static bool convert (const QVariant::Private *d, QVariant::Type t, void *result, bool *ok)
static void streamDebug (QDebug dbg, const QVariant &v)
int qRegisterGuiVariant ()

Variables

const QVariant::Handler qt_gui_variant_handler
Q_VARIANT_DECL_IMPORT const
QMetaTypeGuiHelper * 		qMetaTypeGuiHelper
static const QMetaTypeGuiHelper qVariantGuiHelper []

Define Documentation

#define Q_DECL_METATYPE_HELPER ( TYPE   ) 

Value:

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>;

Definition at line 532 of file qguivariant.cpp.

#define Q_IMPL_METATYPE_HELPER ( TYPE   ) 

Value:

{ reinterpret_cast<QMetaType::Constructor>(qConstruct##TYPE), \
       reinterpret_cast<QMetaType::Destructor>(qDestruct##TYPE), \
       reinterpret_cast<QMetaType::SaveOperator>(qSave##TYPE), \
       reinterpret_cast<QMetaType::LoadOperator>(qLoad##TYPE) \
     }

Definition at line 575 of file qguivariant.cpp.

#define Q_VARIANT_DECL_IMPORT

Definition at line 520 of file qguivariant.cpp.

Function Documentation

static void clear ( QVariant::Private *  d  )  [static]

Definition at line 134 of file qguivariant.cpp.

References QVariant::Bitmap, QVariant::Brush, QVariant::Handler::clear, QVariant::Color, QVariant::Cursor, d, QVariant::Font, QVariant::Icon, QVariant::Image, QVariant::Invalid, QVariant::KeySequence, QVariant::Matrix, QVariant::Palette, QVariant::Pen, QVariant::Pixmap, QVariant::Polygon, qcoreVariantHandler(), QVariant::Region, QVariant::SizePolicy, QVariant::TextFormat, and QVariant::TextLength.

00135 {
00136     switch (d->type) {
00137     case QVariant::Bitmap:
00138         v_clear<QBitmap>(d);
00139         break;
00140     case QVariant::Cursor:
00141         v_clear<QCursor>(d);
00142         break;
00143     case QVariant::Region:
00144         v_clear<QRegion>(d);
00145         break;
00146     case QVariant::Polygon:
00147         v_clear<QPolygon>(d);
00148         break;
00149     case QVariant::Font:
00150         v_clear<QFont>(d);
00151         break;
00152     case QVariant::Pixmap:
00153         v_clear<QPixmap>(d);
00154         break;
00155     case QVariant::Image:
00156         v_clear<QImage>(d);
00157         break;
00158     case QVariant::Brush:
00159         v_clear<QBrush>(d);
00160         break;
00161     case QVariant::Color:
00162         v_clear<QColor>(d);
00163         break;
00164     case QVariant::Palette:
00165         v_clear<QPalette>(d);
00166         break;
00167 #ifdef QT3_SUPPORT
00168     case QVariant::ColorGroup:
00169         v_clear<QColorGroup>(d);
00170         break;
00171 #endif
00172 #ifndef QT_NO_ICON
00173     case QVariant::Icon:
00174         v_clear<QIcon>(d);
00175         break;
00176 #endif
00177     case QVariant::Matrix:
00178         v_clear<QMatrix>(d);
00179         break;
00180     case QVariant::TextFormat:
00181         v_clear<QTextFormat>(d);
00182         break;
00183     case QVariant::TextLength:
00184         v_clear<QTextLength>(d);
00185         break;
00186     case QVariant::SizePolicy:
00187         v_clear<QSizePolicy>(d);
00188         break;
00189 #ifndef QT_NO_SHORTCUT
00190     case QVariant::KeySequence:
00191         v_clear<QKeySequence>(d);
00192         break;
00193 #endif
00194     case QVariant::Pen:
00195         v_clear<QPen>(d);
00196         break;
00197     default:
00198         qcoreVariantHandler()->clear(d);
00199         return;
00200     }
00201 
00202     d->type = QVariant::Invalid;
00203     d->is_null = true;
00204     d->is_shared = false;
00205 }

Here is the call graph for this function:

static bool compare ( const QVariant::Private *  a,
const QVariant::Private *  b 
) [static]

Definition at line 249 of file qguivariant.cpp.

References a, b, QVariant::Bitmap, QVariant::Brush, QVariant::Color, QVariant::Handler::compare, QVariant::Cursor, QVariant::Font, QVariant::Icon, QVariant::Image, QVariant::KeySequence, QVariant::Matrix, QVariant::Palette, QVariant::Pen, QVariant::Pixmap, QVariant::Polygon, qcoreVariantHandler(), QVariant::Region, QVariant::SizePolicy, QVariant::TextFormat, and QVariant::TextLength.

00250 {
00251     Q_ASSERT(a->type == b->type);
00252     switch(a->type) {
00253     case QVariant::Cursor:
00254 #ifndef QT_NO_CURSOR
00255         return v_cast<QCursor>(a)->shape() == v_cast<QCursor>(b)->shape();
00256 #endif
00257     case QVariant::Bitmap:
00258         return v_cast<QBitmap>(a)->serialNumber()
00259             == v_cast<QBitmap>(b)->serialNumber();
00260     case QVariant::Polygon:
00261         return *v_cast<QPolygon>(a) == *v_cast<QPolygon>(b);
00262     case QVariant::Region:
00263         return *v_cast<QRegion>(a) == *v_cast<QRegion>(b);
00264     case QVariant::Font:
00265         return *v_cast<QFont>(a) == *v_cast<QFont>(b);
00266     case QVariant::Pixmap:
00267         return v_cast<QPixmap>(a)->serialNumber() == v_cast<QPixmap>(b)->serialNumber();
00268     case QVariant::Image:
00269         return *v_cast<QImage>(a) == *v_cast<QImage>(b);
00270     case QVariant::Brush:
00271         return *v_cast<QBrush>(a) == *v_cast<QBrush>(b);
00272     case QVariant::Color:
00273         return *v_cast<QColor>(a) == *v_cast<QColor>(b);
00274     case QVariant::Palette:
00275         return *v_cast<QPalette>(a) == *v_cast<QPalette>(b);
00276 #ifdef QT3_SUPPORT
00277     case QVariant::ColorGroup:
00278         return *v_cast<QColorGroup>(a) == *v_cast<QColorGroup>(b);
00279 #endif
00280 #ifndef QT_NO_ICON
00281     case QVariant::Icon:
00282         return false; // #### FIXME
00283 #endif
00284     case QVariant::Matrix:
00285         return *v_cast<QMatrix>(a) == *v_cast<QMatrix>(b);
00286     case QVariant::TextFormat:
00287         return *v_cast<QTextFormat>(a) == *v_cast<QTextFormat>(b);
00288     case QVariant::TextLength:
00289         return *v_cast<QTextLength>(a) == *v_cast<QTextLength>(b);
00290     case QVariant::SizePolicy:
00291         return *v_cast<QSizePolicy>(a) == *v_cast<QSizePolicy>(b);
00292 #ifndef QT_NO_SHORTCUT
00293     case QVariant::KeySequence:
00294         return *v_cast<QKeySequence>(a) == *v_cast<QKeySequence>(b);
00295 #endif
00296     case QVariant::Pen:
00297         return *v_cast<QPen>(a) == *v_cast<QPen>(b);
00298     default:
00299         break;
00300     }
00301     return qcoreVariantHandler()->compare(a, b);
00302 }

Here is the call graph for this function:

static void construct ( QVariant::Private *  x,
const void *  copy 
) [static]

Definition at line 54 of file qguivariant.cpp.

References QVariant::Bitmap, QVariant::Brush, QVariant::Color, QVariant::Handler::construct, QVariant::Cursor, QVariant::Font, QVariant::Icon, QVariant::Image, QVariant::KeySequence, QVariant::Matrix, QVariant::Palette, QVariant::Pen, QVariant::Pixmap, QVariant::Polygon, qcoreVariantHandler(), QVariant::Region, QVariant::SizePolicy, QVariant::TextFormat, QVariant::TextLength, and x.

00055 {
00056     switch (x->type) {
00057     case QVariant::Bitmap:
00058         v_construct<QBitmap>(x, copy);
00059         break;
00060     case QVariant::Region:
00061         v_construct<QRegion>(x, copy);
00062         break;
00063     case QVariant::Polygon:
00064         v_construct<QPolygon>(x, copy);
00065         break;
00066     case QVariant::Font:
00067         v_construct<QFont>(x, copy);
00068         break;
00069     case QVariant::Pixmap:
00070         v_construct<QPixmap>(x, copy);
00071         break;
00072     case QVariant::Image:
00073         v_construct<QImage>(x, copy);
00074         break;
00075     case QVariant::Brush:
00076         v_construct<QBrush>(x, copy);
00077         break;
00078     case QVariant::Color:
00079         v_construct<QColor>(x, copy);
00080         break;
00081     case QVariant::Palette:
00082         v_construct<QPalette>(x, copy);
00083         break;
00084 #ifdef QT3_SUPPORT
00085     case QVariant::ColorGroup:
00086         v_construct<QColorGroup>(x, copy);
00087         break;
00088 #endif
00089 #ifndef QT_NO_ICON
00090     case QVariant::Icon:
00091         v_construct<QIcon>(x, copy);
00092         break;
00093 #endif
00094     case QVariant::Matrix:
00095         v_construct<QMatrix>(x, copy);
00096         break;
00097     case QVariant::TextFormat:
00098         v_construct<QTextFormat>(x, copy);
00099         break;
00100     case QVariant::TextLength:
00101         v_construct<QTextLength>(x, copy);
00102         break;
00103 #ifndef QT_NO_SHORTCUT
00104     case QVariant::KeySequence:
00105         v_construct<QKeySequence>(x, copy);
00106         break;
00107 #endif
00108     case QVariant::Pen:
00109         v_construct<QPen>(x, copy);
00110         break;
00111     case QVariant::SizePolicy:
00112         v_construct<QSizePolicy>(x, copy);
00113         break;
00114 #ifndef QT_NO_CURSOR
00115     case QVariant::Cursor:
00116         v_construct<QCursor>(x, copy);
00117         break;
00118 #endif
00119     case 62: {
00120         // small 'trick' to let a QVariant(Qt::blue) create a variant
00121         // of type QColor
00122         x->type = QVariant::Color;
00123         QColor color(*reinterpret_cast<const Qt::GlobalColor *>(copy));
00124         v_construct<QColor>(x, &color);
00125         break;
00126     }
00127     default:
00128         qcoreVariantHandler()->construct(x, copy);
00129         return;
00130     }
00131     x->is_null = !copy;
00132 }

Here is the call graph for this function:

static bool convert ( const QVariant::Private *  d,
QVariant::Type  t,
void *  result,
bool *  ok 
) [static]

Definition at line 306 of file qguivariant.cpp.

References QVariant::Bitmap, QVariant::Brush, QVariant::ByteArray, QVariant::Color, QVariant::Handler::convert, d, QVariant::Font, QPixmap::fromImage(), QBitmap::fromImage(), QString::fromLatin1(), QFont::fromString(), QVariant::Image, QVariant::Int, QVariant::KeySequence, name, QVariant::Pixmap, qcoreVariantHandler(), Qt::SolidPattern, QVariant::String, Qt::TexturePattern, and toString().

00308 {
00309     switch (t) {
00310     case QVariant::ByteArray:
00311         if (d->type == QVariant::Color) {
00312             *static_cast<QByteArray *>(result) = v_cast<QColor>(d)->name().toLatin1();
00313             return true;
00314         }
00315         break;
00316     case QVariant::String: {
00317         QString *str = static_cast<QString *>(result);
00318         switch (d->type) {
00319 #ifndef QT_NO_SHORTCUT
00320         case QVariant::KeySequence:
00321             *str = QString(*v_cast<QKeySequence>(d));
00322             return true;
00323 #endif
00324         case QVariant::Font:
00325             *str = v_cast<QFont>(d)->toString();
00326             return true;
00327         case QVariant::Color:
00328             *str = v_cast<QColor>(d)->name();
00329             return true;
00330         default:
00331             break;
00332         }
00333         break;
00334     }
00335     case QVariant::Pixmap:
00336         if (d->type == QVariant::Image) {
00337             *static_cast<QPixmap *>(result) = QPixmap::fromImage(*v_cast<QImage>(d));
00338             return true;
00339         } else if (d->type == QVariant::Bitmap) {
00340             *static_cast<QPixmap *>(result) = *v_cast<QBitmap>(d);
00341             return true;
00342         } else if (d->type == QVariant::Brush) {
00343             if (v_cast<QBrush>(d)->style() == Qt::TexturePattern) {
00344                 *static_cast<QPixmap *>(result) = v_cast<QBrush>(d)->texture();
00345                 return true;
00346             }
00347         }
00348         break;
00349     case QVariant::Image:
00350         if (d->type == QVariant::Pixmap) {
00351             *static_cast<QImage *>(result) = v_cast<QPixmap>(d)->toImage();
00352             return true;
00353         } else if (d->type == QVariant::Bitmap) {
00354             *static_cast<QImage *>(result) = v_cast<QBitmap>(d)->toImage();
00355             return true;
00356         }
00357         break;
00358     case QVariant::Bitmap:
00359         if (d->type == QVariant::Pixmap) {
00360             *static_cast<QBitmap *>(result) = *v_cast<QPixmap>(d);
00361             return true;
00362         } else if (d->type == QVariant::Image) {
00363             *static_cast<QBitmap *>(result) = QBitmap::fromImage(*v_cast<QImage>(d));
00364             return true;
00365         }
00366         break;
00367 #ifndef QT_NO_SHORTCUT
00368     case QVariant::Int:
00369         if (d->type == QVariant::KeySequence) {
00370             *static_cast<int *>(result) = (int)(*(v_cast<QKeySequence>(d)));
00371             return true;
00372         }
00373         break;
00374 #endif
00375     case QVariant::Font:
00376         if (d->type == QVariant::String) {
00377             QFont *f = static_cast<QFont *>(result);
00378             f->fromString(*v_cast<QString>(d));
00379             return true;
00380         }
00381         break;
00382     case QVariant::Color:
00383         if (d->type == QVariant::String) {
00384             static_cast<QColor *>(result)->setNamedColor(*v_cast<QString>(d));
00385             return true;
00386         } else if (d->type == QVariant::ByteArray) {
00387             static_cast<QColor *>(result)->setNamedColor(QString::fromLatin1(
00388                                 *v_cast<QByteArray>(d)));
00389             return true;
00390         } else if (d->type == QVariant::Brush) {
00391             if (v_cast<QBrush>(d)->style() == Qt::SolidPattern) {
00392                 *static_cast<QColor *>(result) = v_cast<QBrush>(d)->color();
00393                 return true;
00394             }
00395         }
00396         break;
00397     case QVariant::Brush:
00398         if (d->type == QVariant::Color) {
00399             *static_cast<QBrush *>(result) = QBrush(*v_cast<QColor>(d));
00400             return true;
00401         } else if (d->type == QVariant::Pixmap) {
00402             *static_cast<QBrush *>(result) = QBrush(*v_cast<QPixmap>(d));
00403             return true;
00404         }
00405         break;
00406 #ifndef QT_NO_SHORTCUT
00407     case QVariant::KeySequence: {
00408         QKeySequence *seq = static_cast<QKeySequence *>(result);
00409         switch (d->type) {
00410         case QVariant::String:
00411             *seq = QKeySequence(*v_cast<QString>(d));
00412             return true;
00413         case QVariant::Int:
00414             *seq = QKeySequence(d->data.i);
00415             return true;
00416         default:
00417             break;
00418         }
00419     }
00420 #endif
00421     default:
00422         break;
00423     }
00424     return qcoreVariantHandler()->convert(d, t, result, ok);
00425 }

Here is the call graph for this function:

static bool isNull ( const QVariant::Private *  d  )  [static]

Definition at line 208 of file qguivariant.cpp.

References QVariant::Bitmap, QVariant::Brush, QVariant::Color, QVariant::Cursor, d, QVariant::Font, QVariant::Icon, QVariant::Image, isEmpty(), isNull(), QVariant::Handler::isNull, QVariant::KeySequence, QVariant::Matrix, QVariant::Palette, QVariant::Pen, QVariant::Pixmap, QVariant::Polygon, qcoreVariantHandler(), QVariant::Region, QVariant::SizePolicy, QVariant::StringList, QVariant::TextFormat, and QVariant::TextLength.

00209 {
00210     switch(d->type) {
00211     case QVariant::Bitmap:
00212         return v_cast<QBitmap>(d)->isNull();
00213     case QVariant::Region:
00214         return v_cast<QRegion>(d)->isEmpty();
00215     case QVariant::Polygon:
00216         return v_cast<QPolygon>(d)->isEmpty();
00217     case QVariant::Pixmap:
00218         return v_cast<QPixmap>(d)->isNull();
00219     case QVariant::Image:
00220         return v_cast<QImage>(d)->isNull();
00221 #ifndef QT_NO_ICON
00222     case QVariant::Icon:
00223         return v_cast<QIcon>(d)->isNull();
00224 #endif
00225     case QVariant::Matrix:
00226     case QVariant::TextFormat:
00227     case QVariant::TextLength:
00228     case QVariant::Cursor:
00229     case QVariant::StringList:
00230     case QVariant::Font:
00231     case QVariant::Brush:
00232     case QVariant::Color:
00233     case QVariant::Palette:
00234 #ifdef QT3_SUPPORT
00235     case QVariant::ColorGroup:
00236 #endif
00237     case QVariant::SizePolicy:
00238 #ifndef QT_NO_SHORTCUT
00239     case QVariant::KeySequence:
00240 #endif
00241     case QVariant::Pen:
00242         break;
00243     default:
00244         return qcoreVariantHandler()->isNull(d);
00245     }
00246     return d->is_null;
00247 }

Here is the call graph for this function:

Q_CORE_EXPORT const QVariant::Handler* qcoreVariantHandler (  ) 

Definition at line 1027 of file qvariant.cpp.

References qt_kernel_variant_handler.

Referenced by clear(), compare(), construct(), convert(), isNull(), and streamDebug().

01028 {
01029     return &qt_kernel_variant_handler;
01030 }

int qRegisterGuiVariant (  ) 

Definition at line 620 of file qguivariant.cpp.

References QVariant::handler, qMetaTypeGuiHelper, qt_gui_variant_handler, and qVariantGuiHelper.

Referenced by QApplicationPrivate::initialize().

00621 {
00622     QVariant::handler = &qt_gui_variant_handler;
00623     qMetaTypeGuiHelper = qVariantGuiHelper;
00624 
00625     return 1;
00626 }

static void streamDebug ( QDebug  dbg,
const QVariant &  v 
) [static]

Definition at line 428 of file qguivariant.cpp.

References QVariant::Bitmap, QVariant::Brush, QVariant::Color, QVariant::Cursor, QVariant::Handler::debugStream, QVariant::Font, QVariant::Icon, QVariant::Image, QVariant::KeySequence, QVariant::Matrix, QDebug::nospace(), QVariant::Palette, QVariant::Pen, QVariant::Pixmap, QVariant::Polygon, qcoreVariantHandler(), QVariant::Region, QVariant::SizePolicy, and QVariant::type().

00429 {
00430     switch(v.type()) {
00431     case QVariant::Cursor:
00432 #ifndef QT_NO_CURSOR
00433 //        dbg.nospace() << qvariant_cast<QCursor>(v); //FIXME
00434 #endif
00435         break;
00436     case QVariant::Bitmap:
00437 //        dbg.nospace() << qvariant_cast<QBitmap>(v); //FIXME
00438         break;
00439     case QVariant::Polygon:
00440         dbg.nospace() << qvariant_cast<QPolygon>(v);
00441         break;
00442     case QVariant::Region:
00443         dbg.nospace() << qvariant_cast<QRegion>(v);
00444         break;
00445     case QVariant::Font:
00446 //        dbg.nospace() << qvariant_cast<QFont>(v);  //FIXME
00447         break;
00448     case QVariant::Matrix:
00449         dbg.nospace() << qvariant_cast<QMatrix>(v);
00450         break;
00451     case QVariant::Pixmap:
00452 //        dbg.nospace() << qvariant_cast<QPixmap>(v); //FIXME
00453         break;
00454     case QVariant::Image:
00455 //        dbg.nospace() << qvariant_cast<QImage>(v); //FIXME
00456         break;
00457     case QVariant::Brush:
00458         dbg.nospace() << qvariant_cast<QBrush>(v);
00459         break;
00460     case QVariant::Color:
00461         dbg.nospace() << qvariant_cast<QColor>(v);
00462         break;
00463     case QVariant::Palette:
00464 //        dbg.nospace() << qvariant_cast<QPalette>(v); //FIXME
00465         break;
00466 #ifndef QT_NO_ICON
00467     case QVariant::Icon:
00468 //        dbg.nospace() << qvariant_cast<QIcon>(v); // FIXME
00469         break;
00470 #endif
00471     case QVariant::SizePolicy:
00472 //        dbg.nospace() << qvariant_cast<QSizePolicy>(v); //FIXME
00473         break;
00474 #ifndef QT_NO_SHORTCUT
00475     case QVariant::KeySequence:
00476         dbg.nospace() << qvariant_cast<QKeySequence>(v);
00477         break;
00478 #endif
00479     case QVariant::Pen:
00480         dbg.nospace() << qvariant_cast<QPen>(v);
00481         break;
00482     default:
00483         qcoreVariantHandler()->debugStream(dbg, v);
00484         break;
00485     }
00486 }

Here is the call graph for this function:

Variable Documentation

Q_VARIANT_DECL_IMPORT const QMetaTypeGuiHelper* qMetaTypeGuiHelper

Definition at line 319 of file qmetatype.cpp.

Referenced by QMetaType::construct(), QMetaType::destroy(), QMetaType::load(), qRegisterGuiVariant(), and QMetaType::save().

const QVariant::Handler qt_gui_variant_handler

Initial value:

 {
    construct,
    clear,
    isNull,

    0,
    0,

    compare,
    convert,
    0,

    streamDebug



}

Definition at line 489 of file qguivariant.cpp.

Referenced by qRegisterGuiVariant().

const QMetaTypeGuiHelper qVariantGuiHelper[] [static]

Definition at line 583 of file qguivariant.cpp.

Referenced by qRegisterGuiVariant().

Generated on Thu Mar 15 13:27:09 2007 for Qt 4.2 User's Guide by  doxygen 1.5.1