Removed unnecessary and/or TDE-unrelated code.r14.0.7

Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
Signed-off-by: Slávek Banko <slavek.banko@axis.cz>

1 files changed, 0 insertions, 4972 deletions

diff --git a/tqtinterface/qt4/src/kernel/tqvariant.cpp b/tqtinterface/qt4/src/kernel/tqvariant.cpp
deleted file mode 100644
index 90a2afd..0000000
--- a/tqtinterface/qt4/src/kernel/tqvariant.cpp
+++ /dev/null
@@ -1,4972 +0,0 @@
-/****************************************************************************
-**
-** Implementation of TQVariant class
-**
-** Created : 990414
-**
-** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
-**
-** This file is part of the kernel module of the TQt GUI Toolkit.
-**
-** This file may be used under the terms of the GNU General
-** Public License versions 2.0 or 3.0 as published by the Free
-** Software Foundation and appearing in the files LICENSE.GPL2
-** and LICENSE.GPL3 included in the packaging of this file.
-** Alternatively you may (at your option) use any later version
-** of the GNU General Public License if such license has been
-** publicly approved by Trolltech ASA (or its successors, if any)
-** and the KDE Free TQt Foundation.
-**
-** Please review the following information to ensure GNU General
-** Public Licensing requirements will be met:
-** http://trolltech.com/products/qt/licenses/licensing/opensource/.
-** If you are unsure which license is appropriate for your use, please
-** review the following information:
-** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
-** or contact the sales department at sales@trolltech.com.
-**
-** This file may be used under the terms of the Q Public License as
-** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
-** included in the packaging of this file.  Licensees holding valid TQt
-** Commercial licenses may use this file in accordance with the TQt
-** Commercial License Agreement provided with the Software.
-**
-** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
-** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
-** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
-** herein.
-**
-**********************************************************************/
-
-#include <float.h>
-
-#include "tqvariant.h"
-#ifndef TQT_NO_VARIANT
-#include "tqstring.h"
-#include "tqcstring.h"
-#include "tqfont.h"
-#include "tqpixmap.h"
-#include "tqimage.h"
-#include "tqbrush.h"
-#include "tqpoint.h"
-#include "tqrect.h"
-#include "tqsize.h"
-#include "tqcolor.h"
-#include "tqpalette.h"
-#include "tqiconset.h"
-#include "tqdatastream.h"
-#include "tqregion.h"
-#include "tqpointarray.h"
-#include "tqbitmap.h"
-#include "tqcursor.h"
-#include "tqdatetime.h"
-#include "tqsizepolicy.h"
-#include "tqshared.h"
-#include "tqbitarray.h"
-#include "tqkeysequence.h"
-#include "tqpen.h"
-
-#ifdef USE_QT4
-
-#define IconSet Icon
-#define CString ByteArray
-#define PointArray Polygon
-#define ColorGroup 63
-
-/*!
-    Constructs a copy of the variant, \a p, passed as the argument to
-    this constructor. Usually this is a deep copy, but a shallow copy
-    is made if the stored data type is explicitly shared, as e.g.
-    TQImage is.
-*/
-TQVariant::TQVariant( const QVariant& p )
- : QVariant(p)
-{
-//     p.d.ref();
-//     d = p.d;
-}
-
-#ifndef TQT_NO_DATASTREAM
-/*!
-    Reads the variant from the data stream, \a s.
-*/
-TQVariant::TQVariant( TQDataStream& s )
-{
-    s >> *this;
-}
-#endif //TQT_NO_DATASTREAM
-
-/*!
-    Constructs a new variant with a string value, \a val.
-*/
-TQVariant::TQVariant( const TQString& val )
- : QVariant(val)
-{
-//     d.type = String;
-//     d.data.ptr = new TQString( val );
-}
-
-/*!
-    Constructs a new variant with a C-string value, \a val.
-
-    If you want to modify the TQCString after you've passed it to this
-    constructor, we recommend passing a deep copy (see
-    TQCString::copy()).
-*/
-TQVariant::TQVariant( const TQCString& val )
-{
-    d.type = CString;
-    d.data.ptr = new TQCString( val );
-}
-
-/*!
-    Constructs a new variant with a C-string value of \a val if \a val
-    is non-null. The variant creates a deep copy of \a val.
-
-    If \a val is null, the resulting variant has type Invalid.
-*/
-TQVariant::TQVariant( const char* val )
-{
-    if ( val == 0 )
-	return;
-    d.type = CString;
-    d.data.ptr = new TQCString( val );
-}
-
-#ifndef TQT_NO_STRINGLIST
-/*!
-    Constructs a new variant with a string list value, \a val.
-*/
-TQVariant::TQVariant( const TQStringList& val )
-{
-    d.type = StringList;
-    d.data.ptr = new TQStringList( val );
-    d.is_null = FALSE;
-}
-#endif // TQT_NO_STRINGLIST
-
-#ifndef TQT_NO_TEMPLATE_VARIANT
-/*!
-    Constructs a new variant with a map of TQVariants, \a val.
-*/
-TQVariant::TQVariant( const TQMap<TQString,TQVariant>& val )
-{
-    d.type = Map;
-    d.data.ptr = new TQMap<TQString,TQVariant>( val );
-    d.is_null = FALSE;
-}
-#endif
-/*!
-    Constructs a new variant with a font value, \a val.
-*/
-TQVariant::TQVariant( const TQFont& val )
-{
-    d.type = Font;
-    d.data.ptr = new TQFont( val );
-    d.is_null = FALSE;
-}
-
-/*!
-    Constructs a new variant with a pixmap value, \a val.
-*/
-TQVariant::TQVariant( const TQPixmap& val )
-{
-    d.type = Pixmap;
-    d.data.ptr = new TQPixmap( val );
-}
-
-
-/*!
-    Constructs a new variant with an image value, \a val.
-
-    Because TQImage is explicitly shared, you may need to pass a deep
-    copy to the variant using TQImage::copy(), e.g. if you intend
-    changing the image you've passed later on.
-*/
-TQVariant::TQVariant( const TQImage& val )
-{
-    d.type = Image;
-    d.data.ptr = new TQImage( val );
-}
-
-/*!
-    Constructs a new variant with a brush value, \a val.
-*/
-TQVariant::TQVariant( const TQBrush& val )
-{
-    d.type = Brush;
-    d.data.ptr = new TQBrush( val );
-    d.is_null = FALSE;
-}
-
-/*!
-    Constructs a new variant with a point value, \a val.
-*/
-TQVariant::TQVariant( const TQPoint& val )
-{
-    d.type = Point;
-    d.data.ptr = new TQPoint( val );
-}
-
-/*!
-    Constructs a new variant with a rect value, \a val.
-*/
-TQVariant::TQVariant( const TQRect& val )
-{
-    d.type = Rect;
-    d.data.ptr = new TQRect( val );
-}
-
-/*!
-    Constructs a new variant with a size value, \a val.
-*/
-TQVariant::TQVariant( const TQSize& val )
-{
-    d.type = Size;
-    d.data.ptr = new TQSize( val );
-}
-
-/*!
-    Constructs a new variant with a color value, \a val.
-*/
-TQVariant::TQVariant( const TQColor& val )
-{
-    d.type = Color;
-    d.data.ptr = new TQColor( val );
-    d.is_null = FALSE;
-}
-
-#ifndef TQT_NO_PALETTE
-/*!
-    Constructs a new variant with a color palette value, \a val.
-*/
-TQVariant::TQVariant( const TQPalette& val )
-{
-    d.type = Palette;
-    d.data.ptr = new TQPalette( val );
-    d.is_null = FALSE;
-}
-
-/*!
-    Constructs a new variant with a color group value, \a val.
-*/
-TQVariant::TQVariant( const TQColorGroup& val )
-{
-    d.type = ColorGroup;
-    d.data.ptr = new TQColorGroup( val );
-    d.is_null = FALSE;
-}
-#endif //TQT_NO_PALETTE
-#ifndef TQT_NO_ICONSET
-/*!
-    Constructs a new variant with an icon set value, \a val.
-*/
-TQVariant::TQVariant( const TQIconSet& val )
-{
-    d.type = IconSet;
-    d.data.ptr = new TQIconSet( val );
-}
-#endif //TQT_NO_ICONSET
-/*!
-    Constructs a new variant with a region value, \a val.
-*/
-TQVariant::TQVariant( const TQRegion& val )
-{
-    d.type = Region;
-    // ## Force a detach
-    d.data.ptr = new TQRegion( val );
-    ((TQRegion*)d.data.ptr)->translate( 0, 0 );
-}
-
-/*!
-    Constructs a new variant with a bitmap value, \a val.
-*/
-TQVariant::TQVariant( const TQBitmap& val )
-{
-    d.type = Bitmap;
-    d.data.ptr = new TQBitmap( val );
-}
-
-/*!
-    Constructs a new variant with a cursor value, \a val.
-*/
-TQVariant::TQVariant( const TQCursor& val )
-{
-    d.type = Cursor;
-    d.data.ptr = new TQCursor( val );
-    d.is_null = FALSE;
-}
-
-/*!
-    Constructs a new variant with a point array value, \a val.
-
-    Because TQPointArray is explicitly shared, you may need to pass a
-    deep copy to the variant using TQPointArray::copy(), e.g. if you
-    intend changing the point array you've passed later on.
-*/
-TQVariant::TQVariant( const TQPointArray& val )
-{
-    d.type = PointArray;
-    d.data.ptr = new TQPointArray( val );
-}
-
-/*!
-    Constructs a new variant with a date value, \a val.
-*/
-TQVariant::TQVariant( const TQDate& val )
-{
-    d.type = Date;
-    d.data.ptr = new TQDate( val );
-}
-
-/*!
-    Constructs a new variant with a time value, \a val.
-*/
-TQVariant::TQVariant( const TQTime& val )
-{
-    d.type = Time;
-    d.data.ptr = new TQTime( val );
-}
-
-/*!
-    Constructs a new variant with a date/time value, \a val.
-*/
-TQVariant::TQVariant( const TQDateTime& val )
-{
-    d.type = DateTime;
-    d.data.ptr = new TQDateTime( val );
-}
-
-/*!
-    Constructs a new variant with a bytearray value, \a val.
-*/
-TQVariant::TQVariant( const TQByteArray& val )
-{
-    d.type = ByteArray;
-    d.data.ptr = new TQByteArray( val );
-}
-
-/*!
-    Constructs a new variant with a bitarray value, \a val.
-*/
-TQVariant::TQVariant( const TQBitArray& val )
-{
-    d.type = BitArray;
-    d.data.ptr = new TQBitArray( val );
-}
-
-#ifndef TQT_NO_ACCEL
-
-/*!
-    Constructs a new variant with a key sequence value, \a val.
-*/
-TQVariant::TQVariant( const TQKeySequence& val )
-{
-    d.type = KeySequence;
-    d.data.ptr = new TQKeySequence( val );
-    d.is_null = FALSE;
-}
-
-#endif
-
-/*!
-    Constructs a new variant with a pen value, \a val.
-*/
-TQVariant::TQVariant( const TQPen& val )
-{
-    d.type = Pen;
-    d.data.ptr = new TQPen( val );
-}
-
-#if 0
-
-/*!
-    Constructs a new variant with an integer value, \a val.
-*/
-TQVariant::TQVariant( int val )
-{
-    d = new Private;
-    d->typ = Int;
-    d->value.i = val;
-    d->is_null = FALSE;
-}
-
-/*!
-    Constructs a new variant with an unsigned integer value, \a val.
-*/
-TQVariant::TQVariant( uint val )
-{
-    d = new Private;
-    d->typ = UInt;
-    d->value.u = val;
-    d->is_null = FALSE;
-}
-
-/*!
-    Constructs a new variant with a long long integer value, \a val.
-*/
-TQVariant::TQVariant( TQ_LLONG val )
-{
-    d = new Private;
-    d->typ = LongLong;
-    d->value.ll = val;
-    d->is_null = FALSE;
-}
-
-/*!
-    Constructs a new variant with an unsigned long long integer value, \a val.
-*/
-
-TQVariant::TQVariant( TQ_ULLONG val )
-{
-    d = new Private;
-    d->typ = ULongLong;
-    d->value.ull = val;
-    d->is_null = FALSE;
-}
-
-/*!
-    Constructs a new variant with a boolean value, \a val. The integer
-    argument is a dummy, necessary for compatibility with some
-    compilers.
-*/
-TQVariant::TQVariant( bool val, int )
-{ // this is the comment that does NOT name said compiler.
-    d = new Private;
-    d->typ = Bool;
-    d->value.b = val;
-    d->is_null = FALSE;
-}
-
-
-/*!
-    Constructs a new variant with a floating point value, \a val.
-*/
-TQVariant::TQVariant( double val )
-{
-    d = new Private;
-    d->typ = Double;
-    d->value.d = val;
-    d->is_null = FALSE;
-}
-
-#endif
-
-#ifndef TQT_NO_TEMPLATE_VARIANT
-/*!
-    Constructs a new variant with a list value, \a val.
-*/
-TQVariant::TQVariant( const TQValueList<TQVariant>& val )
-{
-    d.type = List;
-    d.data.ptr = new TQValueList<TQVariant>( val );
-    d.is_null = FALSE;
-}
-#endif
-
-/*!
-    Constructs a new variant with a size policy value, \a val.
-*/
-TQVariant::TQVariant( TQSizePolicy val )
-{
-//     d = new Private;
-    d.type = SizePolicy;
-//     d.value.ptr = new TQSizePolicy( val );
-    d.data.ptr = new TQSizePolicy( val );
-    d.is_null = FALSE;
-}
-
-/*!
-    Assigns the value of the variant \a variant to this variant.
-
-    This is a deep copy of the variant, but note that if the variant
-    holds an explicitly shared type such as TQImage, a shallow copy is
-    performed.
-
-    Directly taken from Qt4 qvariant.cpp
-*/
-// TQVariant& TQVariant::operator= ( const QVariant& variant )
-// {
-// // 	if (this == &variant)
-// // 		return *this;
-// // 
-// // 	clear();
-// // 	if (variant.d.is_shared) {
-// // 		variant.d.data.shared->ref.ref();
-// // 		d = variant.d;
-// // 	} else if (variant.d.type > Char && variant.d.type < UserType) {
-// // 		d.type = variant.d.type;
-// // 		handler->construct(&d, variant.constData());
-// // 		d.is_null = variant.d.is_null;
-// // 	} else {
-// // 		d = variant.d;
-// // 	}
-// // 	
-// // 	return *this;
-// 
-// 	return QVariant::operator=(variant);
-// }
-
-/*!
-    Returns the variant as a TQFont if the variant can be cast to Font;
-    otherwise returns the application's default font.
-
-  \sa asFont(), canCast()
-*/
-const TQFont TQVariant::toFont() const
-{
-    switch ( type() ) {
-//     case CString:
-    case ByteArray:
-    case String:
-	{
-	    TQFont fnt;
-	    fnt.fromString( toString() );
-	    return fnt;
-	}
-    case Font:
-	return *((TQFont*)d.data.ptr);
-    default:
-	return TQFont();
-    }
-}
-
-#define TQ_VARIANT_AS( f ) TQ##f& TQVariant::as##f() \
-{ \
-    bool b = isNull(); \
-    if ( d.type != f ) \
-	*this = TQVariant( to##f() ); \
-    else \
-	detach(); \
-    d.is_null = b; \
-    return *((TQ##f*)d.data.ptr); \
-}
-
-TQ_VARIANT_AS(String)
-TQ_VARIANT_AS(CString)
-#ifndef TQT_NO_STRINGLIST
-TQ_VARIANT_AS(StringList)
-#endif
-TQ_VARIANT_AS(Font)
-TQ_VARIANT_AS(Pixmap)
-TQ_VARIANT_AS(Image)
-TQ_VARIANT_AS(Brush)
-TQ_VARIANT_AS(Point)
-TQ_VARIANT_AS(Rect)
-TQ_VARIANT_AS(Size)
-TQ_VARIANT_AS(Color)
-#ifndef TQT_NO_PALETTE
-TQ_VARIANT_AS(Palette)
-TQ_VARIANT_AS(ColorGroup)
-#endif
-#ifndef TQT_NO_ICONSET
-TQ_VARIANT_AS(IconSet)
-#endif
-TQ_VARIANT_AS(PointArray)
-TQ_VARIANT_AS(Bitmap)
-TQ_VARIANT_AS(Region)
-TQ_VARIANT_AS(Cursor)
-TQ_VARIANT_AS(SizePolicy)
-TQ_VARIANT_AS(Date)
-TQ_VARIANT_AS(Time)
-TQ_VARIANT_AS(DateTime)
-TQ_VARIANT_AS(ByteArray)
-TQ_VARIANT_AS(BitArray)
-#ifndef TQT_NO_ACCEL
-TQ_VARIANT_AS(KeySequence)
-#endif
-TQ_VARIANT_AS(Pen)
-
-// #if 0
-
-/*!
-    Returns the variant's value as int reference.
-*/
-int& TQVariant::asInt()
-{
-    detach();
-    if ( d.type != Int ) {
-	int i = toInt();
-	bool b = isNull();
-// 	d.clear();
- 	d.data.i = i;
-	d.type = Int;
-	d.is_null = b;
-    }
-    return d.data.i;
-}
-
-/*!
-    Returns the variant's value as unsigned int reference.
-*/
-uint& TQVariant::asUInt()
-{
-    detach();
-    if ( d.type != UInt ) {
-	uint u = toUInt();
-	bool b = isNull();
-// 	d.clear();
-	d.data.u = u;
-	d.type = UInt;
-	d.is_null = b;
-    }
-    return d.data.u;
-}
-
-/*!
-    Returns the variant's value as long long reference.
-*/
-TQ_LLONG& TQVariant::asLongLong()
-{
-    detach();
-    if ( d.type != LongLong ) {
-	TQ_LLONG ll = toLongLong();
-	bool b = isNull();
-// 	d.clear();
- 	d.data.ll = ll;
-	d.type = LongLong;
-	d.is_null = b;
-    }
-    return d.data.ll;
-}
-
-/*!
-    Returns the variant's value as unsigned long long reference.
-*/
-TQ_ULLONG& TQVariant::asULongLong()
-{
-    detach();
-    if ( d.type != ULongLong ) {
-	TQ_ULLONG ull = toULongLong();
-	bool b = isNull();
-// 	d.clear();
- 	d.data.ull = ull;
-	d.type = ULongLong;
-	d.is_null = b;
-    }
-    return d.data.ull;
-}
-
-/*!
-    Returns the variant's value as bool reference.
-*/
-bool& TQVariant::asBool()
-{
-    detach();
-    if ( d.type != Bool ) {
-	bool b = toBool();
-	bool nb = isNull();
-// 	d.clear();
-	d.data.b = b;
-	d.type = Bool;
-	d.is_null = nb;
-    }
-    return d.data.b;
-}
-
-/*!
-    Returns the variant's value as double reference.
-*/
-double& TQVariant::asDouble()
-{
-    detach();
-    if ( d.type != Double ) {
-	double dbl = toDouble();
-	bool b = isNull();
-// 	d.clear();
-	d.data.d = dbl;
-	d.type = Double;
-	d.is_null = b;
-    }
-    return d.data.d;
-}
-
-// #endif
-
-#ifndef TQT_NO_TEMPLATE_VARIANT
-/*!
-    Returns the variant's value as variant list reference.
-
-    Note that if you want to iterate over the list, you should iterate
-    over a copy, e.g.
-    \code
-    TQValueList<TQVariant> list = myVariant.asList();
-    TQValueList<TQVariant>::Iterator it = list.begin();
-    while( it != list.end() ) {
-	myProcessing( *it );
-	++it;
-    }
-    \endcode
-*/
-TQValueList<TQVariant>& TQVariant::asList()
-{
-    bool b = isNull();
-    if ( d.type != List )
-	*this = TQVariant( toList() );
-    else
-	detach();
-    d.is_null = b;
-    return *((TQValueList<TQVariant>*)d.data.ptr);
-}
-
-/*!
-    Returns the variant's value as variant map reference.
-
-    Note that if you want to iterate over the map, you should iterate
-    over a copy, e.g.
-    \code
-    TQMap<TQString, TQVariant> map = myVariant.asMap();
-    TQMap<TQString, TQVariant>::Iterator it = map.begin();
-    while( it != map.end() ) {
-	myProcessing( *it );
-	++it;
-    }
-    \endcode
-*/
-TQMap<TQString, TQVariant>& TQVariant::asMap()
-{
-    bool b = isNull();
-    if ( d.type != Map )
-	*this = TQVariant( toMap() );
-    else
-	detach();
-    d.is_null = b;
-    return *((TQMap<TQString,TQVariant>*)d.data.ptr);
-}
-#endif
-
-/*!
-    Returns the variant as a TQString if the variant can be cast to
-    String, otherwise returns TQString::null.
-
-    \sa asString(), canCast()
-*/
-const TQString TQVariant::toString() const
-{
-//     switch( d.type ) {
-// //     case CString:
-// // 	return TQString::tqfromLatin1( toCString() );
-//     case Int:
-// 	return TQString::number( toInt() );
-//     case UInt:
-// 	return TQString::number( toUInt() );
-//     case LongLong:
-// 	return TQString::number( toLongLong() );
-//     case ULongLong:
-// 	return TQString::number( toULongLong() );
-//     case Double:
-// 	return TQString::number( toDouble(), 'g', DBL_DIG );
-// #if !defined(TQT_NO_SPRINTF) && !defined(TQT_NO_DATESTRING)
-//     case Date:
-// 	return toDate().toString( Qt::ISODate );
-//     case Time:
-// 	return toTime().toString( Qt::ISODate );
-//     case DateTime:
-// 	return toDateTime().toString( Qt::ISODate );
-// #endif
-//     case Bool:
-// 	return toInt() ? "true" : "false";
-// #ifndef TQT_NO_ACCEL
-//     case KeySequence:
-// 	return (TQString) *( (TQKeySequence*)d.data.ptr );
-// #endif
-//     case ByteArray:
-// 	return TQString( *((TQByteArray*)d.data.ptr) );
-//     case Font:
-// 	return toFont().toString();
-//     case Color:
-// 	return toColor().name();
-//     case String:
-// 	return *(static_cast<TQString*>(d.data.ptr));
-//     default:
-// 	return TQString();
-//     }
-
-// 	const QString& ref = QVariant::toString();
-// 	return *(static_cast<const TQString*>(&ref));
-	return TQString(QVariant::toString());
-}
-/*!
-    Returns the variant as a TQCString if the variant can be cast to a
-    CString; otherwise returns 0.
-
-    \sa asCString(), canCast()
-*/
-const TQCString TQVariant::toCString() const
-{
-    switch( d.type ) {
-    case CString: return *((TQCString*)d.data.ptr);
-    case String: return ((TQString*)d.data.ptr)->latin1();
-    default: {
-	if (!canCast(String))
-	    return 0;
-	TQString c = toString();
-	return TQCString(c.latin1());
-    }
-    }
-}
-
-
-#ifndef TQT_NO_STRINGLIST
-/*!
-    Returns the variant as a TQStringList if the variant has type()
-    StringList or List of a type that can be converted to TQString;
-    otherwise returns an empty list.
-
-    Note that if you want to iterate over the list, you should iterate
-    over a copy, e.g.
-    \code
-    TQStringList list = myVariant.toStringList();
-    TQStringList::Iterator it = list.begin();
-    while( it != list.end() ) {
-	myProcessing( *it );
-	++it;
-    }
-    \endcode
-
-    \sa asStringList()
-*/
-const TQStringList TQVariant::toStringList() const
-{
-    switch ( d.type ) {
-    case StringList:
-	return *((TQStringList*)d.data.ptr);
-#ifndef TQT_NO_TEMPLATE_VARIANT
-    case List:
-	{
-	    TQStringList lst;
-	    TQValueList<TQVariant>::ConstIterator it = listBegin();
-	    TQValueList<TQVariant>::ConstIterator end = listEnd();
-	    while( it != end ) {
-		TQString tmp = (*it).toString();
-		++it;
-		lst.append( tmp );
-	    }
-	    return lst;
-	}
-#endif
-    default:
-	return TQStringList();
-    }
-}
-#endif //TQT_NO_STRINGLIST
-
-#ifndef TQT_NO_TEMPLATE_VARIANT
-/*!
-    Returns the variant as a TQMap<TQString,TQVariant> if the variant has
-    type() Map; otherwise returns an empty map.
-
-    Note that if you want to iterate over the map, you should iterate
-    over a copy, e.g.
-    \code
-    TQMap<TQString, TQVariant> map = myVariant.toMap();
-    TQMap<TQString, TQVariant>::Iterator it = map.begin();
-    while( it != map.end() ) {
-	myProcessing( *it );
-	++it;
-    }
-    \endcode
-
-    \sa asMap()
-*/
-const TQMap<TQString, TQVariant> TQVariant::toMap() const
-{
-    if ( d.type != Map )
-	return TQMap<TQString,TQVariant>();
-
-    return *((TQMap<TQString,TQVariant>*)d.data.ptr);
-}
-#endif
-
-/*!
-    Returns the variant as a TQPixmap if the variant has type() Pixmap;
-    otherwise returns a null pixmap.
-
-    \sa asPixmap()
-*/
-const TQPixmap TQVariant::toPixmap() const
-{
-    if ( d.type != Pixmap )
-	return TQPixmap();
-
-    return *((TQPixmap*)d.data.ptr);
-}
-
-/*!
-    Returns the variant as a TQImage if the variant has type() Image;
-    otherwise returns a null image.
-
-    \sa asImage()
-*/
-const TQImage TQVariant::toImage() const
-{
-    if ( d.type != Image )
-	return TQImage();
-
-    return *((TQImage*)d.data.ptr);
-}
-
-/*!
-    Returns the variant as a TQBrush if the variant has type() Brush;
-    otherwise returns a default brush (with all black colors).
-
-    \sa asBrush()
-*/
-const TQBrush TQVariant::toBrush() const
-{
-    if( d.type != Brush )
-	return TQBrush();
-
-    return *((TQBrush*)d.data.ptr);
-}
-
-/*!
-    Returns the variant as a TQPoint if the variant has type() Point;
-    otherwise returns a point (0, 0).
-
-    \sa asPoint()
-*/
-const TQPoint TQVariant::toPoint() const
-{
-    if ( d.type != Point )
-	return TQPoint();
-
-    return *((TQPoint*)d.data.ptr);
-}
-
-/*!
-    Returns the variant as a TQRect if the variant has type() Rect;
-    otherwise returns an empty rectangle.
-
-    \sa asRect()
-*/
-const TQRect TQVariant::toRect() const
-{
-    if ( d.type != Rect )
-	return TQRect();
-
-    return *((TQRect*)d.data.ptr);
-}
-
-/*!
-    Returns the variant as a TQSize if the variant has type() Size;
-    otherwise returns an invalid size.
-
-    \sa asSize()
-*/
-const TQSize TQVariant::toSize() const
-{
-    if ( d.type != Size )
-	return TQSize();
-
-    return *((TQSize*)d.data.ptr);
-}
-
-/*!
-    Returns the variant as a TQColor if the variant can be cast to Color;
-    otherwise returns an invalid color.
-
-    \sa asColor(), canCast()
-*/
-const TQColor TQVariant::toColor() const
-{
-    switch ( d.type ) {
-    case ByteArray:
-//     case CString:
-    case String:
-    {
-	TQColor col;
-	col.setNamedColor( toString() );
-	return col;
-    }
-    case Color:
-	return *((TQColor*)d.data.ptr);
-    default:
-	return TQColor();
-    }
-}
-#ifndef TQT_NO_PALETTE
-/*!
-    Returns the variant as a TQPalette if the variant has type()
-    Palette; otherwise returns a completely black palette.
-
-    \sa asPalette()
-*/
-const TQPalette TQVariant::toPalette() const
-{
-    if ( d.type != Palette )
-	return TQPalette();
-
-    return *((TQPalette*)d.data.ptr);
-}
-
-/*!
-    Returns the variant as a TQColorGroup if the variant has type()
-    ColorGroup; otherwise returns a completely black color group.
-
-    \sa asColorGroup()
-*/
-const TQColorGroup TQVariant::toColorGroup() const
-{
-    if ( d.type != ColorGroup )
-	return TQColorGroup();
-
-    return *((TQColorGroup*)d.data.ptr);
-}
-#endif //TQT_NO_PALETTE
-#ifndef TQT_NO_ICONSET
-/*!
-    Returns the variant as a TQIconSet if the variant has type()
-    IconSet; otherwise returns an icon set of null pixmaps.
-
-    \sa asIconSet()
-*/
-const TQIconSet TQVariant::toIconSet() const
-{
-    if ( d.type != IconSet )
-	return TQIconSet();
-
-    return *((TQIconSet*)d.data.ptr);
-}
-#endif //TQT_NO_ICONSET
-/*!
-    Returns the variant as a TQPointArray if the variant has type()
-    PointArray; otherwise returns an empty TQPointArray.
-
-    \sa asPointArray()
-*/
-const TQPointArray TQVariant::toPointArray() const
-{
-    if ( d.type != PointArray )
-	return TQPointArray();
-
-    return *((TQPointArray*)d.data.ptr);
-}
-
-/*!
-    Returns the variant as a TQBitmap if the variant has type() Bitmap;
-    otherwise returns a null TQBitmap.
-
-    \sa asBitmap()
-*/
-const TQBitmap TQVariant::toBitmap() const
-{
-    if ( d.type != Bitmap )
-	return TQBitmap();
-
-    return *((TQBitmap*)d.data.ptr);
-}
-
-/*!
-    Returns the variant as a TQRegion if the variant has type() Region;
-    otherwise returns an empty TQRegion.
-
-    \sa asRegion()
-*/
-const TQRegion TQVariant::toRegion() const
-{
-    if ( d.type != Region )
-	return TQRegion();
-
-    return *((TQRegion*)d.data.ptr);
-}
-
-/*!
-    Returns the variant as a TQCursor if the variant has type() Cursor;
-    otherwise returns the default arrow cursor.
-
-    \sa asCursor()
-*/
-const TQCursor TQVariant::toCursor() const
-{
-#ifndef TQT_NO_CURSOR
-    if ( d.type != Cursor )
-	return TQCursor();
-#endif
-
-    return *((TQCursor*)d.data.ptr);
-}
-
-/*!
-    Returns the variant as a TQDate if the variant can be cast to Date;
-    otherwise returns an invalid date.
-
-    Note that if the type() is String, CString or ByteArray an invalid
-    date will be returned if the string cannot be parsed as a
-    Qt::ISODate format date.
-
-    \sa asDate(), canCast()
-*/
-const TQDate TQVariant::toDate() const
-{
-    switch ( d.type ) {
-    case Date:
-	return *((TQDate*)d.data.ptr);
-    case DateTime:
-	return TQT_TQDATE_OBJECT(((TQDateTime*)d.data.ptr)->date());
-#ifndef TQT_NO_DATESTRING
-    case String:
-	return TQT_TQDATE_OBJECT(TQDate::fromString( *((TQString*)d.data.ptr), Qt::ISODate ));
-//     case CString:
-    case ByteArray:
-	return TQT_TQDATE_OBJECT(TQDate::fromString(toString(), Qt::ISODate));
-#endif
-    default:
-	return TQDate();
-    }
-}
-
-/*!
-    Returns the variant as a TQTime if the variant can be cast to Time;
-    otherwise returns an invalid date.
-
-    Note that if the type() is String, CString or ByteArray an invalid
-    time will be returned if the string cannot be parsed as a
-    Qt::ISODate format time.
-
-    \sa asTime()
-*/
-const TQTime TQVariant::toTime() const
-{
-    switch ( d.type ) {
-    case Time:
-	return *((TQTime*)d.data.ptr);
-    case DateTime:
-	return TQT_TQTIME_OBJECT(((TQDateTime*)d.data.ptr)->time());
-#ifndef TQT_NO_DATESTRING
-    case String:
-	return  TQT_TQTIME_OBJECT(TQTime::fromString( *((TQString*)d.data.ptr), Qt::ISODate ));
-//     case CString:
-    case ByteArray:
-	return  TQT_TQTIME_OBJECT(TQTime::fromString(toString(), Qt::ISODate));
-#endif
-    default:
-	return TQTime();
-    }
-}
-
-/*!
-    Returns the variant as a TQDateTime if the variant can be cast to
-    DateTime; otherwise returns an invalid TQDateTime.
-
-    Note that if the type() is String, CString or ByteArray an invalid
-    TQDateTime will be returned if the string cannot be parsed as a
-    Qt::ISODate format date/time.
-
-    \sa asDateTime()
-*/
-const TQDateTime TQVariant::toDateTime() const
-{
-    switch ( d.type ) {
-    case DateTime:
-	return *((TQDateTime*)d.data.ptr);
-#ifndef TQT_NO_DATESTRING
-    case String:
-	return TQT_TQDATETIME_OBJECT(TQDateTime::fromString( *((TQString*)d.data.ptr), Qt::ISODate ));
-//     case CString:
-    case ByteArray:
-	return TQT_TQDATETIME_OBJECT(TQDateTime::fromString(toString(), Qt::ISODate));
-#endif
-    case Date:
-	return TQDateTime( *((TQDate*)d.data.ptr) );
-    default:
-	return TQDateTime();
-    }
-}
-
-/*!
-    Returns the variant as a TQByteArray if the variant can be cast to
-    a ByteArray; otherwise returns an empty bytearray.
-
-    \sa asByteArray(), canCast()
-*/
-const TQByteArray TQVariant::toByteArray() const
-{
-    switch(d.type) {
-    case ByteArray: return *((TQByteArray*)d.data.ptr);
-//     case CString: return *((TQByteArray*)d.data.ptr);
-    default: {
-	TQByteArray ret;
-	if (canCast(String)) {
-	    TQString c = toString();
-	    ret.duplicate(c.latin1(), c.length());
-	}
-	return ret;
-    }
-    }
-}
-
-/*!
-    Returns the variant as a TQBitArray if the variant has type()
-    BitArray; otherwise returns an empty bitarray.
-
-    \sa asBitArray()
-*/
-const TQBitArray TQVariant::toBitArray() const
-{
-    if ( d.type == BitArray )
-	return *((TQBitArray*)d.data.ptr);
-    return TQBitArray();
-}
-
-#ifndef TQT_NO_ACCEL
-
-/*!
-    Returns the variant as a TQKeySequence if the variant can be cast
-    to a KeySequence; otherwise returns an empty key sequence.
-
-    \sa asKeySequence(), canCast()
-*/
-const TQKeySequence TQVariant::toKeySequence() const
-{
-    switch ( d.type ) {
-    case KeySequence:
-	return *((TQKeySequence*)d.data.ptr);
-    case String:
-    case ByteArray:
-//     case CString:
-	return TQKeySequence( toString() );
-    case Int:
-    case UInt:
-    case Double:
-    case ULongLong:
-    case LongLong:
-	return TQKeySequence( toInt() );
-    default:
-	return TQKeySequence();
-    }
-}
-
-#endif // TQT_NO_ACCEL
-
-/*!
-    Returns the variant as a TQPen if the variant has type()
-    Pen; otherwise returns an empty TQPen.
-
-    \sa asPen()
-*/
-const TQPen TQVariant::toPen() const
-{
-    if ( d.type != Pen )
-	return TQPen();
-
-    return *((TQPen*)d.data.ptr);
-}
-
-#if 0
-
-/*!
-    Returns the variant as an int if the variant can be cast to Int;
-    otherwise returns 0.
-
-    If \a ok is non-null: \a *ok is set to TRUE if the value could be
-    converted to an int; otherwise \a *ok is set to FALSE.
-
-    \sa asInt(), canCast()
-*/
-int TQVariant::toInt( bool * ok ) const
-{
-    if ( ok )
-	*ok = canCast( Int );
-
-    switch ( d.type ) {
-    case String:
-	return ((TQString*)d.data.ptr)->toInt( ok );
-    case CString:
-    case ByteArray:
-	return ((TQCString*)d.data.ptr)->toInt( ok );
-    case Int:
-	return d.data.i;
-    case UInt:
-	return (int)d.data.u;
-    case LongLong:
-        return (int)d.data.ll;
-    case ULongLong:
-        return (int)d.data.ull;
-    case Double:
-	return (int)d.data.d;
-    case Bool:
-	return (int)d.data.b;
-#ifndef TQT_NO_ACCEL
-    case KeySequence:
-	return (int) *( (TQKeySequence*)d.data.ptr );
-#endif
-    default:
-	return 0;
-    }
-}
-
-/*!
-    Returns the variant as an unsigned int if the variant can be cast
-    to UInt; otherwise returns 0.
-
-    If \a ok is non-null: \a *ok is set to TRUE if the value could be
-    converted to an unsigned int; otherwise \a *ok is set to FALSE.
-
-    \sa asUInt(), canCast()
-*/
-uint TQVariant::toUInt( bool * ok ) const
-{
-    if ( ok )
-	*ok = canCast( UInt );
-
-    switch( d.type ) {
-    case String:
-	return ((TQString*)d.data.ptr)->toUInt( ok );
-    case CString:
-    case ByteArray:
-	return ((TQCString*)d.data.ptr)->toUInt( ok );
-    case Int:
-	return (uint)d.data.i;
-    case UInt:
-	return d.data.u;
-    case LongLong:
-        return (uint)d.data.ll;
-    case ULongLong:
-        return (uint)d.data.ull;
-    case Double:
-	return (uint)d.data.d;
-    case Bool:
-	return (uint)d.data.b;
-    default:
-	return 0;
-    }
-}
-
-/*!
-    Returns the variant as a long long int if the variant can be cast
-    to LongLong; otherwise returns 0.
-
-    If \a ok is non-null: \a *ok is set to TRUE if the value could be
-    converted to an int; otherwise \a *ok is set to FALSE.
-
-    \sa asLongLong(), canCast()
-*/
-TQ_LLONG TQVariant::toLongLong( bool * ok ) const
-{
-    if ( ok )
-	*ok = canCast( LongLong );
-
-    switch ( d.type ) {
-    case String:
-	return ((TQString*)d.data.ptr)->toLongLong( ok );
-    case CString:
-    case ByteArray:
-	return TQString(*(TQCString*)d.data.ptr).toLongLong(ok);
-    case Int:
-	return (TQ_LLONG)d.data.i;
-    case UInt:
-	return (TQ_LLONG)d.data.u;
-    case LongLong:
-	return d.data.ll;
-    case ULongLong:
-	return (TQ_LLONG)d.data.ull;
-    case Double:
-	return (TQ_LLONG)d.data.d;
-    case Bool:
-	return (TQ_LLONG)d.data.b;
-    default:
-	return 0;
-    }
-}
-
-/*!
-    Returns the variant as as an unsigned long long int if the variant
-    can be cast to ULongLong; otherwise returns 0.
-
-    If \a ok is non-null: \a *ok is set to TRUE if the value could be
-    converted to an int; otherwise \a *ok is set to FALSE.
-
-    \sa asULongLong(), canCast()
-*/
-TQ_ULLONG TQVariant::toULongLong( bool * ok ) const
-{
-    if ( ok )
-	*ok = canCast( ULongLong );
-
-    switch ( d.type ) {
-    case Int:
-	return (TQ_ULLONG)d.data.i;
-    case UInt:
-	return (TQ_ULLONG)d.data.u;
-    case LongLong:
-	return (TQ_ULLONG)d.data.ll;
-    case ULongLong:
-	return d.data.ull;
-    case Double:
-	return (TQ_ULLONG)d.data.d;
-    case Bool:
-	return (TQ_ULLONG)d.data.b;
-    case String:
-	return ((TQString*)d.data.ptr)->toULongLong( ok );
-    case CString:
-    case ByteArray:
-	return TQString(*(TQCString*)d.data.ptr).toULongLong(ok);
-    default:
-	return 0;
-    }
-}
-
-/*!
-    Returns the variant as a bool if the variant can be cast to Bool;
-    otherWise returns FALSE.
-
-    Returns TRUE if the variant has a numeric type and its value is
-    non-zero, or if the variant has type String, ByteArray or CString
-    and its lower-case content is not empty, "0" or "false"; otherwise
-    returns FALSE.
-
-    \sa asBool(), canCast()
-*/
-bool TQVariant::toBool() const
-{
-    switch( d.type ) {
-    case Bool:
-	return d.data.b;
-    case Double:
-	return d.data.d != 0.0;
-    case Int:
-	return d.data.i != 0;
-    case UInt:
-	return d.data.u != 0;
-    case LongLong:
-	return d.data.ll != 0;
-    case ULongLong:
-	return d.data.ull != 0;
-    case String:
-    case CString:
-    case ByteArray:
-	{
-	    TQString str = toString().lower();
-	    return !(str == "0" || str == "false" || str.isEmpty() );
-	}
-    default:
-	return FALSE;
-    }
-}
-
-/*!
-    Returns the variant as a double if the variant can be cast to
-    Double; otherwise returns 0.0.
-
-    If \a ok is non-null: \a *ok is set to TRUE if the value could be
-    converted to a double; otherwise \a *ok is set to FALSE.
-
-    \sa asDouble(), canCast()
-*/
-double TQVariant::toDouble( bool * ok ) const
-{
-    if ( ok )
-	*ok = canCast( Double );
-
-    switch ( d.type ) {
-    case String:
-	return ((TQString*)d.data.ptr)->toDouble( ok );
-    case CString:
-    case ByteArray:
-	return ((TQCString*)d.data.ptr)->toDouble( ok );
-    case Double:
-	return d.data.d;
-    case Int:
-	return (double)d.data.i;
-    case Bool:
-	return (double)d.data.b;
-    case UInt:
-	return (double)d.data.u;
-    case LongLong:
-	return (double)d.data.ll;
-    case ULongLong:
-#if defined(TQ_CC_MSVC) && !defined(TQ_CC_MSVC_NET)
-	return (double)(TQ_LLONG)d.data.ull;
-#else
-	return (double)d.data.ull;
-#endif
-    default:
-	return 0.0;
-    }
-}
-
-#endif
-
-#ifndef TQT_NO_TEMPLATE_VARIANT
-/*!
-    Returns the variant as a TQValueList<TQVariant> if the variant has
-    type() List or StringList; otherwise returns an empty list.
-
-    Note that if you want to iterate over the list, you should iterate
-    over a copy, e.g.
-    \code
-    TQValueList<TQVariant> list = myVariant.toList();
-    TQValueList<TQVariant>::Iterator it = list.begin();
-    while( it != list.end() ) {
-	myProcessing( *it );
-	++it;
-    }
-    \endcode
-
-    \sa asList()
-*/
-const TQValueList<TQVariant> TQVariant::toList() const
-{
-    if ( d.type == List )
-	return *((TQValueList<TQVariant>*)d.data.ptr);
-#ifndef TQT_NO_STRINGLIST
-    if ( d.type == StringList ) {
-	TQValueList<TQVariant> lst;
-	TQStringList::ConstIterator it = stringListBegin();
-	TQStringList::ConstIterator end = stringListEnd();
-	for( ; it != end; ++it )
-	    lst.append( TQVariant( *it ) );
-	return lst;
-    }
-#endif //TQT_NO_STRINGLIST
-    return TQValueList<TQVariant>();
-}
-#endif
-
-/*!
-    Returns the variant as a TQSizePolicy if the variant has type()
-    SizePolicy; otherwise returns an undefined (but legal) size
-    policy.
-*/
-
-TQSizePolicy TQVariant::toSizePolicy() const
-{
-    if ( d.type == SizePolicy )
-	return *((TQSizePolicy*)d.data.ptr);
-
-    return TQSizePolicy();
-}
-
-#else // USE_QT4
-
-#ifndef DBL_DIG
-#define DBL_DIG 10
-#endif //DBL_DIG
-
-// Uncomment to test for memory leaks or to run qt/test/qvariant/main.cpp
-// #define TQVARIANT_DEBUG
-
-
-static bool isNumeric(TQVariant::Type type)
-{
-    return (type == TQVariant::Int || type == TQVariant::UInt
-	    || type == TQVariant::Double || type == TQVariant::LongLong
-	    || type == TQVariant::ULongLong || type == TQVariant::Bool);
-}
-
-
-#ifdef TQVARIANT_DEBUG
-int qv_count = 0;
-int get_qv_count() { return qv_count; }
-#endif
-
-TQVariant::Private::Private()
-{
-#ifdef TQVARIANT_DEBUG
-    qv_count++;
-#endif
-    typ = TQVariant::Invalid;
-    is_null = TRUE;
-}
-
-TQVariant::Private::Private( Private* d )
-{
-#ifdef TQVARIANT_DEBUG
-    qv_count++;
-#endif
-
-    switch( d->typ )
-	{
-	case TQVariant::Invalid:
-	    break;
-	case TQVariant::Bitmap:
-	    value.ptr = new TQBitmap( *((TQBitmap*)d->value.ptr) );
-	    break;
-	case TQVariant::Region:
-	    value.ptr = new TQRegion( *((TQRegion*)d->value.ptr) );
-	    // ## Force a detach
-	    // ((TQRegion*)value.ptr)->translate( 0, 0 );
-	    break;
-	case TQVariant::PointArray:
-	    // TQPointArray is explicit shared
-	    value.ptr = new TQPointArray( *((TQPointArray*)d->value.ptr) );
-	    break;
-	case TQVariant::String:
-	    value.ptr = new TQString( *((TQString*)d->value.ptr) );
-	    break;
-	case TQVariant::CString:
-	    // TQCString is explicit shared
-	    value.ptr = new TQCString( *((TQCString*)d->value.ptr) );
-	    break;
-#ifndef TQT_NO_STRINGLIST
-	case TQVariant::StringList:
-	    value.ptr = new TQStringList( *((TQStringList*)d->value.ptr) );
-	    break;
-#endif //TQT_NO_STRINGLIST
-	case TQVariant::Font:
-	    value.ptr = new TQFont( *((TQFont*)d->value.ptr) );
-	    break;
-	case TQVariant::Pixmap:
-	    value.ptr = new TQPixmap( *((TQPixmap*)d->value.ptr) );
-	    break;
-	case TQVariant::Image:
-	    // TQImage is explicit shared
-	    value.ptr = new TQImage( *((TQImage*)d->value.ptr) );
-	    break;
-	case TQVariant::Brush:
-	    value.ptr = new TQBrush( *((TQBrush*)d->value.ptr) );
-	    // ## Force a detach
-	    // ((TQBrush*)value.ptr)->setColor( ((TQBrush*)value.ptr)->color() );
-	    break;
-	case TQVariant::Point:
-	    value.ptr = new TQPoint( *((TQPoint*)d->value.ptr) );
-	    break;
-	case TQVariant::Rect:
-	    value.ptr = new TQRect( *((TQRect*)d->value.ptr) );
-	    break;
-	case TQVariant::Size:
-	    value.ptr = new TQSize( *((TQSize*)d->value.ptr) );
-	    break;
-	case TQVariant::Color:
-	    value.ptr = new TQColor( *((TQColor*)d->value.ptr) );
-	    break;
-#ifndef TQT_NO_PALETTE
-	case TQVariant::Palette:
-	    value.ptr = new TQPalette( *((TQPalette*)d->value.ptr) );
-	    break;
-	case TQVariant::ColorGroup:
-	    value.ptr = new TQColorGroup( *((TQColorGroup*)d->value.ptr) );
-	    break;
-#endif
-#ifndef TQT_NO_ICONSET
-	case TQVariant::IconSet:
-	    value.ptr = new TQIconSet( *((TQIconSet*)d->value.ptr) );
-	    break;
-#endif
-#ifndef TQT_NO_TEMPLATE_VARIANT
-	case TQVariant::Map:
-	    value.ptr = new TQMap<TQString,TQVariant>( *((TQMap<TQString,TQVariant>*)d->value.ptr) );
-	    break;
-	case TQVariant::List:
-	    value.ptr = new TQValueList<TQVariant>( *((TQValueList<TQVariant>*)d->value.ptr) );
-	    break;
-#endif
-	case TQVariant::Date:
-	    value.ptr = new TQDate( *((TQDate*)d->value.ptr) );
-	    break;
-	case TQVariant::Time:
-	    value.ptr = new TQTime( *((TQTime*)d->value.ptr) );
-	    break;
-	case TQVariant::DateTime:
-	    value.ptr = new TQDateTime( *((TQDateTime*)d->value.ptr) );
-	    break;
-	case TQVariant::ByteArray:
-	    value.ptr = new TQByteArray( *((TQByteArray*)d->value.ptr) );
-	    break;
-	case TQVariant::BitArray:
-	    value.ptr = new TQBitArray( *((TQBitArray*)d->value.ptr) );
-	    break;
-#ifndef TQT_NO_ACCEL
-	case TQVariant::KeySequence:
-	    value.ptr = new TQKeySequence( *((TQKeySequence*)d->value.ptr) );
-	    break;
-#endif
-	case TQVariant::Pen:
-	    value.ptr = new TQPen( *((TQPen*)d->value.ptr) );
-	    break;
-	case TQVariant::Int:
-	    value.i = d->value.i;
-	    break;
-	case TQVariant::UInt:
-	    value.u = d->value.u;
-	    break;
-	case TQVariant::LongLong:
-	    value.ll = d->value.ll;
-	    break;
-	case TQVariant::ULongLong:
-	    value.ull = d->value.ull;
-	    break;
-	case TQVariant::Bool:
-	    value.b = d->value.b;
-	    break;
-	case TQVariant::Double:
-	    value.d = d->value.d;
-	    break;
-	case TQVariant::SizePolicy:
-	    value.ptr = new TQSizePolicy( *((TQSizePolicy*)d->value.ptr) );
-	    break;
-	case TQVariant::Cursor:
-	    value.ptr = new TQCursor( *((TQCursor*)d->value.ptr) );
-	    break;
-	default:
-	    TQ_ASSERT( 0 );
-	}
-
-    typ = d->typ;
-    is_null = d->is_null;
-}
-
-TQVariant::Private::~Private()
-{
-#ifdef TQVARIANT_DEBUG
-    qv_count--;
-#endif
-    clear();
-}
-
-void TQVariant::Private::clear()
-{
-    switch( typ )
-	{
-	case TQVariant::Bitmap:
-	    delete (TQBitmap*)value.ptr;
-	    break;
-	case TQVariant::Cursor:
-	    delete (TQCursor*)value.ptr;
-	    break;
-	case TQVariant::Region:
-	    delete (TQRegion*)value.ptr;
-	    break;
-	case TQVariant::PointArray:
-	    delete (TQPointArray*)value.ptr;
-	    break;
-	case TQVariant::String:
-	    delete (TQString*)value.ptr;
-	    break;
-	case TQVariant::CString:
-	    delete (TQCString*)value.ptr;
-	    break;
-#ifndef TQT_NO_STRINGLIST
-	case TQVariant::StringList:
-	    delete (TQStringList*)value.ptr;
-	    break;
-#endif //TQT_NO_STRINGLIST
-	case TQVariant::Font:
-	    delete (TQFont*)value.ptr;
-	    break;
-	case TQVariant::Pixmap:
-	    delete (TQPixmap*)value.ptr;
-	    break;
-	case TQVariant::Image:
-	    delete (TQImage*)value.ptr;
-	    break;
-	case TQVariant::Brush:
-	    delete (TQBrush*)value.ptr;
-	    break;
-	case TQVariant::Point:
-	    delete (TQPoint*)value.ptr;
-	    break;
-	case TQVariant::Rect:
-	    delete (TQRect*)value.ptr;
-	    break;
-	case TQVariant::Size:
-	    delete (TQSize*)value.ptr;
-	    break;
-	case TQVariant::Color:
-	    delete (TQColor*)value.ptr;
-	    break;
-#ifndef TQT_NO_PALETTE
-	case TQVariant::Palette:
-	    delete (TQPalette*)value.ptr;
-	    break;
-	case TQVariant::ColorGroup:
-	    delete (TQColorGroup*)value.ptr;
-	    break;
-#endif
-#ifndef TQT_NO_ICONSET
-	case TQVariant::IconSet:
-	    delete (TQIconSet*)value.ptr;
-	    break;
-#endif
-#ifndef TQT_NO_TEMPLATE_VARIANT
-	case TQVariant::Map:
-	    delete (TQMap<TQString,TQVariant>*)value.ptr;
-	    break;
-	case TQVariant::List:
-	    delete (TQValueList<TQVariant>*)value.ptr;
-	    break;
-#endif
-	case TQVariant::SizePolicy:
-	    delete (TQSizePolicy*)value.ptr;
-	    break;
-	case TQVariant::Date:
-	    delete (TQDate*)value.ptr;
-	    break;
-	case TQVariant::Time:
-	    delete (TQTime*)value.ptr;
-	    break;
-	case TQVariant::DateTime:
-	    delete (TQDateTime*)value.ptr;
-	    break;
-	case TQVariant::ByteArray:
-	    delete (TQByteArray*)value.ptr;
-	    break;
-	case TQVariant::BitArray:
-	    delete (TQBitArray*)value.ptr;
-	    break;
-#ifndef TQT_NO_ACCEL
-	case TQVariant::KeySequence:
-	    delete (TQKeySequence*)value.ptr;
-	    break;
-#endif
-	case TQVariant::Pen:
-	    delete (TQPen*)value.ptr;
-	    break;
-	case TQVariant::Invalid:
-	case TQVariant::Int:
-	case TQVariant::UInt:
-	case TQVariant::LongLong:
-	case TQVariant::ULongLong:
-	case TQVariant::Bool:
-	case TQVariant::Double:
-	    break;
-	}
-
-    typ = TQVariant::Invalid;
-    is_null = TRUE;
-}
-
-/*!
-    \class TQVariant tqvariant.h
-    \brief The TQVariant class acts like a union for the most common TQt data types.
-
-    \ingroup objectmodel
-    \ingroup misc
-    \mainclass
-
-    Because C++ forbids unions from including types that have
-    non-default constructors or destructors, most interesting TQt
-    classes cannot be used in unions. Without TQVariant, this would be
-    a problem for TQObject::property() and for database work, etc.
-
-    A TQVariant object holds a single value of a single type() at a
-    time. (Some type()s are multi-valued, for example a string list.)
-    You can find out what type, T, the variant holds, convert it to a
-    different type using one of the asT() functions, e.g. asSize(),
-    get its value using one of the toT() functions, e.g. toSize(), and
-    check whether the type can be converted to a particular type using
-    canCast().
-
-    The methods named toT() (for any supported T, see the \c Type
-    documentation for a list) are const. If you ask for the stored
-    type, they return a copy of the stored object. If you ask for a
-    type that can be generated from the stored type, toT() copies and
-    converts and leaves the object itself unchanged. If you ask for a
-    type that cannot be generated from the stored type, the result
-    depends on the type (see the function documentation for details).
-
-    Note that three data types supported by TQVariant are explicitly
-    shared, namely TQImage, TQPointArray, and TQCString, and in these
-    cases the toT() methods return a shallow copy. In almost all cases
-    you must make a deep copy of the returned values before modifying
-    them.
-
-    The asT() functions are not const. They do conversion like the
-    toT() methods, set the variant to hold the converted value, and
-    return a reference to the new contents of the variant.
-
-    Here is some example code to demonstrate the use of TQVariant:
-
-    \code
-    TQDataStream out(...);
-    TQVariant v(123);          // The variant now contains an int
-    int x = v.toInt();        // x = 123
-    out << v;                 // Writes a type tag and an int to out
-    v = TQVariant("hello");    // The variant now contains a TQCString
-    v = TQVariant(tr("hello"));// The variant now contains a TQString
-    int y = v.toInt();        // y = 0 since v cannot be converted to an int
-    TQString s = v.toString(); // s = tr("hello")  (see TQObject::tr())
-    out << v;                 // Writes a type tag and a TQString to out
-    ...
-    TQDataStream in(...);      // (opening the previously written stream)
-    in >> v;                  // Reads an Int variant
-    int z = v.toInt();        // z = 123
-    qDebug("Type is %s",      // prints "Type is int"
-	    v.typeName());
-    v.asInt() += 100;	      // The variant now hold the value 223.
-    v = TQVariant( TQStringList() );
-    v.asStringList().append( "Hello" );
-    \endcode
-
-    You can even store TQValueList<TQVariant>s and
-    TQMap<TQString,TQVariant>s in a variant, so you can easily construct
-    arbitrarily complex data structures of arbitrary types. This is
-    very powerful and versatile, but may prove less memory and speed
-    efficient than storing specific types in standard data structures.
-
-    TQVariant also supports the notion of NULL values, where you have a
-    defined type with no value set.
-    \code
-    TQVariant x, y( TQString() ), z( TQString("") );
-    x.asInt();
-    // x.isNull() == TRUE, y.isNull() == TRUE, z.isNull() == FALSE
-    \endcode
-
-    See the \link collection.html Collection Classes\endlink.
-*/
-
-/*!
-    \enum TQVariant::Type
-
-    This enum type defines the types of variable that a TQVariant can
-    contain.
-
-    \value Invalid  no type
-    \value BitArray  a TQBitArray
-    \value ByteArray  a TQByteArray
-    \value Bitmap  a TQBitmap
-    \value Bool  a bool
-    \value Brush  a TQBrush
-    \value Color  a TQColor
-    \value ColorGroup  a TQColorGroup
-    \value Cursor  a TQCursor
-    \value Date  a TQDate
-    \value DateTime  a TQDateTime
-    \value Double  a double
-    \value Font  a TQFont
-    \value IconSet  a TQIconSet
-    \value Image  a TQImage
-    \value Int  an int
-    \value KeySequence  a TQKeySequence
-    \value List  a TQValueList<TQVariant>
-    \value LongLong a long long
-    \value ULongLong an unsigned long long
-    \value Map  a TQMap<TQString,TQVariant>
-    \value Palette  a TQPalette
-    \value Pen  a TQPen
-    \value Pixmap  a TQPixmap
-    \value Point  a TQPoint
-    \value PointArray  a TQPointArray
-    \value Rect  a TQRect
-    \value Region  a TQRegion
-    \value Size  a TQSize
-    \value SizePolicy  a TQSizePolicy
-    \value String  a TQString
-    \value CString  a TQCString
-    \value StringList  a TQStringList
-    \value Time  a TQTime
-    \value UInt  an unsigned int
-
-    Note that TQt's definition of bool depends on the compiler.
-    \c tqglobal.h has the system-dependent definition of bool.
-*/
-
-/*!
-    Constructs an invalid variant.
-*/
-TQVariant::TQVariant()
-{
-    d = new Private;
-}
-
-/*!
-    Destroys the TQVariant and the contained object.
-
-    Note that subclasses that reimplement clear() should reimplement
-    the destructor to call clear(). This destructor calls clear(), but
-    because it is the destructor, TQVariant::clear() is called rather
-    than a subclass's clear().
-*/
-TQVariant::~TQVariant()
-{
-    if ( d->deref() )
-	delete d;
-}
-
-/*!
-    Constructs a copy of the variant, \a p, passed as the argument to
-    this constructor. Usually this is a deep copy, but a shallow copy
-    is made if the stored data type is explicitly shared, as e.g.
-    TQImage is.
-*/
-TQVariant::TQVariant( const TQVariant& p )
-{
-    p.d->ref();
-    d = p.d;
-}
-
-#ifndef TQT_NO_DATASTREAM
-/*!
-    Reads the variant from the data stream, \a s.
-*/
-TQVariant::TQVariant( TQDataStream& s )
-{
-    d = new Private;
-    s >> *this;
-}
-#endif //TQT_NO_DATASTREAM
-
-/*!
-    Constructs a new variant with a string value, \a val.
-*/
-TQVariant::TQVariant( const TQString& val )
-{
-    d = new Private;
-    d->typ = String;
-    d->value.ptr = new TQString( val );
-}
-
-/*!
-    Constructs a new variant with a C-string value, \a val.
-
-    If you want to modify the TQCString after you've passed it to this
-    constructor, we recommend passing a deep copy (see
-    TQCString::copy()).
-*/
-TQVariant::TQVariant( const TQCString& val )
-{
-    d = new Private;
-    d->typ = CString;
-    d->value.ptr = new TQCString( val );
-}
-
-/*!
-    Constructs a new variant with a C-string value of \a val if \a val
-    is non-null. The variant creates a deep copy of \a val.
-
-    If \a val is null, the resulting variant has type Invalid.
-*/
-TQVariant::TQVariant( const char* val )
-{
-    d = new Private;
-    if ( val == 0 )
-	return;
-    d->typ = CString;
-    d->value.ptr = new TQCString( val );
-}
-
-#ifndef TQT_NO_STRINGLIST
-/*!
-    Constructs a new variant with a string list value, \a val.
-*/
-TQVariant::TQVariant( const TQStringList& val )
-{
-    d = new Private;
-    d->typ = StringList;
-    d->value.ptr = new TQStringList( val );
-    d->is_null = FALSE;
-}
-#endif // TQT_NO_STRINGLIST
-
-#ifndef TQT_NO_TEMPLATE_VARIANT
-/*!
-    Constructs a new variant with a map of TQVariants, \a val.
-*/
-TQVariant::TQVariant( const TQMap<TQString,TQVariant>& val )
-{
-    d = new Private;
-    d->typ = Map;
-    d->value.ptr = new TQMap<TQString,TQVariant>( val );
-    d->is_null = FALSE;
-}
-#endif
-/*!
-    Constructs a new variant with a font value, \a val.
-*/
-TQVariant::TQVariant( const TQFont& val )
-{
-    d = new Private;
-    d->typ = Font;
-    d->value.ptr = new TQFont( val );
-    d->is_null = FALSE;
-}
-
-/*!
-    Constructs a new variant with a pixmap value, \a val.
-*/
-TQVariant::TQVariant( const TQPixmap& val )
-{
-    d = new Private;
-    d->typ = Pixmap;
-    d->value.ptr = new TQPixmap( val );
-}
-
-
-/*!
-    Constructs a new variant with an image value, \a val.
-
-    Because TQImage is explicitly shared, you may need to pass a deep
-    copy to the variant using TQImage::copy(), e.g. if you intend
-    changing the image you've passed later on.
-*/
-TQVariant::TQVariant( const TQImage& val )
-{
-    d = new Private;
-    d->typ = Image;
-    d->value.ptr = new TQImage( val );
-}
-
-/*!
-    Constructs a new variant with a brush value, \a val.
-*/
-TQVariant::TQVariant( const TQBrush& val )
-{
-    d = new Private;
-    d->typ = Brush;
-    d->value.ptr = new TQBrush( val );
-    d->is_null = FALSE;
-}
-
-/*!
-    Constructs a new variant with a point value, \a val.
-*/
-TQVariant::TQVariant( const TQPoint& val )
-{
-    d = new Private;
-    d->typ = Point;
-    d->value.ptr = new TQPoint( val );
-}
-
-/*!
-    Constructs a new variant with a rect value, \a val.
-*/
-TQVariant::TQVariant( const TQRect& val )
-{
-    d = new Private;
-    d->typ = Rect;
-    d->value.ptr = new TQRect( val );
-}
-
-/*!
-    Constructs a new variant with a size value, \a val.
-*/
-TQVariant::TQVariant( const TQSize& val )
-{
-    d = new Private;
-    d->typ = Size;
-    d->value.ptr = new TQSize( val );
-}
-
-/*!
-    Constructs a new variant with a color value, \a val.
-*/
-TQVariant::TQVariant( const TQColor& val )
-{
-    d = new Private;
-    d->typ = Color;
-    d->value.ptr = new TQColor( val );
-    d->is_null = FALSE;
-}
-
-#ifndef TQT_NO_PALETTE
-/*!
-    Constructs a new variant with a color palette value, \a val.
-*/
-TQVariant::TQVariant( const TQPalette& val )
-{
-    d = new Private;
-    d->typ = Palette;
-    d->value.ptr = new TQPalette( val );
-    d->is_null = FALSE;
-}
-
-/*!
-    Constructs a new variant with a color group value, \a val.
-*/
-TQVariant::TQVariant( const TQColorGroup& val )
-{
-    d = new Private;
-    d->typ = ColorGroup;
-    d->value.ptr = new TQColorGroup( val );
-    d->is_null = FALSE;
-}
-#endif //TQT_NO_PALETTE
-#ifndef TQT_NO_ICONSET
-/*!
-    Constructs a new variant with an icon set value, \a val.
-*/
-TQVariant::TQVariant( const TQIconSet& val )
-{
-    d = new Private;
-    d->typ = IconSet;
-    d->value.ptr = new TQIconSet( val );
-}
-#endif //TQT_NO_ICONSET
-/*!
-    Constructs a new variant with a region value, \a val.
-*/
-TQVariant::TQVariant( const TQRegion& val )
-{
-    d = new Private;
-    d->typ = Region;
-    // ## Force a detach
-    d->value.ptr = new TQRegion( val );
-    ((TQRegion*)d->value.ptr)->translate( 0, 0 );
-}
-
-/*!
-    Constructs a new variant with a bitmap value, \a val.
-*/
-TQVariant::TQVariant( const TQBitmap& val )
-{
-    d = new Private;
-    d->typ = Bitmap;
-    d->value.ptr = new TQBitmap( val );
-}
-
-/*!
-    Constructs a new variant with a cursor value, \a val.
-*/
-TQVariant::TQVariant( const TQCursor& val )
-{
-    d = new Private;
-    d->typ = Cursor;
-    d->value.ptr = new TQCursor( val );
-    d->is_null = FALSE;
-}
-
-/*!
-    Constructs a new variant with a point array value, \a val.
-
-    Because TQPointArray is explicitly shared, you may need to pass a
-    deep copy to the variant using TQPointArray::copy(), e.g. if you
-    intend changing the point array you've passed later on.
-*/
-TQVariant::TQVariant( const TQPointArray& val )
-{
-    d = new Private;
-    d->typ = PointArray;
-    d->value.ptr = new TQPointArray( val );
-}
-
-/*!
-    Constructs a new variant with a date value, \a val.
-*/
-TQVariant::TQVariant( const TQDate& val )
-{
-    d = new Private;
-    d->typ = Date;
-    d->value.ptr = new TQDate( val );
-}
-
-/*!
-    Constructs a new variant with a time value, \a val.
-*/
-TQVariant::TQVariant( const TQTime& val )
-{
-    d = new Private;
-    d->typ = Time;
-    d->value.ptr = new TQTime( val );
-}
-
-/*!
-    Constructs a new variant with a date/time value, \a val.
-*/
-TQVariant::TQVariant( const TQDateTime& val )
-{
-    d = new Private;
-    d->typ = DateTime;
-    d->value.ptr = new TQDateTime( val );
-}
-
-/*!
-    Constructs a new variant with a bytearray value, \a val.
-*/
-TQVariant::TQVariant( const TQByteArray& val )
-{
-    d = new Private;
-    d->typ = ByteArray;
-    d->value.ptr = new TQByteArray( val );
-}
-
-/*!
-    Constructs a new variant with a bitarray value, \a val.
-*/
-TQVariant::TQVariant( const TQBitArray& val )
-{
-    d = new Private;
-    d->typ = BitArray;
-    d->value.ptr = new TQBitArray( val );
-}
-
-#ifndef TQT_NO_ACCEL
-
-/*!
-    Constructs a new variant with a key sequence value, \a val.
-*/
-TQVariant::TQVariant( const TQKeySequence& val )
-{
-    d = new Private;
-    d->typ = KeySequence;
-    d->value.ptr = new TQKeySequence( val );
-    d->is_null = FALSE;
-}
-
-#endif
-
-/*!
-    Constructs a new variant with a pen value, \a val.
-*/
-TQVariant::TQVariant( const TQPen& val )
-{
-    d = new Private;
-    d->typ = Pen;
-    d->value.ptr = new TQPen( val );
-}
-
-/*!
-    Constructs a new variant with an integer value, \a val.
-*/
-TQVariant::TQVariant( int val )
-{
-    d = new Private;
-    d->typ = Int;
-    d->value.i = val;
-    d->is_null = FALSE;
-}
-
-/*!
-    Constructs a new variant with an unsigned integer value, \a val.
-*/
-TQVariant::TQVariant( uint val )
-{
-    d = new Private;
-    d->typ = UInt;
-    d->value.u = val;
-    d->is_null = FALSE;
-}
-
-/*!
-    Constructs a new variant with a long long integer value, \a val.
-*/
-TQVariant::TQVariant( TQ_LLONG val )
-{
-    d = new Private;
-    d->typ = LongLong;
-    d->value.ll = val;
-    d->is_null = FALSE;
-}
-
-/*!
-    Constructs a new variant with an unsigned long long integer value, \a val.
-*/
-
-TQVariant::TQVariant( TQ_ULLONG val )
-{
-    d = new Private;
-    d->typ = ULongLong;
-    d->value.ull = val;
-    d->is_null = FALSE;
-}
-
-/*!
-    Constructs a new variant with a boolean value, \a val. The integer
-    argument is a dummy, necessary for compatibility with some
-    compilers.
-*/
-TQVariant::TQVariant( bool val, int )
-{ // this is the comment that does NOT name said compiler.
-    d = new Private;
-    d->typ = Bool;
-    d->value.b = val;
-    d->is_null = FALSE;
-}
-
-
-/*!
-    Constructs a new variant with a floating point value, \a val.
-*/
-TQVariant::TQVariant( double val )
-{
-    d = new Private;
-    d->typ = Double;
-    d->value.d = val;
-    d->is_null = FALSE;
-}
-
-#ifndef TQT_NO_TEMPLATE_VARIANT
-/*!
-    Constructs a new variant with a list value, \a val.
-*/
-TQVariant::TQVariant( const TQValueList<TQVariant>& val )
-{
-    d = new Private;
-    d->typ = List;
-    d->value.ptr = new TQValueList<TQVariant>( val );
-    d->is_null = FALSE;
-}
-#endif
-
-/*!
-    Constructs a new variant with a size policy value, \a val.
-*/
-TQVariant::TQVariant( TQSizePolicy val )
-{
-    d = new Private;
-    d->typ = SizePolicy;
-    d->value.ptr = new TQSizePolicy( val );
-    d->is_null = FALSE;
-}
-
-/*!
-    Assigns the value of the variant \a variant to this variant.
-
-    This is a deep copy of the variant, but note that if the variant
-    holds an explicitly shared type such as TQImage, a shallow copy is
-    performed.
-*/
-TQVariant& TQVariant::operator= ( const TQVariant& variant )
-{
-    TQVariant& other = (TQVariant&)variant;
-
-    other.d->ref();
-    if ( d->deref() )
-	delete d;
-
-    d = other.d;
-
-    return *this;
-}
-
-/*!
-    \internal
-*/
-void TQVariant::detach()
-{
-    if ( d->count == 1 )
-	return;
-
-    d->deref();
-    d = new Private( d );
-}
-
-/*!
-    Returns the name of the type stored in the variant. The returned
-    strings describe the C++ datatype used to store the data: for
-    example, "TQFont", "TQString", or "TQValueList<TQVariant>". An Invalid
-    variant returns 0.
-*/
-const char* TQVariant::typeName() const
-{
-    return typeToName( (Type) d->typ );
-}
-
-/*!
-    Convert this variant to type Invalid and free up any resources
-    used.
-*/
-void TQVariant::clear()
-{
-    if ( d->count > 1 )
-    {
-	d->deref();
-	d = new Private;
-	return;
-    }
-
-    d->clear();
-}
-
-/* Attention!
-
-   For dependency reasons, this table is duplicated in tqmoc.y. If you
-   change one, change both.
-
-   (Search for the word 'Attention' in tqmoc.y.)
-*/
-static const int ntypes = 35;
-static const char* const type_map[ntypes] =
-{
-    0,
-    "TQMap<TQString,TQVariant>",
-    "TQValueList<TQVariant>",
-    "TQString",
-    "TQStringList",
-    "TQFont",
-    "TQPixmap",
-    "TQBrush",
-    "TQRect",
-    "TQSize",
-    "TQColor",
-    "TQPalette",
-    "TQColorGroup",
-    "TQIconSet",
-    "TQPoint",
-    "TQImage",
-    "int",
-    "uint",
-    "bool",
-    "double",
-    "TQCString",
-    "TQPointArray",
-    "TQRegion",
-    "TQBitmap",
-    "TQCursor",
-    "TQSizePolicy",
-    "TQDate",
-    "TQTime",
-    "TQDateTime",
-    "TQByteArray",
-    "TQBitArray",
-    "TQKeySequence",
-    "TQPen",
-    "TQ_LLONG",
-    "TQ_ULLONG"
-};
-
-
-/*!
-    Converts the enum representation of the storage type, \a typ, to
-    its string representation.
-*/
-const char* TQVariant::typeToName( Type typ )
-{
-    if ( typ >= ntypes )
-	return 0;
-    return type_map[typ];
-}
-
-
-/*!
-    Converts the string representation of the storage type given in \a
-    name, to its enum representation.
-
-    If the string representation cannot be converted to any enum
-    representation, the variant is set to \c Invalid.
-*/
-TQVariant::Type TQVariant::nameToType( const char* name )
-{
-    for ( int i = 0; i < ntypes; i++ ) {
-	if ( !qstrcmp( type_map[i], name ) )
-	    return (Type) i;
-    }
-    return Invalid;
-}
-
-#ifndef TQT_NO_DATASTREAM
-/*!
-    Internal function for loading a variant from stream \a s. Use the
-    stream operators instead.
-
-    \internal
-*/
-void TQVariant::load( TQDataStream& s )
-{
-    clear();
-    TQ_UINT32 u;
-    s >> u;
-    Type t = (Type)u;
-
-    switch( t ) {
-    case Invalid:
-	{
-	    // Since we wrote something, we should read something
-	    TQString x;
-	    s >> x;
-	    d->typ = t;
-	    d->is_null = TRUE;
-	}
-	break;
-#ifndef TQT_NO_TEMPLATE_VARIANT
-    case Map:
-	{
-	    TQMap<TQString,TQVariant>* x = new TQMap<TQString,TQVariant>;
-	    s >> *x;
-	    d->value.ptr = x;
-	    d->is_null = FALSE;
-	}
-	break;
-    case List:
-	{
-	    TQValueList<TQVariant>* x = new TQValueList<TQVariant>;
-	    s >> *x;
-	    d->value.ptr = x;
-	    d->is_null = FALSE;
-	}
-	break;
-#endif
-    case Cursor:
-	{
-#ifndef TQT_NO_CURSOR
-	    TQCursor* x = new TQCursor;
-	    s >> *x;
-	    d->value.ptr = x;
-	    d->is_null = FALSE;
-#endif
-	}
-	break;
-    case Bitmap:
-	{
-	    TQBitmap* x = new TQBitmap;
-#ifndef TQT_NO_IMAGEIO
-	    s >> *x;
-#endif
-	    d->value.ptr = x;
-	}
-	break;
-    case Region:
-	{
-	    TQRegion* x = new TQRegion;
-	    s >> *x;
-	    d->value.ptr = x;
-	}
-	break;
-    case PointArray:
-	{
-	    TQPointArray* x = new TQPointArray;
-	    s >> *x;
-	    d->value.ptr = x;
-	}
-	break;
-    case String:
-	{
-	    TQString* x = new TQString;
-	    s >> *x;
-	    d->value.ptr = x;
-	}
-	break;
-    case CString:
-	{
-	    TQCString* x = new TQCString;
-	    s >> *x;
-	    d->value.ptr = x;
-	}
-	break;
-#ifndef TQT_NO_STRINGLIST
-    case StringList:
-	{
-	    TQStringList* x = new TQStringList;
-	    s >> *x;
-	    d->value.ptr = x;
-	    d->is_null = FALSE;
-	}
-	break;
-#endif // TQT_NO_STRINGLIST
-    case Font:
-	{
-	    TQFont* x = new TQFont;
-	    s >> *x;
-	    d->value.ptr = x;
-	    d->is_null = FALSE;
-	}
-	break;
-    case Pixmap:
-	{
-	    TQPixmap* x = new TQPixmap;
-#ifndef TQT_NO_IMAGEIO
-	    s >> *x;
-#endif
-	    d->value.ptr = x;
-	}
-	break;
-    case Image:
-	{
-	    TQImage* x = new TQImage;
-#ifndef TQT_NO_IMAGEIO
-	    s >> *x;
-#endif
-	    d->value.ptr = x;
-	}
-	break;
-    case Brush:
-	{
-	    TQBrush* x = new TQBrush;
-	    s >> *x;
-	    d->value.ptr = x;
-	    d->is_null = FALSE;
-	}
-	break;
-    case Rect:
-	{
-	    TQRect* x = new TQRect;
-	    s >> *x;
-	    d->value.ptr = x;
-	}
-	break;
-    case Point:
-	{
-	    TQPoint* x = new TQPoint;
-	    s >> *x;
-	    d->value.ptr = x;
-	}
-	break;
-    case Size:
-	{
-	    TQSize* x = new TQSize;
-	    s >> *x;
-	    d->value.ptr = x;
-	}
-	break;
-    case Color:
-	{
-	    TQColor* x = new TQColor;
-	    s >> *x;
-	    d->value.ptr = x;
-	    d->is_null = FALSE;
-	}
-	break;
-#ifndef TQT_NO_PALETTE
-    case Palette:
-	{
-	    TQPalette* x = new TQPalette;
-	    s >> *x;
-	    d->value.ptr = x;
-	    d->is_null = FALSE;
-	}
-	break;
-    case ColorGroup:
-	{
-	    TQColorGroup* x = new TQColorGroup;
-	    s >> *x;
-	    d->value.ptr = x;
-	    d->is_null = FALSE;
-	}
-	break;
-#endif
-#ifndef TQT_NO_ICONSET
-    case IconSet:
-	{
-	    TQPixmap x;
-	    s >> x;
-	    d->value.ptr = new TQIconSet( x );
-	}
-	break;
-#endif
-    case Int:
-	{
-	    int x;
-	    s >> x;
-	    d->value.i = x;
-	    d->is_null = FALSE;
-	}
-	break;
-    case UInt:
-	{
-	    uint x;
-	    s >> x;
-	    d->value.u = x;
-	    d->is_null = FALSE;
-	}
-	break;
-    case LongLong:
-	{
-	    TQ_LLONG x;
-	    s >> x;
-	    d->value.ll = x;
-	}
-	break;
-    case ULongLong:
-	{
-	    TQ_ULLONG x;
-	    s >> x;
-	    d->value.ull = x;
-	}
-	break;
-    case Bool:
-	{
-	    TQ_INT8 x;
-	    s >> x;
-	    d->value.b = x;
-	    d->is_null = FALSE;
-	}
-	break;
-    case Double:
-	{
-	    double x;
-	    s >> x;
-	    d->value.d = x;
-	    d->is_null = FALSE;
-	}
-	break;
-    case SizePolicy:
-	{
-	    int h,v;
-	    TQ_INT8 hfw;
-	    s >> h >> v >> hfw;
-	    d->value.ptr = new TQSizePolicy( (TQSizePolicy::SizeType)h,
-					    (TQSizePolicy::SizeType)v,
-					    (bool) hfw);
-	    d->is_null = FALSE;
-	}
-	break;
-    case Date:
-	{
-	    TQDate* x = new TQDate;
-	    s >> *x;
-	    d->value.ptr = x;
-	}
-	break;
-    case Time:
-	{
-	    TQTime* x = new TQTime;
-	    s >> *x;
-	    d->value.ptr = x;
-	}
-	break;
-    case DateTime:
-	{
-	    TQDateTime* x = new TQDateTime;
-	    s >> *x;
-	    d->value.ptr = x;
-	}
-	break;
-    case ByteArray:
-	{
-	    TQByteArray* x = new TQByteArray;
-	    s >> *x;
-	    d->value.ptr = x;
-	}
-	break;
-    case BitArray:
-	{
-	    TQBitArray* x = new TQBitArray;
-	    s >> *x;
-	    d->value.ptr = x;
-	}
-	break;
-#ifndef TQT_NO_ACCEL
-    case KeySequence:
-	{
-	    TQKeySequence* x = new TQKeySequence;
-	    s >> *x;
-	    d->value.ptr = x;
-	    d->is_null = FALSE;
-	}
-	break;
-#endif // TQT_NO_ACCEL
-    case Pen:
-	{
-	    TQPen* x = new TQPen;
-	    s >> *x;
-	    d->value.ptr = x;
-	    d->is_null = FALSE;
-	}
-	break;
-    }
-    d->typ = t;
-}
-
-/*!
-    Internal function for saving a variant to the stream \a s. Use the
-    stream operators instead.
-
-    \internal
-*/
-void TQVariant::save( TQDataStream& s ) const
-{
-    s << (TQ_UINT32)type();
-
-    switch( d->typ ) {
-    case Cursor:
-	s << *((TQCursor*)d->value.ptr);
-	break;
-    case Bitmap:
-#ifndef TQT_NO_IMAGEIO
-	s << *((TQBitmap*)d->value.ptr);
-#endif
-	break;
-    case PointArray:
-	s << *((TQPointArray*)d->value.ptr);
-	break;
-    case Region:
-	s << *((TQRegion*)d->value.ptr);
-	break;
-#ifndef TQT_NO_TEMPLATE_VARIANT
-    case List:
-	s << *((TQValueList<TQVariant>*)d->value.ptr);
-	break;
-    case Map:
-	s << *((TQMap<TQString,TQVariant>*)d->value.ptr);
-	break;
-#endif
-    case String:
-	s << *((TQString*)d->value.ptr);
-	break;
-    case CString:
-	s << *((TQCString*)d->value.ptr);
-	break;
-#ifndef TQT_NO_STRINGLIST
-    case StringList:
-	s << *((TQStringList*)d->value.ptr);
-	break;
-#endif
-    case Font:
-	s << *((TQFont*)d->value.ptr);
-	break;
-    case Pixmap:
-#ifndef TQT_NO_IMAGEIO
-	s << *((TQPixmap*)d->value.ptr);
-#endif
-	break;
-    case Image:
-#ifndef TQT_NO_IMAGEIO
-	s << *((TQImage*)d->value.ptr);
-#endif
-	break;
-    case Brush:
-	s << *((TQBrush*)d->value.ptr);
-	break;
-    case Point:
-	s << *((TQPoint*)d->value.ptr);
-	break;
-    case Rect:
-	s << *((TQRect*)d->value.ptr);
-	break;
-    case Size:
-	s << *((TQSize*)d->value.ptr);
-	break;
-    case Color:
-	s << *((TQColor*)d->value.ptr);
-	break;
-#ifndef TQT_NO_PALETTE
-    case Palette:
-	s << *((TQPalette*)d->value.ptr);
-	break;
-    case ColorGroup:
-	s << *((TQColorGroup*)d->value.ptr);
-	break;
-#endif
-#ifndef TQT_NO_ICONSET
-    case IconSet:
-	//### add stream operator to iconset
-	s << ((TQIconSet*)d->value.ptr)->pixmap();
-	break;
-#endif
-    case Int:
-	s << d->value.i;
-	break;
-    case UInt:
-	s << d->value.u;
-	break;
-    case LongLong:
-	s << d->value.ll;
-	break;
-    case ULongLong:
-	s << d->value.ull;
-	break;
-    case Bool:
-	s << (TQ_INT8)d->value.b;
-	break;
-    case Double:
-	s << d->value.d;
-	break;
-    case SizePolicy:
-	{
-	    TQSizePolicy p = toSizePolicy();
-	    s << (int) p.horData() << (int) p.verData()
-	      << (TQ_INT8) p.hasHeightForWidth();
-	}
-	break;
-    case Date:
-	s << *((TQDate*)d->value.ptr);
-	break;
-    case Time:
-	s << *((TQTime*)d->value.ptr);
-	break;
-    case DateTime:
-	s << *((TQDateTime*)d->value.ptr);
-	break;
-    case ByteArray:
-	s << *((TQByteArray*)d->value.ptr);
-	break;
-    case BitArray:
-	s << *((TQBitArray*)d->value.ptr);
-	break;
-#ifndef TQT_NO_ACCEL
-    case KeySequence:
-	s << *((TQKeySequence*)d->value.ptr);
-	break;
-#endif
-    case Pen:
-	s << *((TQPen*)d->value.ptr);
-	break;
-    case Invalid:
-	s << TQString(); // ### looks wrong.
-	break;
-    }
-}
-
-/*!
-    Reads a variant \a p from the stream \a s.
-
-    \sa \link datastreamformat.html Format of the TQDataStream
-    operators \endlink
-*/
-TQDataStream& operator>> ( TQDataStream& s, TQVariant& p )
-{
-    p.load( s );
-    return s;
-}
-
-/*!
-    Writes a variant \a p to the stream \a s.
-
-    \sa \link datastreamformat.html Format of the TQDataStream
-    operators \endlink
-*/
-TQDataStream& operator<< ( TQDataStream& s, const TQVariant& p )
-{
-    p.save( s );
-    return s;
-}
-
-/*!
-    Reads a variant type \a p in enum representation from the stream \a s.
-*/
-TQDataStream& operator>> ( TQDataStream& s, TQVariant::Type& p )
-{
-    TQ_UINT32 u;
-    s >> u;
-    p = (TQVariant::Type) u;
-
-    return s;
-}
-
-/*!
-    Writes a variant type \a p to the stream \a s.
-*/
-TQDataStream& operator<< ( TQDataStream& s, const TQVariant::Type p )
-{
-    s << (TQ_UINT32)p;
-
-    return s;
-}
-
-#endif //TQT_NO_DATASTREAM
-
-/*!
-    \fn Type TQVariant::type() const
-
-    Returns the storage type of the value stored in the variant.
-    Usually it's best to test with canCast() whether the variant can
-    deliver the data type you are interested in.
-*/
-
-/*!
-    \fn bool TQVariant::isValid() const
-
-    Returns TRUE if the storage type of this variant is not
-    TQVariant::Invalid; otherwise returns FALSE.
-*/
-
-/*!
-    \fn TQValueListConstIterator<TQString> TQVariant::stringListBegin() const
-    \obsolete
-
-    Returns an iterator to the first string in the list if the
-    variant's type is StringList; otherwise returns a null iterator.
-*/
-
-/*!
-    \fn TQValueListConstIterator<TQString> TQVariant::stringListEnd() const
-    \obsolete
-
-    Returns the end iterator for the list if the variant's type is
-    StringList; otherwise returns a null iterator.
-*/
-
-/*!
-    \fn TQValueListConstIterator<TQVariant> TQVariant::listBegin() const
-    \obsolete
-
-    Returns an iterator to the first item in the list if the variant's
-    type is appropriate; otherwise returns a null iterator.
-*/
-
-/*!
-    \fn TQValueListConstIterator<TQVariant> TQVariant::listEnd() const
-    \obsolete
-
-    Returns the end iterator for the list if the variant's type is
-    appropriate; otherwise returns a null iterator.
-*/
-
-/*!
-    \fn TQMapConstIterator<TQString, TQVariant> TQVariant::mapBegin() const
-    \obsolete
-
-    Returns an iterator to the first item in the map, if the variant's
-    type is appropriate; otherwise returns a null iterator.
-*/
-
-/*!
-    \fn TQMapConstIterator<TQString, TQVariant> TQVariant::mapEnd() const
-    \obsolete
-
-    Returns the end iterator for the map, if the variant's type is
-    appropriate; otherwise returns a null iterator.
-*/
-
-/*!
-    \fn TQMapConstIterator<TQString, TQVariant> TQVariant::mapFind( const TQString& key ) const
-    \obsolete
-
-    Returns an iterator to the item in the map with \a key as key, if
-    the variant's type is appropriate and \a key is a valid key;
-    otherwise returns a null iterator.
-*/
-
-/*!
-    Returns the variant as a TQString if the variant can be cast to
-    String, otherwise returns TQString::null.
-
-    \sa asString(), canCast()
-*/
-const TQString TQVariant::toString() const
-{
-    switch( d->typ ) {
-    case CString:
-	return TQString::tqfromLatin1( toCString() );
-    case Int:
-	return TQString::number( toInt() );
-    case UInt:
-	return TQString::number( toUInt() );
-    case LongLong:
-	return TQString::number( toLongLong() );
-    case ULongLong:
-	return TQString::number( toULongLong() );
-    case Double:
-	return TQString::number( toDouble(), 'g', DBL_DIG );
-#if !defined(TQT_NO_SPRINTF) && !defined(TQT_NO_DATESTRING)
-    case Date:
-	return toDate().toString( TQt::ISODate );
-    case Time:
-	return toTime().toString( TQt::ISODate );
-    case DateTime:
-	return toDateTime().toString( TQt::ISODate );
-#endif
-    case Bool:
-	return toInt() ? "true" : "false";
-#ifndef TQT_NO_ACCEL
-    case KeySequence:
-	return (TQString) *( (TQKeySequence*)d->value.ptr );
-#endif
-    case ByteArray:
-	return TQString( *((TQByteArray*)d->value.ptr) );
-    case Font:
-	return toFont().toString();
-    case Color:
-	return toColor().name();
-    case String:
-	return *((TQString*)d->value.ptr);
-    default:
-	return TQString::null;
-    }
-}
-/*!
-    Returns the variant as a TQCString if the variant can be cast to a
-    CString; otherwise returns 0.
-
-    \sa asCString(), canCast()
-*/
-const TQCString TQVariant::toCString() const
-{
-    switch( d->typ ) {
-    case CString: return *((TQCString*)d->value.ptr);
-    case String: return ((TQString*)d->value.ptr)->latin1();
-    default: {
-	if (!canCast(String))
-	    return 0;
-	TQString c = toString();
-	return TQCString(c.latin1());
-    }
-    }
-}
-
-
-#ifndef TQT_NO_STRINGLIST
-/*!
-    Returns the variant as a TQStringList if the variant has type()
-    StringList or List of a type that can be converted to TQString;
-    otherwise returns an empty list.
-
-    Note that if you want to iterate over the list, you should iterate
-    over a copy, e.g.
-    \code
-    TQStringList list = myVariant.toStringList();
-    TQStringList::Iterator it = list.begin();
-    while( it != list.end() ) {
-	myProcessing( *it );
-	++it;
-    }
-    \endcode
-
-    \sa asStringList()
-*/
-const TQStringList TQVariant::toStringList() const
-{
-    switch ( d->typ ) {
-    case StringList:
-	return *((TQStringList*)d->value.ptr);
-#ifndef TQT_NO_TEMPLATE_VARIANT
-    case List:
-	{
-	    TQStringList lst;
-	    TQValueList<TQVariant>::ConstIterator it = listBegin();
-	    TQValueList<TQVariant>::ConstIterator end = listEnd();
-	    while( it != end ) {
-		TQString tmp = (*it).toString();
-		++it;
-		lst.append( tmp );
-	    }
-	    return lst;
-	}
-#endif
-    default:
-	return TQStringList();
-    }
-}
-#endif //TQT_NO_STRINGLIST
-
-#ifndef TQT_NO_TEMPLATE_VARIANT
-/*!
-    Returns the variant as a TQMap<TQString,TQVariant> if the variant has
-    type() Map; otherwise returns an empty map.
-
-    Note that if you want to iterate over the map, you should iterate
-    over a copy, e.g.
-    \code
-    TQMap<TQString, TQVariant> map = myVariant.toMap();
-    TQMap<TQString, TQVariant>::Iterator it = map.begin();
-    while( it != map.end() ) {
-	myProcessing( *it );
-	++it;
-    }
-    \endcode
-
-    \sa asMap()
-*/
-const TQMap<TQString, TQVariant> TQVariant::toMap() const
-{
-    if ( d->typ != Map )
-	return TQMap<TQString,TQVariant>();
-
-    return *((TQMap<TQString,TQVariant>*)d->value.ptr);
-}
-#endif
-/*!
-    Returns the variant as a TQFont if the variant can be cast to Font;
-    otherwise returns the application's default font.
-
-  \sa asFont(), canCast()
-*/
-const TQFont TQVariant::toFont() const
-{
-    switch ( d->typ ) {
-    case CString:
-    case ByteArray:
-    case String:
-	{
-	    TQFont fnt;
-	    fnt.fromString( toString() );
-	    return fnt;
-	}
-    case Font:
-	return *((TQFont*)d->value.ptr);
-    default:
-	return TQFont();
-    }
-}
-
-/*!
-    Returns the variant as a TQPixmap if the variant has type() Pixmap;
-    otherwise returns a null pixmap.
-
-    \sa asPixmap()
-*/
-const TQPixmap TQVariant::toPixmap() const
-{
-    if ( d->typ != Pixmap )
-	return TQPixmap();
-
-    return *((TQPixmap*)d->value.ptr);
-}
-
-/*!
-    Returns the variant as a TQImage if the variant has type() Image;
-    otherwise returns a null image.
-
-    \sa asImage()
-*/
-const TQImage TQVariant::toImage() const
-{
-    if ( d->typ != Image )
-	return TQImage();
-
-    return *((TQImage*)d->value.ptr);
-}
-
-/*!
-    Returns the variant as a TQBrush if the variant has type() Brush;
-    otherwise returns a default brush (with all black colors).
-
-    \sa asBrush()
-*/
-const TQBrush TQVariant::toBrush() const
-{
-    if( d->typ != Brush )
-	return TQBrush();
-
-    return *((TQBrush*)d->value.ptr);
-}
-
-/*!
-    Returns the variant as a TQPoint if the variant has type() Point;
-    otherwise returns a point (0, 0).
-
-    \sa asPoint()
-*/
-const TQPoint TQVariant::toPoint() const
-{
-    if ( d->typ != Point )
-	return TQPoint();
-
-    return *((TQPoint*)d->value.ptr);
-}
-
-/*!
-    Returns the variant as a TQRect if the variant has type() Rect;
-    otherwise returns an empty rectangle.
-
-    \sa asRect()
-*/
-const TQRect TQVariant::toRect() const
-{
-    if ( d->typ != Rect )
-	return TQRect();
-
-    return *((TQRect*)d->value.ptr);
-}
-
-/*!
-    Returns the variant as a TQSize if the variant has type() Size;
-    otherwise returns an invalid size.
-
-    \sa asSize()
-*/
-const TQSize TQVariant::toSize() const
-{
-    if ( d->typ != Size )
-	return TQSize();
-
-    return *((TQSize*)d->value.ptr);
-}
-
-/*!
-    Returns the variant as a TQColor if the variant can be cast to Color;
-    otherwise returns an invalid color.
-
-    \sa asColor(), canCast()
-*/
-const TQColor TQVariant::toColor() const
-{
-    switch ( d->typ ) {
-    case ByteArray:
-    case CString:
-    case String:
-    {
-	TQColor col;
-	col.setNamedColor( toString() );
-	return col;
-    }
-    case Color:
-	return *((TQColor*)d->value.ptr);
-    default:
-	return TQColor();
-    }
-}
-#ifndef TQT_NO_PALETTE
-/*!
-    Returns the variant as a TQPalette if the variant has type()
-    Palette; otherwise returns a completely black palette.
-
-    \sa asPalette()
-*/
-const TQPalette TQVariant::toPalette() const
-{
-    if ( d->typ != Palette )
-	return TQPalette();
-
-    return *((TQPalette*)d->value.ptr);
-}
-
-/*!
-    Returns the variant as a TQColorGroup if the variant has type()
-    ColorGroup; otherwise returns a completely black color group.
-
-    \sa asColorGroup()
-*/
-const TQColorGroup TQVariant::toColorGroup() const
-{
-    if ( d->typ != ColorGroup )
-	return TQColorGroup();
-
-    return *((TQColorGroup*)d->value.ptr);
-}
-#endif //TQT_NO_PALETTE
-#ifndef TQT_NO_ICONSET
-/*!
-    Returns the variant as a TQIconSet if the variant has type()
-    IconSet; otherwise returns an icon set of null pixmaps.
-
-    \sa asIconSet()
-*/
-const TQIconSet TQVariant::toIconSet() const
-{
-    if ( d->typ != IconSet )
-	return TQIconSet();
-
-    return *((TQIconSet*)d->value.ptr);
-}
-#endif //TQT_NO_ICONSET
-/*!
-    Returns the variant as a TQPointArray if the variant has type()
-    PointArray; otherwise returns an empty TQPointArray.
-
-    \sa asPointArray()
-*/
-const TQPointArray TQVariant::toPointArray() const
-{
-    if ( d->typ != PointArray )
-	return TQPointArray();
-
-    return *((TQPointArray*)d->value.ptr);
-}
-
-/*!
-    Returns the variant as a TQBitmap if the variant has type() Bitmap;
-    otherwise returns a null TQBitmap.
-
-    \sa asBitmap()
-*/
-const TQBitmap TQVariant::toBitmap() const
-{
-    if ( d->typ != Bitmap )
-	return TQBitmap();
-
-    return *((TQBitmap*)d->value.ptr);
-}
-
-/*!
-    Returns the variant as a TQRegion if the variant has type() Region;
-    otherwise returns an empty TQRegion.
-
-    \sa asRegion()
-*/
-const TQRegion TQVariant::toRegion() const
-{
-    if ( d->typ != Region )
-	return TQRegion();
-
-    return *((TQRegion*)d->value.ptr);
-}
-
-/*!
-    Returns the variant as a TQCursor if the variant has type() Cursor;
-    otherwise returns the default arrow cursor.
-
-    \sa asCursor()
-*/
-const TQCursor TQVariant::toCursor() const
-{
-#ifndef TQT_NO_CURSOR
-    if ( d->typ != Cursor )
-	return TQCursor();
-#endif
-
-    return *((TQCursor*)d->value.ptr);
-}
-
-/*!
-    Returns the variant as a TQDate if the variant can be cast to Date;
-    otherwise returns an invalid date.
-
-    Note that if the type() is String, CString or ByteArray an invalid
-    date will be returned if the string cannot be parsed as a
-    TQt::ISODate format date.
-
-    \sa asDate(), canCast()
-*/
-const TQDate TQVariant::toDate() const
-{
-    switch ( d->typ ) {
-    case Date:
-	return *((TQDate*)d->value.ptr);
-    case DateTime:
-	return ((TQDateTime*)d->value.ptr)->date();
-#ifndef TQT_NO_DATESTRING
-    case String:
-	return TQDate::fromString( *((TQString*)d->value.ptr), TQt::ISODate );
-    case CString:
-    case ByteArray:
-	return TQDate::fromString(toString(), TQt::ISODate);
-#endif
-    default:
-	return TQDate();
-    }
-}
-
-/*!
-    Returns the variant as a TQTime if the variant can be cast to Time;
-    otherwise returns an invalid date.
-
-    Note that if the type() is String, CString or ByteArray an invalid
-    time will be returned if the string cannot be parsed as a
-    TQt::ISODate format time.
-
-    \sa asTime()
-*/
-const TQTime TQVariant::toTime() const
-{
-    switch ( d->typ ) {
-    case Time:
-	return *((TQTime*)d->value.ptr);
-    case DateTime:
-	return ((TQDateTime*)d->value.ptr)->time();
-#ifndef TQT_NO_DATESTRING
-    case String:
-	return TQTime::fromString( *((TQString*)d->value.ptr), TQt::ISODate );
-    case CString:
-    case ByteArray:
-	return TQTime::fromString(toString(), TQt::ISODate);
-#endif
-    default:
-	return TQTime();
-    }
-}
-
-/*!
-    Returns the variant as a TQDateTime if the variant can be cast to
-    DateTime; otherwise returns an invalid TQDateTime.
-
-    Note that if the type() is String, CString or ByteArray an invalid
-    TQDateTime will be returned if the string cannot be parsed as a
-    TQt::ISODate format date/time.
-
-    \sa asDateTime()
-*/
-const TQDateTime TQVariant::toDateTime() const
-{
-    switch ( d->typ ) {
-    case DateTime:
-	return *((TQDateTime*)d->value.ptr);
-#ifndef TQT_NO_DATESTRING
-    case String:
-	return TQDateTime::fromString( *((TQString*)d->value.ptr), TQt::ISODate );
-    case CString:
-    case ByteArray:
-	return TQDateTime::fromString(toString(), TQt::ISODate);
-#endif
-    case Date:
-	return TQDateTime( *((TQDate*)d->value.ptr) );
-    default:
-	return TQDateTime();
-    }
-}
-
-/*!
-    Returns the variant as a TQByteArray if the variant can be cast to
-    a ByteArray; otherwise returns an empty bytearray.
-
-    \sa asByteArray(), canCast()
-*/
-const TQByteArray TQVariant::toByteArray() const
-{
-    switch(d->typ) {
-    case ByteArray: return *((TQByteArray*)d->value.ptr);
-    case CString: return *((TQByteArray*)d->value.ptr);
-    default: {
-	TQByteArray ret;
-	if (canCast(String)) {
-	    TQString c = toString();
-	    ret.duplicate(c.latin1(), c.length());
-	}
-	return ret;
-    }
-    }
-}
-
-/*!
-    Returns the variant as a TQBitArray if the variant has type()
-    BitArray; otherwise returns an empty bitarray.
-
-    \sa asBitArray()
-*/
-const TQBitArray TQVariant::toBitArray() const
-{
-    if ( d->typ == BitArray )
-	return *((TQBitArray*)d->value.ptr);
-    return TQBitArray();
-}
-
-#ifndef TQT_NO_ACCEL
-
-/*!
-    Returns the variant as a TQKeySequence if the variant can be cast
-    to a KeySequence; otherwise returns an empty key sequence.
-
-    \sa asKeySequence(), canCast()
-*/
-const TQKeySequence TQVariant::toKeySequence() const
-{
-    switch ( d->typ ) {
-    case KeySequence:
-	return *((TQKeySequence*)d->value.ptr);
-    case String:
-    case ByteArray:
-    case CString:
-	return TQKeySequence( toString() );
-    case Int:
-    case UInt:
-    case Double:
-    case ULongLong:
-    case LongLong:
-	return TQKeySequence( toInt() );
-    default:
-	return TQKeySequence();
-    }
-}
-
-#endif // TQT_NO_ACCEL
-
-/*!
-    Returns the variant as a TQPen if the variant has type()
-    Pen; otherwise returns an empty TQPen.
-
-    \sa asPen()
-*/
-const TQPen TQVariant::toPen() const
-{
-    if ( d->typ != Pen )
-	return TQPen();
-
-    return *((TQPen*)d->value.ptr);
-}
-
-/*!
-    Returns the variant as an int if the variant can be cast to Int;
-    otherwise returns 0.
-
-    If \a ok is non-null: \a *ok is set to TRUE if the value could be
-    converted to an int; otherwise \a *ok is set to FALSE.
-
-    \sa asInt(), canCast()
-*/
-int TQVariant::toInt( bool * ok ) const
-{
-    if ( ok )
-	*ok = canCast( Int );
-
-    switch ( d->typ ) {
-    case String:
-	return ((TQString*)d->value.ptr)->toInt( ok );
-    case CString:
-    case ByteArray:
-	return ((TQCString*)d->value.ptr)->toInt( ok );
-    case Int:
-	return d->value.i;
-    case UInt:
-	return (int)d->value.u;
-    case LongLong:
-        return (int)d->value.ll;
-    case ULongLong:
-        return (int)d->value.ull;
-    case Double:
-	return (int)d->value.d;
-    case Bool:
-	return (int)d->value.b;
-#ifndef TQT_NO_ACCEL
-    case KeySequence:
-	return (int) *( (TQKeySequence*)d->value.ptr );
-#endif
-    default:
-	return 0;
-    }
-}
-
-/*!
-    Returns the variant as an unsigned int if the variant can be cast
-    to UInt; otherwise returns 0.
-
-    If \a ok is non-null: \a *ok is set to TRUE if the value could be
-    converted to an unsigned int; otherwise \a *ok is set to FALSE.
-
-    \sa asUInt(), canCast()
-*/
-uint TQVariant::toUInt( bool * ok ) const
-{
-    if ( ok )
-	*ok = canCast( UInt );
-
-    switch( d->typ ) {
-    case String:
-	return ((TQString*)d->value.ptr)->toUInt( ok );
-    case CString:
-    case ByteArray:
-	return ((TQCString*)d->value.ptr)->toUInt( ok );
-    case Int:
-	return (uint)d->value.i;
-    case UInt:
-	return d->value.u;
-    case LongLong:
-        return (uint)d->value.ll;
-    case ULongLong:
-        return (uint)d->value.ull;
-    case Double:
-	return (uint)d->value.d;
-    case Bool:
-	return (uint)d->value.b;
-    default:
-	return 0;
-    }
-}
-
-/*!
-    Returns the variant as a long long int if the variant can be cast
-    to LongLong; otherwise returns 0.
-
-    If \a ok is non-null: \a *ok is set to TRUE if the value could be
-    converted to an int; otherwise \a *ok is set to FALSE.
-
-    \sa asLongLong(), canCast()
-*/
-TQ_LLONG TQVariant::toLongLong( bool * ok ) const
-{
-    if ( ok )
-	*ok = canCast( LongLong );
-
-    switch ( d->typ ) {
-    case String:
-	return ((TQString*)d->value.ptr)->toLongLong( ok );
-    case CString:
-    case ByteArray:
-	return TQString(*(TQCString*)d->value.ptr).toLongLong(ok);
-    case Int:
-	return (TQ_LLONG)d->value.i;
-    case UInt:
-	return (TQ_LLONG)d->value.u;
-    case LongLong:
-	return d->value.ll;
-    case ULongLong:
-	return (TQ_LLONG)d->value.ull;
-    case Double:
-	return (TQ_LLONG)d->value.d;
-    case Bool:
-	return (TQ_LLONG)d->value.b;
-    default:
-	return 0;
-    }
-}
-
-/*!
-    Returns the variant as as an unsigned long long int if the variant
-    can be cast to ULongLong; otherwise returns 0.
-
-    If \a ok is non-null: \a *ok is set to TRUE if the value could be
-    converted to an int; otherwise \a *ok is set to FALSE.
-
-    \sa asULongLong(), canCast()
-*/
-TQ_ULLONG TQVariant::toULongLong( bool * ok ) const
-{
-    if ( ok )
-	*ok = canCast( ULongLong );
-
-    switch ( d->typ ) {
-    case Int:
-	return (TQ_ULLONG)d->value.i;
-    case UInt:
-	return (TQ_ULLONG)d->value.u;
-    case LongLong:
-	return (TQ_ULLONG)d->value.ll;
-    case ULongLong:
-	return d->value.ull;
-    case Double:
-	return (TQ_ULLONG)d->value.d;
-    case Bool:
-	return (TQ_ULLONG)d->value.b;
-    case String:
-	return ((TQString*)d->value.ptr)->toULongLong( ok );
-    case CString:
-    case ByteArray:
-	return TQString(*(TQCString*)d->value.ptr).toULongLong(ok);
-    default:
-	return 0;
-    }
-}
-
-/*!
-    Returns the variant as a bool if the variant can be cast to Bool;
-    otherWise returns FALSE.
-
-    Returns TRUE if the variant has a numeric type and its value is
-    non-zero, or if the variant has type String, ByteArray or CString
-    and its lower-case content is not empty, "0" or "false"; otherwise
-    returns FALSE.
-
-    \sa asBool(), canCast()
-*/
-bool TQVariant::toBool() const
-{
-    switch( d->typ ) {
-    case Bool:
-	return d->value.b;
-    case Double:
-	return d->value.d != 0.0;
-    case Int:
-	return d->value.i != 0;
-    case UInt:
-	return d->value.u != 0;
-    case LongLong:
-	return d->value.ll != 0;
-    case ULongLong:
-	return d->value.ull != 0;
-    case String:
-    case CString:
-    case ByteArray:
-	{
-	    TQString str = toString().lower();
-	    return !(str == "0" || str == "false" || str.isEmpty() );
-	}
-    default:
-	return FALSE;
-    }
-}
-
-/*!
-    Returns the variant as a double if the variant can be cast to
-    Double; otherwise returns 0.0.
-
-    If \a ok is non-null: \a *ok is set to TRUE if the value could be
-    converted to a double; otherwise \a *ok is set to FALSE.
-
-    \sa asDouble(), canCast()
-*/
-double TQVariant::toDouble( bool * ok ) const
-{
-    if ( ok )
-	*ok = canCast( Double );
-
-    switch ( d->typ ) {
-    case String:
-	return ((TQString*)d->value.ptr)->toDouble( ok );
-    case CString:
-    case ByteArray:
-	return ((TQCString*)d->value.ptr)->toDouble( ok );
-    case Double:
-	return d->value.d;
-    case Int:
-	return (double)d->value.i;
-    case Bool:
-	return (double)d->value.b;
-    case UInt:
-	return (double)d->value.u;
-    case LongLong:
-	return (double)d->value.ll;
-    case ULongLong:
-#if defined(TQ_CC_MSVC) && !defined(TQ_CC_MSVC_NET)
-	return (double)(TQ_LLONG)d->value.ull;
-#else
-	return (double)d->value.ull;
-#endif
-    default:
-	return 0.0;
-    }
-}
-
-#ifndef TQT_NO_TEMPLATE_VARIANT
-/*!
-    Returns the variant as a TQValueList<TQVariant> if the variant has
-    type() List or StringList; otherwise returns an empty list.
-
-    Note that if you want to iterate over the list, you should iterate
-    over a copy, e.g.
-    \code
-    TQValueList<TQVariant> list = myVariant.toList();
-    TQValueList<TQVariant>::Iterator it = list.begin();
-    while( it != list.end() ) {
-	myProcessing( *it );
-	++it;
-    }
-    \endcode
-
-    \sa asList()
-*/
-const TQValueList<TQVariant> TQVariant::toList() const
-{
-    if ( d->typ == List )
-	return *((TQValueList<TQVariant>*)d->value.ptr);
-#ifndef TQT_NO_STRINGLIST
-    if ( d->typ == StringList ) {
-	TQValueList<TQVariant> lst;
-	TQStringList::ConstIterator it = stringListBegin();
-	TQStringList::ConstIterator end = stringListEnd();
-	for( ; it != end; ++it )
-	    lst.append( TQVariant( *it ) );
-	return lst;
-    }
-#endif //TQT_NO_STRINGLIST
-    return TQValueList<TQVariant>();
-}
-#endif
-
-/*!
-    Returns the variant as a TQSizePolicy if the variant has type()
-    SizePolicy; otherwise returns an undefined (but legal) size
-    policy.
-*/
-
-TQSizePolicy TQVariant::toSizePolicy() const
-{
-    if ( d->typ == SizePolicy )
-	return *((TQSizePolicy*)d->value.ptr);
-
-    return TQSizePolicy();
-}
-
-
-#define TQ_VARIANT_AS( f ) TQ##f& TQVariant::as##f() \
-{ \
-    bool b = isNull(); \
-    if ( d->typ != f ) \
-	*this = TQVariant( to##f() ); \
-    else \
-	detach(); \
-    d->is_null = b; \
-    return *((TQ##f*)d->value.ptr); \
-}
-
-TQ_VARIANT_AS(String)
-TQ_VARIANT_AS(CString)
-#ifndef TQT_NO_STRINGLIST
-TQ_VARIANT_AS(StringList)
-#endif
-TQ_VARIANT_AS(Font)
-TQ_VARIANT_AS(Pixmap)
-TQ_VARIANT_AS(Image)
-TQ_VARIANT_AS(Brush)
-TQ_VARIANT_AS(Point)
-TQ_VARIANT_AS(Rect)
-TQ_VARIANT_AS(Size)
-TQ_VARIANT_AS(Color)
-#ifndef TQT_NO_PALETTE
-TQ_VARIANT_AS(Palette)
-TQ_VARIANT_AS(ColorGroup)
-#endif
-#ifndef TQT_NO_ICONSET
-TQ_VARIANT_AS(IconSet)
-#endif
-TQ_VARIANT_AS(PointArray)
-TQ_VARIANT_AS(Bitmap)
-TQ_VARIANT_AS(Region)
-TQ_VARIANT_AS(Cursor)
-TQ_VARIANT_AS(SizePolicy)
-TQ_VARIANT_AS(Date)
-TQ_VARIANT_AS(Time)
-TQ_VARIANT_AS(DateTime)
-TQ_VARIANT_AS(ByteArray)
-TQ_VARIANT_AS(BitArray)
-#ifndef TQT_NO_ACCEL
-TQ_VARIANT_AS(KeySequence)
-#endif
-TQ_VARIANT_AS(Pen)
-
-/*!
-    \fn TQString& TQVariant::asString()
-
-    Tries to convert the variant to hold a string value. If that is
-    not possible the variant is set to an empty string.
-
-    Returns a reference to the stored string.
-
-    \sa toString()
-*/
-
-/*!
-    \fn TQCString& TQVariant::asCString()
-
-    Tries to convert the variant to hold a string value. If that is
-    not possible the variant is set to an empty string.
-
-    Returns a reference to the stored string.
-
-    \sa toCString()
-*/
-
-/*!
-    \fn TQStringList& TQVariant::asStringList()
-
-    Tries to convert the variant to hold a TQStringList value. If that
-    is not possible the variant is set to an empty string list.
-
-    Returns a reference to the stored string list.
-
-    Note that if you want to iterate over the list, you should
-    iterate over a copy, e.g.
-    \code
-    TQStringList list = myVariant.asStringList();
-    TQStringList::Iterator it = list.begin();
-    while( it != list.end() ) {
-	myProcessing( *it );
-	++it;
-    }
-    \endcode
-
-    \sa toStringList()
-*/
-
-/*!
-    \fn TQFont& TQVariant::asFont()
-
-    Tries to convert the variant to hold a TQFont. If that is not
-    possible the variant is set to the application's default font.
-
-    Returns a reference to the stored font.
-
-    \sa toFont()
-*/
-
-/*!
-    \fn TQPixmap& TQVariant::asPixmap()
-
-    Tries to convert the variant to hold a pixmap value. If that is
-    not possible the variant is set to a null pixmap.
-
-    Returns a reference to the stored pixmap.
-
-    \sa toPixmap()
-*/
-
-/*!
-    \fn TQImage& TQVariant::asImage()
-
-    Tries to convert the variant to hold an image value. If that is
-    not possible the variant is set to a null image.
-
-    Returns a reference to the stored image.
-
-    \sa toImage()
-*/
-
-/*!
-    \fn TQBrush& TQVariant::asBrush()
-
-    Tries to convert the variant to hold a brush value. If that is not
-    possible the variant is set to a default black brush.
-
-    Returns a reference to the stored brush.
-
-    \sa toBrush()
-*/
-
-/*!
-    \fn TQPoint& TQVariant::asPoint()
-
-    Tries to convert the variant to hold a point value. If that is not
-    possible the variant is set to a (0, 0) point.
-
-    Returns a reference to the stored point.
-
-    \sa toPoint()
-*/
-
-/*!
-    \fn TQRect& TQVariant::asRect()
-
-    Tries to convert the variant to hold a rectangle value. If that is
-    not possible the variant is set to an empty rectangle.
-
-    Returns a reference to the stored rectangle.
-
-    \sa toRect()
-*/
-
-/*!
-    \fn TQSize& TQVariant::asSize()
-
-    Tries to convert the variant to hold a TQSize value. If that is not
-    possible the variant is set to an invalid size.
-
-    Returns a reference to the stored size.
-
-    \sa toSize() TQSize::isValid()
-*/
-
-/*!
-    \fn TQSizePolicy& TQVariant::asSizePolicy()
-
-    Tries to convert the variant to hold a TQSizePolicy value. If that
-    fails, the variant is set to an arbitrary (valid) size policy.
-*/
-
-
-/*!
-    \fn TQColor& TQVariant::asColor()
-
-    Tries to convert the variant to hold a TQColor value. If that is
-    not possible the variant is set to an invalid color.
-
-    Returns a reference to the stored color.
-
-    \sa toColor() TQColor::isValid()
-*/
-
-/*!
-    \fn TQPalette& TQVariant::asPalette()
-
-    Tries to convert the variant to hold a TQPalette value. If that is
-    not possible the variant is set to a palette of black colors.
-
-    Returns a reference to the stored palette.
-
-    \sa toString()
-*/
-
-/*!
-    \fn TQColorGroup& TQVariant::asColorGroup()
-
-    Tries to convert the variant to hold a TQColorGroup value. If that
-    is not possible the variant is set to a color group of all black
-    colors.
-
-    Returns a reference to the stored color group.
-
-    \sa toColorGroup()
-*/
-
-/*!
-    \fn TQIconSet& TQVariant::asIconSet()
-
-    Tries to convert the variant to hold a TQIconSet value. If that is
-    not possible the variant is set to an empty iconset.
-
-    Returns a reference to the stored iconset.
-
-    \sa toIconSet()
-*/
-
-/*!
-    \fn TQPointArray& TQVariant::asPointArray()
-
-    Tries to convert the variant to hold a TQPointArray value. If that
-    is not possible the variant is set to an empty point array.
-
-    Returns a reference to the stored point array.
-
-    \sa toPointArray()
-*/
-
-/*!
-    \fn TQBitmap& TQVariant::asBitmap()
-
-    Tries to convert the variant to hold a bitmap value. If that is
-    not possible the variant is set to a null bitmap.
-
-    Returns a reference to the stored bitmap.
-
-    \sa toBitmap()
-*/
-
-/*!
-    \fn TQRegion& TQVariant::asRegion()
-
-    Tries to convert the variant to hold a TQRegion value. If that is
-    not possible the variant is set to a null region.
-
-    Returns a reference to the stored region.
-
-    \sa toRegion()
-*/
-
-/*!
-    \fn TQCursor& TQVariant::asCursor()
-
-    Tries to convert the variant to hold a TQCursor value. If that is
-    not possible the variant is set to a default arrow cursor.
-
-    Returns a reference to the stored cursor.
-
-    \sa toCursor()
-*/
-
-/*!
-    \fn TQDate& TQVariant::asDate()
-
-    Tries to convert the variant to hold a TQDate value. If that is not
-    possible then the variant is set to an invalid date.
-
-    Returns a reference to the stored date.
-
-    \sa toDate()
-*/
-
-/*!
-    \fn TQTime& TQVariant::asTime()
-
-    Tries to convert the variant to hold a TQTime value. If that is not
-    possible then the variant is set to an invalid time.
-
-    Returns a reference to the stored time.
-
-    \sa toTime()
-*/
-
-/*!
-    \fn TQDateTime& TQVariant::asDateTime()
-
-    Tries to convert the variant to hold a TQDateTime value. If that is
-    not possible then the variant is set to an invalid date/time.
-
-    Returns a reference to the stored date/time.
-
-    \sa toDateTime()
-*/
-
-/*!
-    \fn TQByteArray& TQVariant::asByteArray()
-
-    Tries to convert the variant to hold a TQByteArray value. If that
-    is not possible then the variant is set to an empty bytearray.
-
-    Returns a reference to the stored bytearray.
-
-    \sa toByteArray()
-*/
-
-/*!
-    \fn TQBitArray& TQVariant::asBitArray()
-
-    Tries to convert the variant to hold a TQBitArray value. If that is
-    not possible then the variant is set to an empty bitarray.
-
-    Returns a reference to the stored bitarray.
-
-    \sa toBitArray()
-*/
-
-/*!
-    \fn TQKeySequence& TQVariant::asKeySequence()
-
-    Tries to convert the variant to hold a TQKeySequence value. If that
-    is not possible then the variant is set to an empty key sequence.
-
-    Returns a reference to the stored key sequence.
-
-    \sa toKeySequence()
-*/
-
-/*! \fn TQPen& TQVariant::asPen()
-
-  Tries to convert the variant to hold a TQPen value. If that
-  is not possible then the variant is set to an empty pen.
-
-  Returns a reference to the stored pen.
-
-  \sa toPen()
-*/
-
-/*!
-    Returns the variant's value as int reference.
-*/
-int& TQVariant::asInt()
-{
-    detach();
-    if ( d->typ != Int ) {
-	int i = toInt();
-	bool b = isNull();
-	d->clear();
- 	d->value.i = i;
-	d->typ = Int;
-	d->is_null = b;
-    }
-    return d->value.i;
-}
-
-/*!
-    Returns the variant's value as unsigned int reference.
-*/
-uint& TQVariant::asUInt()
-{
-    detach();
-    if ( d->typ != UInt ) {
-	uint u = toUInt();
-	bool b = isNull();
-	d->clear();
-	d->value.u = u;
-	d->typ = UInt;
-	d->is_null = b;
-    }
-    return d->value.u;
-}
-
-/*!
-    Returns the variant's value as long long reference.
-*/
-TQ_LLONG& TQVariant::asLongLong()
-{
-    detach();
-    if ( d->typ != LongLong ) {
-	TQ_LLONG ll = toLongLong();
-	bool b = isNull();
-	d->clear();
- 	d->value.ll = ll;
-	d->typ = LongLong;
-	d->is_null = b;
-    }
-    return d->value.ll;
-}
-
-/*!
-    Returns the variant's value as unsigned long long reference.
-*/
-TQ_ULLONG& TQVariant::asULongLong()
-{
-    detach();
-    if ( d->typ != ULongLong ) {
-	TQ_ULLONG ull = toULongLong();
-	bool b = isNull();
-	d->clear();
- 	d->value.ull = ull;
-	d->typ = ULongLong;
-	d->is_null = b;
-    }
-    return d->value.ull;
-}
-
-/*!
-    Returns the variant's value as bool reference.
-*/
-bool& TQVariant::asBool()
-{
-    detach();
-    if ( d->typ != Bool ) {
-	bool b = toBool();
-	bool nb = isNull();
-	d->clear();
-	d->value.b = b;
-	d->typ = Bool;
-	d->is_null = nb;
-    }
-    return d->value.b;
-}
-
-/*!
-    Returns the variant's value as double reference.
-*/
-double& TQVariant::asDouble()
-{
-    detach();
-    if ( d->typ != Double ) {
-	double dbl = toDouble();
-	bool b = isNull();
-	d->clear();
-	d->value.d = dbl;
-	d->typ = Double;
-	d->is_null = b;
-    }
-    return d->value.d;
-}
-
-#ifndef TQT_NO_TEMPLATE_VARIANT
-/*!
-    Returns the variant's value as variant list reference.
-
-    Note that if you want to iterate over the list, you should iterate
-    over a copy, e.g.
-    \code
-    TQValueList<TQVariant> list = myVariant.asList();
-    TQValueList<TQVariant>::Iterator it = list.begin();
-    while( it != list.end() ) {
-	myProcessing( *it );
-	++it;
-    }
-    \endcode
-*/
-TQValueList<TQVariant>& TQVariant::asList()
-{
-    bool b = isNull();
-    if ( d->typ != List )
-	*this = TQVariant( toList() );
-    else
-	detach();
-    d->is_null = b;
-    return *((TQValueList<TQVariant>*)d->value.ptr);
-}
-
-/*!
-    Returns the variant's value as variant map reference.
-
-    Note that if you want to iterate over the map, you should iterate
-    over a copy, e.g.
-    \code
-    TQMap<TQString, TQVariant> map = myVariant.asMap();
-    TQMap<TQString, TQVariant>::Iterator it = map.begin();
-    while( it != map.end() ) {
-	myProcessing( *it );
-	++it;
-    }
-    \endcode
-*/
-TQMap<TQString, TQVariant>& TQVariant::asMap()
-{
-    bool b = isNull();
-    if ( d->typ != Map )
-	*this = TQVariant( toMap() );
-    else
-	detach();
-    d->is_null = b;
-    return *((TQMap<TQString,TQVariant>*)d->value.ptr);
-}
-#endif
-
-/*!
-    Returns TRUE if the variant's type can be cast to the requested
-    type, \a t. Such casting is done automatically when calling the
-    toInt(), toBool(), ... or asInt(), asBool(), ... methods.
-
-    The following casts are done automatically:
-    \table
-    \header \i Type \i Automatically Cast To
-    \row \i Bool \i Double, Int, UInt, LongLong, ULongLong, String, CString, ByteArray
-    \row \i Color \i String. CString. ByteArray
-    \row \i Date \i String, CString, ByteArray, DateTime
-    \row \i DateTime \i String, CString, ByteArray, Date, Time
-    \row \i Double \i String, CString, ByteArray, Int, Bool, UInt, LongLong, ULongLong
-    \row \i Font \i String, CString, ByteArray
-    \row \i Int \i String, CString, ByteArray, Double, Bool, UInt, LongLong, ULongLong, KeySequence
-    \row \i LongLong \i String, CString, ByteArray, Double, Bool, UInt, LongLong, ULongLong, KeySequence
-    \row \i ULongLong \i String, CString, ByteArray, Double, Bool, UInt, LongLong, ULongLong, KeySequence
-    \row \i List \i StringList (if the list contains only strings or
-    something that can be cast to a string)
-    \row \i String \i CString, ByteArray, CString, Int, UInt, Bool, Double, Date,
-    Time, DateTime, KeySequence, Font, Color
-    \row \i CString \i String, ByteArray, Int, UInt, Bool, Double, Date, ULongLong, LongLong
-    \row \i ByteArray \i String, CString, Int, UInt, Bool, Double, Date, ULongLong, LongLong
-    \row \i StringList \i List
-    \row \i Time \i String
-    \row \i Int \i String, CString, ByteArray, Double, Bool, UInt, LongLong, ULongLong, KeySequence
-    \row \i KeySequence \i String, CString, ByteArray, Int, UInt, LongLong, ULongLong
-    \endtable
-*/
-bool TQVariant::canCast( Type t ) const
-{
-    if ( Type( d->typ ) == t )
-	return TRUE;
-
-    switch ( t ) {
-    case Bool:
-    case Double:
-	if (d->typ == KeySequence)
-	    break;
-    case Int:
-    case UInt:
-    case LongLong:
-    case ULongLong:
-	switch(d->typ) {
-	case Bool:
-	case ByteArray:
-	case CString:
-	case Double:
-	case Int:
-	case KeySequence:
-	case LongLong:
-	case String:
-	case UInt:
-	case ULongLong:
-	    return TRUE;
-	default: break;
-	}
-	break;
-
-    case CString:
-    case ByteArray:
-    case String:
-	switch(d->typ) {
-	case Bool:
-	case ByteArray:
-	case CString:
-	case Color:
-	case Date:
-	case DateTime:
-	case Double:
-	case Font:
-	case Int:
-	case KeySequence:
-	case LongLong:
-	case String:
-	case Time:
-	case UInt:
-	case ULongLong:
-	    return TRUE;
-	default: break;
-	}
-	break;
-
-    case Time:
-	if (d->typ == Date)
-	    break;
-    case Date:
-    case DateTime:
-	switch(d->typ) {
-	case ByteArray:
-	case CString:
-	case Date:
-	case DateTime:
-	case String:
-	    return TRUE;
-	default: break;
-	}
-	break;
-
-    case KeySequence:
-	switch(d->typ) {
-	case ByteArray:
-	case CString:
-	case Int:
-	case UInt:
-	case LongLong:
-	case ULongLong:
-	case Double:
-	case String:
-	    return TRUE;
-	default: break;
-	}
-	break;
-
-    case Font:
-    case Color:
-	switch(d->typ) {
-	case ByteArray:
-	case CString:
-	case String:
-	    return TRUE;
-	default: break;
-	}
-	break;
-
-#ifndef TQT_NO_STRINGLIST
-    case List:
-	return d->typ == StringList;
-#endif
-#ifndef TQT_NO_TEMPLATE_VARIANT
-    case StringList:
-	if ( d->typ == List ) {
-	    TQValueList<TQVariant>::ConstIterator it = listBegin();
-	    TQValueList<TQVariant>::ConstIterator end = listEnd();
-	    for( ; it != end; ++it ) {
-		if ( !(*it).canCast( String ) )
-		    return FALSE;
-	    }
-	    return TRUE;
-	}
-#endif
-    case Invalid:
-    case Map:
-    case Pixmap:
-    case Brush:
-    case Rect:
-    case Size:
-    case Palette:
-    case ColorGroup:
-    case IconSet:
-    case Point:
-    case Image:
-    case PointArray:
-    case Region:
-    case Bitmap:
-    case Cursor:
-    case SizePolicy:
-    case BitArray:
-    case Pen:
-	break;
-    }
-    return FALSE;
-}
-
-/*!
-    Casts the variant to the requested type. If the cast cannot be
-    done, the variant is set to the default value of the requested
-    type (e.g. an empty string if the requested type \a t is
-    TQVariant::String, an empty point array if the requested type \a t
-    is TQVariant::PointArray, etc). Returns TRUE if the current type of
-    the variant was successfully cast; otherwise returns FALSE.
-
-    \sa canCast()
-*/
-
-bool TQVariant::cast( Type t )
-{
-    switch ( t ) {
-#ifndef TQT_NO_TEMPLATE_VARIANT
-    case TQVariant::Map:
-	asMap();
-	break;
-    case TQVariant::List:
-	asList();
-	break;
-#endif
-    case TQVariant::String:
-	asString();
-	break;
-#ifndef TQT_NO_STRINGLIST
-    case TQVariant::StringList:
-	asStringList();
-	break;
-#endif
-    case TQVariant::Font:
-	asFont();
-	break;
-    case TQVariant::Pixmap:
-	asPixmap();
-	break;
-    case TQVariant::Brush:
-	asBrush();
-	break;
-    case TQVariant::Rect:
-	asRect();
-	break;
-    case TQVariant::Size:
-	asSize();
-	break;
-    case TQVariant::Color:
-	asColor();
-	break;
-#ifndef TQT_NO_PALETTE
-    case TQVariant::Palette:
-	asPalette();
-	break;
-    case TQVariant::ColorGroup:
-	asColorGroup();
-	break;
-#endif
-#ifndef TQT_NO_ICONSET
-    case TQVariant::IconSet:
-	asIconSet();
-	break;
-#endif
-    case TQVariant::Point:
-	asPoint();
-	break;
-    case TQVariant::Image:
-	asImage();
-	break;
-    case TQVariant::Int:
-	asInt();
-	break;
-    case TQVariant::UInt:
-	asUInt();
-	break;
-    case TQVariant::Bool:
-	asBool();
-	break;
-    case TQVariant::Double:
-	asDouble();
-	break;
-    case TQVariant::CString:
-	asCString();
-	break;
-    case TQVariant::PointArray:
-	asPointArray();
-	break;
-    case TQVariant::Region:
-	asRegion();
-	break;
-    case TQVariant::Bitmap:
-	asBitmap();
-	break;
-    case TQVariant::Cursor:
-	asCursor();
-	break;
-    case TQVariant::SizePolicy:
-	asSizePolicy();
-	break;
-    case TQVariant::Date:
-	asDate();
-	break;
-    case TQVariant::Time:
-	asTime();
-	break;
-    case TQVariant::DateTime:
-	asDateTime();
-	break;
-    case TQVariant::ByteArray:
-	asByteArray();
-	break;
-    case TQVariant::BitArray:
-	asBitArray();
-	break;
-#ifndef TQT_NO_ACCEL
-    case TQVariant::KeySequence:
-	asKeySequence();
-	break;
-#endif
-    case TQVariant::Pen:
-	asPen();
-	break;
-    case TQVariant::LongLong:
-	asLongLong();
-	break;
-    case TQVariant::ULongLong:
-	asULongLong();
-	break;
-    default:
-    case TQVariant::Invalid:
-	(*this) = TQVariant();
-    }
-    return canCast( t );
-}
-
-/*!
-    Compares this TQVariant with \a v and returns TRUE if they are
-    equal; otherwise returns FALSE.
-*/
-
-bool TQVariant::operator==( const TQVariant &v ) const
-{
-    if (isNumeric(v.type()) && canCast(v.type())) {
-	bool ok;
-	switch(v.type()) {
-	case Bool:
-	    return toBool() == v.toBool();
-	case Int:
-	{
-	    int val = toInt(&ok);
-	    return (ok && val == v.toInt());
-	}
-	case UInt:
-	{
-	    uint val = toUInt(&ok);
-	    return (ok && val == v.toUInt());
-	}
-
-	case Double:
-	{
-	    double val = toDouble(&ok);
-	    return (ok && val == v.toDouble());
-	}
-
-	case LongLong:
-	{
-	    TQ_LLONG val = toLongLong(&ok);
-	    return (ok && val == v.toLongLong());
-	}
-
-	case ULongLong:
-	{
-	    TQ_ULLONG val = toULongLong(&ok);
-	    return (ok && val == v.toULongLong());
-	}
-
-	default:
-	    TQ_ASSERT(FALSE);
-	}
-    }
-
-    if (!v.canCast(d->typ)) {
-	return FALSE;
-    }
-
-    switch( d->typ ) {
-    case Cursor:
-#ifndef TQT_NO_CURSOR
-	return v.toCursor().tqshape() == toCursor().tqshape();
-#endif
-    case Bitmap:
-	return v.toBitmap().serialNumber() == toBitmap().serialNumber();
-    case PointArray:
-	return v.toPointArray() == toPointArray();
-    case Region:
-	return v.toRegion() == toRegion();
-#ifndef TQT_NO_TEMPLATE_VARIANT
-    case List:
-	return v.toList() == toList();
-    case Map: {
-	if ( v.toMap().count() != toMap().count() )
-	    return FALSE;
-	TQMap<TQString, TQVariant>::ConstIterator it = v.toMap().begin();
-	TQMap<TQString, TQVariant>::ConstIterator it2 = toMap().begin();
-	while ( it != v.toMap().end() ) {
-	    if ( *it != *it2 )
-		return FALSE;
-	    ++it;
-	    ++it2;
-	}
-	return TRUE;
-    }
-#endif
-    case String:
-	return v.toString() == toString();
-    case CString:
-	return v.toCString() == toCString();
-#ifndef TQT_NO_STRINGLIST
-    case StringList:
-	return v.toStringList() == toStringList();
-#endif
-    case Font:
-	return v.toFont() == toFont();
-    case Pixmap:
-	return v.toPixmap().serialNumber() == toPixmap().serialNumber();
-    case Image:
-	return v.toImage() == toImage();
-    case Brush:
-	return v.toBrush() == toBrush();
-    case Point:
-	return v.toPoint() == toPoint();
-    case Rect:
-	return v.toRect() == toRect();
-    case Size:
-	return v.toSize() == toSize();
-    case Color:
-	return v.toColor() == toColor();
-#ifndef TQT_NO_PALETTE
-    case Palette:
-	return v.toPalette() == toPalette();
-    case ColorGroup:
-	return v.toColorGroup() == toColorGroup();
-#endif
-#ifndef TQT_NO_ICONSET
-    case IconSet:
-	return v.toIconSet().pixmap().serialNumber()
-	    == toIconSet().pixmap().serialNumber();
-#endif
-    case Int:
-	return v.toInt() == toInt();
-    case UInt:
-	return v.toUInt() == toUInt();
-    case LongLong:
-	return v.toLongLong() == toLongLong();
-    case ULongLong:
-	return v.toULongLong() == toULongLong();
-    case Bool:
-	return v.toBool() == toBool();
-    case Double:
-	return v.toDouble() == toDouble();
-    case SizePolicy:
-	return v.toSizePolicy() == toSizePolicy();
-    case Date:
-	return v.toDate() == toDate();
-    case Time:
-	return v.toTime() == toTime();
-    case DateTime:
-	return v.toDateTime() == toDateTime();
-    case ByteArray:
-	return v.toByteArray() == toByteArray();
-    case BitArray:
-	return v.toBitArray() == toBitArray();
-#ifndef TQT_NO_ACCEL
-    case KeySequence:
-	return v.toKeySequence() == toKeySequence();
-#endif
-    case Pen:
-	return v.toPen() == toPen();
-    case Invalid:
-	break;
-    }
-    return FALSE;
-}
-
-/*!
-    Compares this TQVariant with \a v and returns TRUE if they are not
-    equal; otherwise returns FALSE.
-*/
-
-bool TQVariant::operator!=( const TQVariant &v ) const
-{
-    return !( v == *this );
-}
-
-
-/*! \internal
-
-  Reads or sets the variant type and ptr
- */
-void* TQVariant::rawAccess( void* ptr, Type typ, bool deepCopy )
-{
-    if ( ptr ) {
-	clear();
-	d->typ = typ;
-	d->value.ptr = ptr;
-	d->is_null = FALSE;
-	if ( deepCopy ) {
-	    TQVariant::Private* p = new Private( d );
-	    d->typ = Invalid;
-	    delete d;
-	    d = p;
-	}
-    }
-
-    if ( !deepCopy )
-	return d->value.ptr;
-    TQVariant::Private* p = new Private( d );
-    void *ret = (void*)p->value.ptr;
-    p->typ = Invalid;
-    delete p;
-    return ret;
-}
-
-/*!
-  Returns TRUE if this is a NULL variant, FALSE otherwise.
-*/
-bool TQVariant::isNull() const
-{
-    switch( d->typ )
-	{
-	case TQVariant::Bitmap:
-	    return ((TQBitmap*) d->value.ptr)->isNull();
-	case TQVariant::Region:
-	    return ((TQRegion*) d->value.ptr)->isNull();
-	case TQVariant::PointArray:
-	    return ((TQPointArray*) d->value.ptr)->isNull();
-	case TQVariant::String:
-	    return ((TQString*) d->value.ptr)->isNull();
-	case TQVariant::CString:
-	    return ((TQCString*) d->value.ptr)->isNull();
-	case TQVariant::Pixmap:
-	    return ((TQPixmap*) d->value.ptr)->isNull();
-	case TQVariant::Image:
-	    return ((TQImage*) d->value.ptr)->isNull();
-	case TQVariant::Point:
-	    return ((TQPoint*) d->value.ptr)->isNull();
-	case TQVariant::Rect:
-	    return ((TQRect*) d->value.ptr)->isNull();
-	case TQVariant::Size:
-	    return ((TQSize*) d->value.ptr)->isNull();
-#ifndef TQT_NO_ICONSET
-	case TQVariant::IconSet:
-	    return ((TQIconSet*) d->value.ptr)->isNull();
-#endif
-	case TQVariant::Date:
-	    return ((TQDate*) d->value.ptr)->isNull();
-	case TQVariant::Time:
-	    return ((TQTime*) d->value.ptr)->isNull();
-	case TQVariant::DateTime:
-	    return ((TQDateTime*) d->value.ptr)->isNull();
-	case TQVariant::ByteArray:
-	    return ((TQByteArray*) d->value.ptr)->isNull();
-	case TQVariant::BitArray:
-	    return ((TQBitArray*) d->value.ptr)->isNull();
-	case TQVariant::Cursor:
-#ifndef TQT_NO_STRINGLIST
-	case TQVariant::StringList:
-#endif //TQT_NO_STRINGLIST
-	case TQVariant::Font:
-	case TQVariant::Brush:
-	case TQVariant::Color:
-#ifndef TQT_NO_PALETTE
-	case TQVariant::Palette:
-	case TQVariant::ColorGroup:
-#endif
-#ifndef TQT_NO_TEMPLATE_VARIANT
-	case TQVariant::Map:
-	case TQVariant::List:
-#endif
-	case TQVariant::SizePolicy:
-#ifndef TQT_NO_ACCEL
-	case TQVariant::KeySequence:
-#endif
-	case TQVariant::Pen:
-	case TQVariant::Invalid:
-	case TQVariant::Int:
-	case TQVariant::UInt:
-	case TQVariant::LongLong:
-	case TQVariant::ULongLong:
-	case TQVariant::Bool:
-	case TQVariant::Double:
-	    break;
-	}
-    return d->is_null;
-}
-#endif //TQT_NO_VARIANT
-
-#endif // USE_QT4
\ No newline at end of file