diff options
Diffstat (limited to 'libkipi/libkipi/KDStream.cpp')
| -rw-r--r-- | libkipi/libkipi/KDStream.cpp | 1325 |
1 files changed, 647 insertions, 678 deletions
diff --git a/libkipi/libkipi/KDStream.cpp b/libkipi/libkipi/KDStream.cpp index aef327f..3385d5e 100644 --- a/libkipi/libkipi/KDStream.cpp +++ b/libkipi/libkipi/KDStream.cpp @@ -1,10 +1,10 @@ /* -*- Mode: C++ -*- - KD Tools - a set of useful widgets for Qt + KD Tools - a set of useful widgets for TQt $Id: KDStream.cpp 445690 2005-08-11 17:01:49Z toma $ */ /**************************************************************************** -** Copyright (C) 2001-2005 Klarälvdalens Datakonsult AB. All rights reserved. +** Copyright (C) 2001-2005 Klar�lvdalens Datakonsult AB. All rights reserved. ** ** This file is part of the KD Tools library. ** @@ -30,44 +30,42 @@ #endif #include "KDStream.h" -#include <qcolor.h> -#include <qpalette.h> -#include <qcursor.h> -#include <qdatetime.h> -#include <qfont.h> -#include <qpen.h> -#include <qpoint.h> -#include <qsize.h> -#include <qrect.h> -#include <qregion.h> -#include <qobject.h> -#include <qstringlist.h> -#include <qmetaobject.h> -#include <qvariant.h> -#include <qpointarray.h> -#include <qsizepolicy.h> -#include <qbitarray.h> -#include <qstrlist.h> - -#if (QT_VERSION >= 300 ) -#include <qkeysequence.h> -#include <qpixmap.h> -#include <qimage.h> -#endif +#include <tqcolor.h> +#include <tqpalette.h> +#include <tqcursor.h> +#include <tqdatetime.h> +#include <tqfont.h> +#include <tqpen.h> +#include <tqpoint.h> +#include <tqsize.h> +#include <tqrect.h> +#include <tqregion.h> +#include <tqobject.h> +#include <tqstringlist.h> +#include <tqmetaobject.h> +#include <tqvariant.h> +#include <tqpointarray.h> +#include <tqsizepolicy.h> +#include <tqbitarray.h> +#include <tqstrlist.h> + +#include <tqkeysequence.h> +#include <tqpixmap.h> +#include <tqimage.h> /** \file KDStream.cpp \class KDStream KDStream.h - \brief Streaming operators for Qt classes. + \brief Streaming operators for TQt classes. - When debugging Qt programs the streaming operators in this class offers - facilities for printing out values of a number of Qt classes. + When debugging TQt programs the streaming operators in this class offers + facilities for printing out values of a number of TQt classes. Example: \code - QPoint point(10,20); - QString string("A test"); - QFont font = qApp->font(); + TQPoint point(10,20); + TQString string("A test"); + TQFont font = tqApp->font(); KDStream() << "the point is " << point << ", the string is " << string << ", the font is " << font << endl; \endcode */ @@ -76,7 +74,7 @@ /*! Creates a KDStream object. */ -KDStream::KDStream( QString* outputString ) :_out(outputString) +KDStream::KDStream( TQString* outputString ) :_out(outputString) { #if defined KDAB_EVAL EvalDialog::checkEvalLicense( "KD Tools" ); @@ -106,7 +104,7 @@ void KDStream::flush() *_out += _output; else qDebug( "%s", _output.local8Bit().data() ); - _output = QString(); + _output = TQString(); } @@ -116,7 +114,7 @@ void KDStream::flush() */ KDStream& KDStream::operator<<( bool b ) { - _output += ( b ? QString::fromLatin1("true") : QString::fromLatin1("false") ); + _output += ( b ? TQString::tqfromLatin1("true") : TQString::tqfromLatin1("false") ); return *this; } @@ -125,7 +123,7 @@ KDStream& KDStream::operator<<( bool b ) */ KDStream& KDStream::operator<<( char ch ) { - _output += QString::fromLatin1("%1").arg( ch ); + _output += TQString::tqfromLatin1("%1").tqarg( ch ); return *this; } @@ -135,7 +133,7 @@ KDStream& KDStream::operator<<( char ch ) */ KDStream& KDStream::operator<<( float num ) { - _output += QString::number( num ); + _output += TQString::number( num ); return *this; } @@ -145,7 +143,7 @@ KDStream& KDStream::operator<<( float num ) */ KDStream& KDStream::operator<<( double num ) { - _output += QString::number( num ); + _output += TQString::number( num ); return *this; } @@ -155,7 +153,7 @@ KDStream& KDStream::operator<<( double num ) */ KDStream& KDStream::operator<<( short num ) { - _output += QString::number( num ); + _output += TQString::number( num ); return *this; } @@ -164,7 +162,7 @@ KDStream& KDStream::operator<<( short num ) */ KDStream& KDStream::operator<<( unsigned short num ) { - _output += QString::number( num ); + _output += TQString::number( num ); return *this; } @@ -173,7 +171,7 @@ KDStream& KDStream::operator<<( unsigned short num ) */ KDStream& KDStream::operator<<( int num ) { - _output += QString::number( num ); + _output += TQString::number( num ); return *this; } @@ -182,7 +180,7 @@ KDStream& KDStream::operator<<( int num ) */ KDStream& KDStream::operator<<( unsigned int num ) { - _output += QString::number( num ); + _output += TQString::number( num ); return *this; } @@ -191,7 +189,7 @@ KDStream& KDStream::operator<<( unsigned int num ) */ KDStream& KDStream::operator<<( long num ) { - _output += QString::number( num ); + _output += TQString::number( num ); return *this; } @@ -200,7 +198,7 @@ KDStream& KDStream::operator<<( long num ) */ KDStream& KDStream::operator<<( unsigned long num ) { - _output += QString::number( num ); + _output += TQString::number( num ); return *this; } @@ -209,7 +207,7 @@ KDStream& KDStream::operator<<( unsigned long num ) */ KDStream& KDStream::operator<<( const char* ch ) { - *this << QString::fromLocal8Bit( ch ); + *this << TQString(TQString::fromLocal8Bit( ch )); return *this; } @@ -219,17 +217,17 @@ KDStream& KDStream::operator<<( const char* ch ) */ KDStream& KDStream::operator<<( const void* p) { - _output += QString().sprintf("%p",p); + _output += TQString().sprintf("%p",p); return *this; } /*! - Writes a QString value to the stream. + Writes a TQString value to the stream. */ -KDStream& KDStream::operator<<( const QString& str ) +KDStream& KDStream::operator<<( const TQString& str ) { - int index = str.findRev( '\n' ); + int index = str.tqfindRev( '\n' ); if ( index == -1 ) _output += str; else { @@ -241,11 +239,11 @@ KDStream& KDStream::operator<<( const QString& str ) } /*! - Writes a QCString value to the stream. + Writes a TQCString value to the stream. */ -KDStream& KDStream::operator<<( const QCString& str ) +KDStream& KDStream::operator<<( const TQCString& str ) { - *this << QString( str ); + *this << TQString( str ); return *this; } @@ -263,7 +261,7 @@ KDStream& KDStream::operator<<( KDSTREAMFUNC func ) */ KDStream& endl( KDStream& stream) { - stream << QString::fromLatin1("\n"); + stream << TQString::tqfromLatin1("\n"); stream.flush(); return stream; } @@ -278,106 +276,87 @@ KDStream& flush( KDStream& stream) } /*! - Writes a QChar value to the stream. + Writes a TQChar value to the stream. */ -KDStream& KDStream::operator<<( const QChar& ch ) +KDStream& KDStream::operator<<( const TQChar& ch ) { - _output += QString( ch ); + _output += TQString( ch ); return *this; } /*! - Writes a QColor value to the stream. See \ref QColor2Str for a + Writes a TQColor value to the stream. See \ref TQColor2Str for a description of the output format. */ -KDStream& KDStream::operator<<( const QColor& col ) +KDStream& KDStream::operator<<( const TQColor& col ) { - _output += QColor2Str( col ); + _output += TQColor2Str( col ); return *this; } /*! - Writes a QColorGroup value to the stream. Each color role output + Writes a TQColorGroup value to the stream. Each color role output with its name and the corresponding color value. */ -KDStream& KDStream::operator<<( const QColorGroup& colgrp ) +KDStream& KDStream::operator<<( const TQColorGroup& colgrp ) { _output += - QString::fromLatin1("foreground: ") + QColor2Str(colgrp.foreground()) + QString::fromLatin1(", ") + - QString::fromLatin1("button: ") + QColor2Str(colgrp.button()) + QString::fromLatin1(", ") + - QString::fromLatin1("light: ") + QColor2Str(colgrp.light()) + QString::fromLatin1(", ") + - QString::fromLatin1("dark: ") + QColor2Str(colgrp.dark()) + QString::fromLatin1(", ") + - QString::fromLatin1("mid: ") + QColor2Str(colgrp.mid()) + QString::fromLatin1(", ") + - QString::fromLatin1("text: ") + QColor2Str(colgrp.text()) + QString::fromLatin1(", ") + - QString::fromLatin1("base: ") + QColor2Str(colgrp.base()) + QString::fromLatin1(", ") + - QString::fromLatin1("background: ") + QColor2Str(colgrp.background()) + QString::fromLatin1(", ") + - QString::fromLatin1("midlight: ") + QColor2Str(colgrp.midlight()) + QString::fromLatin1(", ") + - QString::fromLatin1("brightText: ") + QColor2Str(colgrp.brightText()) + QString::fromLatin1(", ") + - QString::fromLatin1("buttonText: ") + QColor2Str(colgrp.buttonText()) + QString::fromLatin1(", ") + - QString::fromLatin1("shadow: ") + QColor2Str(colgrp.shadow()) + QString::fromLatin1(", ") + - QString::fromLatin1("highlight: ") + QColor2Str(colgrp.highlight()) + QString::fromLatin1(", ") + - QString::fromLatin1("highlightedText: ") + QColor2Str(colgrp.highlightedText()); + TQString::tqfromLatin1("foreground: ") + TQColor2Str(colgrp.foreground()) + TQString::tqfromLatin1(", ") + + TQString::tqfromLatin1("button: ") + TQColor2Str(colgrp.button()) + TQString::tqfromLatin1(", ") + + TQString::tqfromLatin1("light: ") + TQColor2Str(colgrp.light()) + TQString::tqfromLatin1(", ") + + TQString::tqfromLatin1("dark: ") + TQColor2Str(colgrp.dark()) + TQString::tqfromLatin1(", ") + + TQString::tqfromLatin1("mid: ") + TQColor2Str(colgrp.mid()) + TQString::tqfromLatin1(", ") + + TQString::tqfromLatin1("text: ") + TQColor2Str(colgrp.text()) + TQString::tqfromLatin1(", ") + + TQString::tqfromLatin1("base: ") + TQColor2Str(colgrp.base()) + TQString::tqfromLatin1(", ") + + TQString::tqfromLatin1("background: ") + TQColor2Str(colgrp.background()) + TQString::tqfromLatin1(", ") + + TQString::tqfromLatin1("midlight: ") + TQColor2Str(colgrp.midlight()) + TQString::tqfromLatin1(", ") + + TQString::tqfromLatin1("brightText: ") + TQColor2Str(colgrp.brightText()) + TQString::tqfromLatin1(", ") + + TQString::tqfromLatin1("buttonText: ") + TQColor2Str(colgrp.buttonText()) + TQString::tqfromLatin1(", ") + + TQString::tqfromLatin1("shadow: ") + TQColor2Str(colgrp.shadow()) + TQString::tqfromLatin1(", ") + + TQString::tqfromLatin1("highlight: ") + TQColor2Str(colgrp.highlight()) + TQString::tqfromLatin1(", ") + + TQString::tqfromLatin1("highlightedText: ") + TQColor2Str(colgrp.highlightedText()); return *this; } /*! - Writes a QPalette value to the stream. Each color group is output - with its role and the corresponding QColorGroup value. + Writes a TQPalette value to the stream. Each color group is output + with its role and the corresponding TQColorGroup value. */ -KDStream& KDStream::operator<<( const QPalette& palette ) +KDStream& KDStream::operator<<( const TQPalette& palette ) { - *this << QString::fromLatin1("active: ") << palette.active() << endl - << QString::fromLatin1("inactive: ") << palette.inactive() << endl - << QString::fromLatin1("diabled: ") << palette.disabled(); + *this << TQString::tqfromLatin1("active: ") << palette.active() << endl + << TQString::tqfromLatin1("inactive: ") << palette.inactive() << endl + << TQString::tqfromLatin1("diabled: ") << palette.disabled(); return *this; } /*! - Writes a QCursor value to the stream. Each cursor is output with its - name as listed in the \a QCursor reference documentation. + Writes a TQCursor value to the stream. Each cursor is output with its + name as listed in the \a TQCursor reference documentation. */ -KDStream& KDStream::operator<<( const QCursor& cursor ) +KDStream& KDStream::operator<<( const TQCursor& cursor ) { - QString type; - switch ( cursor.shape() ) { -#if ( QT_VERSION < 300 ) - case ArrowCursor: type = QString::fromLatin1("ArrowCursor"); break; - case UpArrowCursor: type = QString::fromLatin1("UpArrowCursor"); break; - case CrossCursor: type = QString::fromLatin1("CrossCursor"); break; - case WaitCursor: type = QString::fromLatin1("WaitCursor"); break; - case IbeamCursor: type = QString::fromLatin1("IbeamCursor"); break; - case SizeVerCursor: type = QString::fromLatin1("SizeVerCursor"); break; - case SizeHorCursor: type = QString::fromLatin1("SizeHorCursor"); break; - case SizeBDiagCursor: type = QString::fromLatin1("SizeBDiagCursor"); break; - case SizeFDiagCursor: type = QString::fromLatin1("SizeFDiagCursor"); break; - case SizeAllCursor: type = QString::fromLatin1("SizeAllCursor"); break; - case BlankCursor: type = QString::fromLatin1("BlankCursor"); break; - case SplitVCursor: type = QString::fromLatin1("SplitVCursor"); break; - case SplitHCursor: type = QString::fromLatin1("SplitHCursor"); break; - case PointingHandCursor: type = QString::fromLatin1("PointingHandCursor"); break; - case ForbiddenCursor: type = QString::fromLatin1("ForbiddenCursor"); break; - case BitmapCursor: type = QString::fromLatin1("BitmapCursor"); break; -#else - case Qt::ArrowCursor: type = QString::fromLatin1("ArrowCursor"); break; - case Qt::UpArrowCursor: type = QString::fromLatin1("UpArrowCursor"); break; - case Qt::CrossCursor: type = QString::fromLatin1("CrossCursor"); break; - case Qt::WaitCursor: type = QString::fromLatin1("WaitCursor"); break; - case Qt::IbeamCursor: type = QString::fromLatin1("IbeamCursor"); break; - case Qt::SizeVerCursor: type = QString::fromLatin1("SizeVerCursor"); break; - case Qt::SizeHorCursor: type = QString::fromLatin1("SizeHorCursor"); break; - case Qt::SizeBDiagCursor: type = QString::fromLatin1("SizeBDiagCursor"); break; - case Qt::SizeFDiagCursor: type = QString::fromLatin1("SizeFDiagCursor"); break; - case Qt::SizeAllCursor: type = QString::fromLatin1("SizeAllCursor"); break; - case Qt::BlankCursor: type = QString::fromLatin1("BlankCursor"); break; - case Qt::SplitVCursor: type = QString::fromLatin1("SplitVCursor"); break; - case Qt::SplitHCursor: type = QString::fromLatin1("SplitHCursor"); break; - case Qt::PointingHandCursor: type = QString::fromLatin1("PointingHandCursor"); break; - case Qt::ForbiddenCursor: type = QString::fromLatin1("ForbiddenCursor"); break; - case Qt::BitmapCursor: type = QString::fromLatin1("BitmapCursor"); break; -#endif + TQString type; + switch ( cursor.tqshape() ) { + case TQt::ArrowCursor: type = TQString::tqfromLatin1("ArrowCursor"); break; + case TQt::UpArrowCursor: type = TQString::tqfromLatin1("UpArrowCursor"); break; + case TQt::CrossCursor: type = TQString::tqfromLatin1("CrossCursor"); break; + case TQt::WaitCursor: type = TQString::tqfromLatin1("WaitCursor"); break; + case TQt::IbeamCursor: type = TQString::tqfromLatin1("IbeamCursor"); break; + case TQt::SizeVerCursor: type = TQString::tqfromLatin1("SizeVerCursor"); break; + case TQt::SizeHorCursor: type = TQString::tqfromLatin1("SizeHorCursor"); break; + case TQt::SizeBDiagCursor: type = TQString::tqfromLatin1("SizeBDiagCursor"); break; + case TQt::SizeFDiagCursor: type = TQString::tqfromLatin1("SizeFDiagCursor"); break; + case TQt::SizeAllCursor: type = TQString::tqfromLatin1("SizeAllCursor"); break; + case TQt::BlankCursor: type = TQString::tqfromLatin1("BlankCursor"); break; + case TQt::SplitVCursor: type = TQString::tqfromLatin1("SplitVCursor"); break; + case TQt::SplitHCursor: type = TQString::tqfromLatin1("SplitHCursor"); break; + case TQt::PointingHandCursor: type = TQString::tqfromLatin1("PointingHandCursor"); break; + case TQt::ForbiddenCursor: type = TQString::tqfromLatin1("ForbiddenCursor"); break; + case TQt::BitmapCursor: type = TQString::tqfromLatin1("BitmapCursor"); break; } _output += type; @@ -386,701 +365,691 @@ KDStream& KDStream::operator<<( const QCursor& cursor ) } /*! - Writes a QDate value to the stream. The format is the one defined by - QDate::toString() and may be system-dependent. + Writes a TQDate value to the stream. The format is the one defined by + TQDate::toString() and may be system-dependent. */ -KDStream& KDStream::operator<<( const QDate& date ) +KDStream& KDStream::operator<<( const TQDate& date ) { _output += date.toString(); return *this; } /*! - Writes a QDateTime value to the stream. The format is the one - defined by QDateTime::toString() and may be system-dependent. + Writes a TQDateTime value to the stream. The format is the one + defined by TQDateTime::toString() and may be system-dependent. */ -KDStream& KDStream::operator<<( const QDateTime& datetime ) +KDStream& KDStream::operator<<( const TQDateTime& datetime ) { _output += datetime.toString(); return *this; } /*! - Writes a QTime value to the stream. The format is the one defined by - QTime::toString() and may be system-dependent. + Writes a TQTime value to the stream. The format is the one defined by + TQTime::toString() and may be system-dependent. */ -KDStream& KDStream::operator<<( const QTime& time ) +KDStream& KDStream::operator<<( const TQTime& time ) { _output += time.toString(); return *this; } /*! - Writes a the raw name of a QFont value to the stream. + Writes a the raw name of a TQFont value to the stream. */ -KDStream& KDStream::operator<<( const QFont& font ) +KDStream& KDStream::operator<<( const TQFont& font ) { _output += font.rawName(); return *this; } /*! - Writes a QPen value to the stream. The format is "QPen" plus the - width, the color, and the style as defined in the \a QPen reference + Writes a TQPen value to the stream. The format is "TQPen" plus the + width, the color, and the style as defined in the \a TQPen reference documentation. */ -KDStream& KDStream::operator<<( const QPen& pen ) +KDStream& KDStream::operator<<( const TQPen& pen ) { - QString style; + TQString style; switch ( pen.style() ) { - case Qt::NoPen: style = QString::fromLatin1("NoPen"); break; - case Qt::SolidLine: style = QString::fromLatin1("SolidLine"); break; - case Qt::DashLine: style = QString::fromLatin1("DashLine"); break; - case Qt::DotLine: style = QString::fromLatin1("DotLine"); break; - case Qt::DashDotLine: style = QString::fromLatin1("DashDotLine"); break; - case Qt::DashDotDotLine : style = QString::fromLatin1("DashDotDotLine "); break; - case Qt::MPenStyle : break; // ignore + case TQt::NoPen: style = TQString::tqfromLatin1("NoPen"); break; + case TQt::SolidLine: style = TQString::tqfromLatin1("SolidLine"); break; + case TQt::DashLine: style = TQString::tqfromLatin1("DashLine"); break; + case TQt::DotLine: style = TQString::tqfromLatin1("DotLine"); break; + case TQt::DashDotLine: style = TQString::tqfromLatin1("DashDotLine"); break; + case TQt::DashDotDotLine : style = TQString::tqfromLatin1("DashDotDotLine "); break; + case TQt::MPenStyle : break; // ignore } - _output += QString::fromLatin1("QPen(%1,%2,%3)") - .arg( pen.width() ) - .arg( QColor2Str( pen.color() ) ) - .arg( style ); + _output += TQString::tqfromLatin1("TQPen(%1,%2,%3)") + .tqarg( pen.width() ) + .tqarg( TQColor2Str( pen.color() ) ) + .tqarg( style ); return *this; } /*! - Writes a QPoint value to the stream. The format is "(x,y)". + Writes a TQPoint value to the stream. The format is "(x,y)". */ -KDStream& KDStream::operator<<( const QPoint& point ) +KDStream& KDStream::operator<<( const TQPoint& point ) { - _output += QString::fromLatin1("(%1,%2)").arg(point.x()).arg(point.y() ); + _output += TQString::tqfromLatin1("(%1,%2)").tqarg(point.x()).tqarg(point.y() ); return *this; } /*! - Writes a QSize value to the stream. The format is "(w x h)". + Writes a TQSize value to the stream. The format is "(w x h)". */ -KDStream& KDStream::operator<<( const QSize& size ) +KDStream& KDStream::operator<<( const TQSize& size ) { - _output += QString::fromLatin1("%1x%2").arg(size.width()).arg(size.height()); + _output += TQString::tqfromLatin1("%1x%2").tqarg(size.width()).tqarg(size.height()); return *this; } /*! - Writes a QRect value to the stream. The format is "(width x height + Writes a TQRect value to the stream. The format is "(width x height xoffset xpos yoffset ypos)". */ -KDStream& KDStream::operator<<( const QRect& rect ) +KDStream& KDStream::operator<<( const TQRect& rect ) { - QString xplus = (rect.x() >= 0) ? QString::fromLatin1("+") : QString::fromLatin1(""); - QString yplus = (rect.y() >= 0) ? QString::fromLatin1("+") : QString::fromLatin1(""); - _output += QString::fromLatin1("%1x%2%3%4%5%6") - .arg( rect.width() ) - .arg( rect.height() ) - .arg( xplus ) - .arg( rect.x() ) - .arg( yplus ) - .arg( rect.y() ); + TQString xplus = (rect.x() >= 0) ? TQString::tqfromLatin1("+") : TQString::tqfromLatin1(""); + TQString yplus = (rect.y() >= 0) ? TQString::tqfromLatin1("+") : TQString::tqfromLatin1(""); + _output += TQString::tqfromLatin1("%1x%2%3%4%5%6") + .tqarg( rect.width() ) + .tqarg( rect.height() ) + .tqarg( xplus ) + .tqarg( rect.x() ) + .tqarg( yplus ) + .tqarg( rect.y() ); return *this; } /*! - This is a helper method that converts a QColor object into a - string. For the predefined Qt colors, their name is output, for all + This is a helper method that converts a TQColor object into a + string. For the predefined TQt colors, their name is output, for all other colors, the output is in the form #RRGGBB (as defined by - QColor::name()). + TQColor::name()). */ -QString KDStream::QColor2Str( const QColor& col ) +TQString KDStream::TQColor2Str( const TQColor& col ) { - if ( col == Qt::black ) - return QString::fromLatin1("black"); - else if ( col == Qt::white ) - return QString::fromLatin1("white"); - else if ( col == Qt::darkGray ) - return QString::fromLatin1("darkGray"); - else if ( col == Qt::gray ) - return QString::fromLatin1("gray"); - else if ( col == Qt::lightGray ) - return QString::fromLatin1("lightGray"); - else if ( col == Qt::red ) - return QString::fromLatin1("red"); - else if ( col == Qt::green ) - return QString::fromLatin1("green"); - else if ( col == Qt::blue ) - return QString::fromLatin1("blue"); - else if ( col == Qt::cyan ) - return QString::fromLatin1("cyan"); - else if ( col == Qt::magenta ) - return QString::fromLatin1("magenta"); - else if ( col == Qt::yellow ) - return QString::fromLatin1("yellow"); - else if ( col == Qt::darkRed ) - return QString::fromLatin1("darkRed"); - else if ( col == Qt::darkGreen ) - return QString::fromLatin1("darkGreen"); - else if ( col == Qt::darkBlue ) - return QString::fromLatin1("darkBlue"); - else if ( col == Qt::darkCyan ) - return QString::fromLatin1("darkCyan"); - else if ( col == Qt::darkMagenta ) - return QString::fromLatin1("darkMagenta"); - else if ( col == Qt::darkYellow ) - return QString::fromLatin1("darkYellow"); - else if ( col == Qt::color0 ) - return QString::fromLatin1("color0"); - else if ( col == Qt::color1 ) - return QString::fromLatin1("color1"); + if ( col == TQt::black ) + return TQString::tqfromLatin1("black"); + else if ( col == TQt::white ) + return TQString::tqfromLatin1("white"); + else if ( col == TQt::darkGray ) + return TQString::tqfromLatin1("darkGray"); + else if ( col == TQt::gray ) + return TQString::tqfromLatin1("gray"); + else if ( col == TQt::lightGray ) + return TQString::tqfromLatin1("lightGray"); + else if ( col == TQt::red ) + return TQString::tqfromLatin1("red"); + else if ( col == TQt::green ) + return TQString::tqfromLatin1("green"); + else if ( col == TQt::blue ) + return TQString::tqfromLatin1("blue"); + else if ( col == TQt::cyan ) + return TQString::tqfromLatin1("cyan"); + else if ( col == TQt::magenta ) + return TQString::tqfromLatin1("magenta"); + else if ( col == TQt::yellow ) + return TQString::tqfromLatin1("yellow"); + else if ( col == TQt::darkRed ) + return TQString::tqfromLatin1("darkRed"); + else if ( col == TQt::darkGreen ) + return TQString::tqfromLatin1("darkGreen"); + else if ( col == TQt::darkBlue ) + return TQString::tqfromLatin1("darkBlue"); + else if ( col == TQt::darkCyan ) + return TQString::tqfromLatin1("darkCyan"); + else if ( col == TQt::darkMagenta ) + return TQString::tqfromLatin1("darkMagenta"); + else if ( col == TQt::darkYellow ) + return TQString::tqfromLatin1("darkYellow"); + else if ( col == TQt::color0 ) + return TQString::tqfromLatin1("color0"); + else if ( col == TQt::color1 ) + return TQString::tqfromLatin1("color1"); else return col.name(); } /*! - Writes a QObject value to the stream. Included information is the + Writes a TQObject value to the stream. Included information is the class name, the object name, the properties and their types. */ -KDStream& KDStream::operator<<( const QObject& obj ) +KDStream& KDStream::operator<<( const TQObject& obj ) { - *this << QString::fromLatin1(obj.className()) + QString::fromLatin1("(") + QString::fromLatin1(obj.name()) << QString::fromLatin1("):")<< endl; - QMetaObject* meta = obj.metaObject(); - QStrList props = meta->propertyNames(true); + *this << TQString::tqfromLatin1(obj.className()) + TQString::tqfromLatin1("(") + TQString::tqfromLatin1(obj.name()) << TQString::tqfromLatin1("):")<< endl; + TQMetaObject* meta = obj.tqmetaObject(); + TQStrList props = meta->propertyNames(true); unsigned int maxWidth = 0; - for ( QStrListIterator it(props) ; *it; ++it ) { - maxWidth = QMAX( maxWidth, QString::fromLatin1(*it).length() ); + for ( TQStrListIterator it(props) ; *it; ++it ) { + maxWidth = TQMAX( maxWidth, TQString::tqfromLatin1(*it).length() ); } - for ( QStrListIterator it2(props) ; *it2; ++it2 ) { - *this << QString::fromLatin1(" ") << QString::fromLatin1(*it2).leftJustify(maxWidth) << QString::fromLatin1(": [") << obj.property(*it2) << QString::fromLatin1("]") << endl; + for ( TQStrListIterator it2(props) ; *it2; ++it2 ) { + *this << TQString::tqfromLatin1(" ") << TQString::tqfromLatin1(*it2).leftJustify(maxWidth) << TQString::tqfromLatin1(": [") << obj.property(*it2) << TQString::tqfromLatin1("]") << endl; } return *this; } /*! - Writes a QVariant value to the stream. The format is dependent on - the actual contents of the QVariant object. + Writes a TQVariant value to the stream. The format is dependent on + the actual contents of the TQVariant object. */ -KDStream& KDStream::operator<<( const QVariant& var) +KDStream& KDStream::operator<<( const TQVariant& var) { switch (var.type() ) { - case QVariant::Invalid: *this << QString::fromLatin1("*INVALID*"); break; - case QVariant::Map: *this << var.toMap(); break; - case QVariant::List: *this << var.toList(); break; - case QVariant::String: *this << var.toString(); break; - case QVariant::StringList: *this << var.toStringList(); break; - case QVariant::Font: *this << var.toFont(); break; - case QVariant::Pixmap: *this << var.toPixmap();break; - - case QVariant::Brush: *this << var.toBrush(); break; - case QVariant::Rect: *this << var.toRect(); break; - case QVariant::Size: *this << var.toSize(); break; - case QVariant::Color: *this << var.toColor(); break; - case QVariant::Palette: *this << var.toPalette(); break; - case QVariant::ColorGroup: *this << var.toColorGroup(); break; - case QVariant::IconSet: *this << QString::fromLatin1("-"); break; - case QVariant::Point: *this << var.toPoint(); break; - case QVariant::Image: *this << var.toImage(); break; - case QVariant::Int: *this << var.toInt(); break; - case QVariant::UInt: *this << var.toUInt(); break; - case QVariant::Bool: *this << var.toBool(); break; - case QVariant::Double: *this << var.toDouble(); break; - case QVariant::CString: *this << var.toCString(); break; - case QVariant::PointArray: *this << var.toPointArray(); break; - case QVariant::Region: *this << QString::fromLatin1("-"); break; - case QVariant::Bitmap: *this << QString::fromLatin1("-"); break; - case QVariant::Cursor: *this << var.toCursor(); break; - case QVariant::SizePolicy: *this << var.toSizePolicy(); break; -#if ( QT_VERSION >= 300 ) - case QVariant::Date: *this << var.toDate(); break; - case QVariant::Time: *this << var.toTime(); break; - case QVariant::DateTime: *this << var.toDateTime(); break; - case QVariant::ByteArray: *this << var.toByteArray(); break; - case QVariant::BitArray: *this << var.toBitArray(); break; - case QVariant::KeySequence: *this << var.toKeySequence(); break; -#if ( QT_VERSION >= 0x030100 ) - case QVariant::Pen: *this << var.toPen(); break; -#endif -#endif + case TQVariant::Invalid: *this << TQString::tqfromLatin1("*INVALID*"); break; + case TQVariant::Map: *this << var.toMap(); break; + case TQVariant::List: *this << var.toList(); break; + case TQVariant::String: *this << var.toString(); break; + case TQVariant::StringList: *this << var.toStringList(); break; + case TQVariant::Font: *this << var.toFont(); break; + case TQVariant::Pixmap: *this << var.toPixmap();break; + + case TQVariant::Brush: *this << var.toBrush(); break; + case TQVariant::Rect: *this << var.toRect(); break; + case TQVariant::Size: *this << var.toSize(); break; + case TQVariant::Color: *this << var.toColor(); break; + case TQVariant::Palette: *this << var.toPalette(); break; + case TQVariant::ColorGroup: *this << var.toColorGroup(); break; + case TQVariant::IconSet: *this << TQString::tqfromLatin1("-"); break; + case TQVariant::Point: *this << var.toPoint(); break; + case TQVariant::Image: *this << var.toImage(); break; + case TQVariant::Int: *this << var.toInt(); break; + case TQVariant::UInt: *this << var.toUInt(); break; + case TQVariant::Bool: *this << var.toBool(); break; + case TQVariant::Double: *this << var.toDouble(); break; + case TQVariant::CString: *this << var.toCString(); break; + case TQVariant::PointArray: *this << var.toPointArray(); break; + case TQVariant::Region: *this << TQString::tqfromLatin1("-"); break; + case TQVariant::Bitmap: *this << TQString::tqfromLatin1("-"); break; + case TQVariant::Cursor: *this << var.toCursor(); break; + case TQVariant::SizePolicy: *this << var.toSizePolicy(); break; + case TQVariant::Date: *this << var.toDate(); break; + case TQVariant::Time: *this << var.toTime(); break; + case TQVariant::DateTime: *this << var.toDateTime(); break; + case TQVariant::ByteArray: *this << TQCString(var.toByteArray()); break; + case TQVariant::BitArray: *this << var.toBitArray(); break; + case TQVariant::KeySequence: *this << var.toKeySequence(); break; + case TQVariant::Pen: *this << var.toPen(); break; } return *this; } /*! - Writes a QBrush value to the stream. The format is "QBrush" plus the - brush style as listed in the \a QBrush reference documentation and + Writes a TQBrush value to the stream. The format is "TQBrush" plus the + brush style as listed in the \a TQBrush reference documentation and the brush color. */ -KDStream& KDStream::operator<<( const QBrush& brush) +KDStream& KDStream::operator<<( const TQBrush& brush) { - QString style; + TQString style; switch ( brush.style() ) { - case Qt::NoBrush: style = QString::fromLatin1("NoBrush"); break; - case Qt::SolidPattern: style = QString::fromLatin1("SolidPattern"); break; - case Qt::Dense1Pattern: style = QString::fromLatin1("Dense1Pattern"); break; - case Qt::Dense2Pattern: style = QString::fromLatin1("Dense2Pattern"); break; - case Qt::Dense3Pattern: style = QString::fromLatin1("Dense3Pattern"); break; - case Qt::Dense4Pattern: style = QString::fromLatin1("Dense4Pattern"); break; - case Qt::Dense5Pattern: style = QString::fromLatin1("Dense5Pattern"); break; - case Qt::Dense6Pattern: style = QString::fromLatin1("Dense6Pattern"); break; - case Qt::Dense7Pattern: style = QString::fromLatin1("Dense7Pattern"); break; - case Qt::HorPattern: style = QString::fromLatin1("HorPattern"); break; - case Qt::VerPattern: style = QString::fromLatin1("VerPattern"); break; - case Qt::CrossPattern: style = QString::fromLatin1("CrossPattern"); break; - case Qt::BDiagPattern: style = QString::fromLatin1("BDiagPattern"); break; - case Qt::FDiagPattern: style = QString::fromLatin1("FDiagPattern"); break; - case Qt::DiagCrossPattern: style = QString::fromLatin1("DiagCrossPattern"); break; - case Qt::CustomPattern: style = QString::fromLatin1("CustomPattern"); break; + case TQt::NoBrush: style = TQString::tqfromLatin1("NoBrush"); break; + case TQt::SolidPattern: style = TQString::tqfromLatin1("SolidPattern"); break; + case TQt::Dense1Pattern: style = TQString::tqfromLatin1("Dense1Pattern"); break; + case TQt::Dense2Pattern: style = TQString::tqfromLatin1("Dense2Pattern"); break; + case TQt::Dense3Pattern: style = TQString::tqfromLatin1("Dense3Pattern"); break; + case TQt::Dense4Pattern: style = TQString::tqfromLatin1("Dense4Pattern"); break; + case TQt::Dense5Pattern: style = TQString::tqfromLatin1("Dense5Pattern"); break; + case TQt::Dense6Pattern: style = TQString::tqfromLatin1("Dense6Pattern"); break; + case TQt::Dense7Pattern: style = TQString::tqfromLatin1("Dense7Pattern"); break; + case TQt::HorPattern: style = TQString::tqfromLatin1("HorPattern"); break; + case TQt::VerPattern: style = TQString::tqfromLatin1("VerPattern"); break; + case TQt::CrossPattern: style = TQString::tqfromLatin1("CrossPattern"); break; + case TQt::BDiagPattern: style = TQString::tqfromLatin1("BDiagPattern"); break; + case TQt::FDiagPattern: style = TQString::tqfromLatin1("FDiagPattern"); break; + case TQt::DiagCrossPattern: style = TQString::tqfromLatin1("DiagCrossPattern"); break; + case TQt::CustomPattern: style = TQString::tqfromLatin1("CustomPattern"); break; } - _output += QString::fromLatin1("QBrush(%1,%2)").arg(style).arg(QColor2Str(brush.color())); + _output += TQString::tqfromLatin1("TQBrush(%1,%2)").tqarg(style).tqarg(TQColor2Str(brush.color())); return *this; } /*! - Writes a QSizePolicy value to the stream. The output contains the + Writes a TQSizePolicy value to the stream. The output contains the horizontal and vertical size policy and whether the policy has a "height for width" setting. */ -KDStream& KDStream::operator<<( const QSizePolicy& policy) +KDStream& KDStream::operator<<( const TQSizePolicy& policy) { - QString hor, ver; + TQString hor, ver; switch ( policy.horData() ) { - case QSizePolicy::Fixed: hor=QString::fromLatin1("Fixed"); break; - case QSizePolicy::Minimum : hor=QString::fromLatin1("Minimum "); break; - case QSizePolicy::Maximum: hor=QString::fromLatin1("Maximum"); break; - case QSizePolicy::Preferred: hor=QString::fromLatin1("Preferred"); break; - case QSizePolicy::MinimumExpanding: hor=QString::fromLatin1("MinimumExpanding"); break; - case QSizePolicy::Expanding: hor=QString::fromLatin1("Expanding"); break; -#if ( QT_VERSION >= 300 ) - case QSizePolicy::Ignored: hor=QString::fromLatin1("Ignored"); break; -#endif + case TQSizePolicy::Fixed: hor=TQString::tqfromLatin1("Fixed"); break; + case TQSizePolicy::Minimum : hor=TQString::tqfromLatin1("Minimum "); break; + case TQSizePolicy::Maximum: hor=TQString::tqfromLatin1("Maximum"); break; + case TQSizePolicy::Preferred: hor=TQString::tqfromLatin1("Preferred"); break; + case TQSizePolicy::MinimumExpanding: hor=TQString::tqfromLatin1("MinimumExpanding"); break; + case TQSizePolicy::Expanding: hor=TQString::tqfromLatin1("Expanding"); break; + case TQSizePolicy::Ignored: hor=TQString::tqfromLatin1("Ignored"); break; } switch ( policy.verData() ) { - case QSizePolicy::Fixed: ver=QString::fromLatin1("Fixed"); break; - case QSizePolicy::Minimum : ver=QString::fromLatin1("Minimum "); break; - case QSizePolicy::Maximum: ver=QString::fromLatin1("Maximum"); break; - case QSizePolicy::Preferred: ver=QString::fromLatin1("Preferred"); break; - case QSizePolicy::MinimumExpanding: ver=QString::fromLatin1("MinimumExpanding"); break; - case QSizePolicy::Expanding: ver=QString::fromLatin1("Expanding"); break; -#if ( QT_VERSION >= 300 ) - case QSizePolicy::Ignored: ver=QString::fromLatin1("Ignored"); break; -#endif + case TQSizePolicy::Fixed: ver=TQString::tqfromLatin1("Fixed"); break; + case TQSizePolicy::Minimum : ver=TQString::tqfromLatin1("Minimum "); break; + case TQSizePolicy::Maximum: ver=TQString::tqfromLatin1("Maximum"); break; + case TQSizePolicy::Preferred: ver=TQString::tqfromLatin1("Preferred"); break; + case TQSizePolicy::MinimumExpanding: ver=TQString::tqfromLatin1("MinimumExpanding"); break; + case TQSizePolicy::Expanding: ver=TQString::tqfromLatin1("Expanding"); break; + case TQSizePolicy::Ignored: ver=TQString::tqfromLatin1("Ignored"); break; } - QString hforw = policy.hasHeightForWidth() ? QString::fromLatin1("true") : QString::fromLatin1("false"); - _output += QString::fromLatin1("QSizePolicy(hor=%1,ver=%2, hasHeightForWidth=%3)") - .arg(hor).arg(ver).arg(hforw); + TQString hforw = policy.hasHeightForWidth() ? TQString::tqfromLatin1("true") : TQString::tqfromLatin1("false"); + _output += TQString::tqfromLatin1("TQSizePolicy(hor=%1,ver=%2, hasHeightForWidth=%3)") + .tqarg(hor).tqarg(ver).tqarg(hforw); return *this; } -#if ( QT_VERSION >= 300 ) /*! - Writes a QKeySequence value to the stream. The output format is the + Writes a TQKeySequence value to the stream. The output format is the string value of the key sequence. */ -KDStream& KDStream::operator<<( const QKeySequence& keySeq) +KDStream& KDStream::operator<<( const TQKeySequence& keySeq) { - _output += QString(keySeq); + _output += TQString(keySeq); return *this; } -#endif /*! - Writes a QStrList value to the stream. The output is the individual + Writes a TQStrList value to the stream. The output is the individual strings. */ -KDStream& KDStream::operator<<( const QStrList& list ) +KDStream& KDStream::operator<<( const TQStrList& list ) { - KDStream_ptrListStream( *this, QStrListIterator( list ), false ); + KDStream_ptrListStream( *this, TQStrListIterator( list ), false ); return *this; } -KDStream& KDStream::operator<<( const QPixmap& pixmap ) +KDStream& KDStream::operator<<( const TQPixmap& pixmap ) { - _output += QString("QPixmap[null=%1,width=%2,heigth=%3,depth=%4,hasMask=%5,hasAlpha=%6]") - .arg(pixmap.isNull()).arg(pixmap.width()).arg(pixmap.height()) - .arg(pixmap.depth()).arg(pixmap.mask() != 0).arg(pixmap.hasAlpha() ); + _output += TQString("TQPixmap[null=%1,width=%2,heigth=%3,depth=%4,hasMask=%5,hasAlpha=%6]") + .tqarg(pixmap.isNull()).tqarg(pixmap.width()).tqarg(pixmap.height()) + .tqarg(pixmap.depth()).tqarg(pixmap.tqmask() != 0).tqarg(pixmap.hasAlpha() ); return *this; } -KDStream& KDStream::operator<<( const QImage& pixmap ) +KDStream& KDStream::operator<<( const TQImage& pixmap ) { - _output += QString("QImage[null=%1,width=%2,heigth=%3,depth=%4,hasAlpha=%5]") - .arg(pixmap.isNull()).arg(pixmap.width()).arg(pixmap.height()) - .arg(pixmap.depth()).arg(pixmap.hasAlphaBuffer() ); + _output += TQString("TQImage[null=%1,width=%2,heigth=%3,depth=%4,hasAlpha=%5]") + .tqarg(pixmap.isNull()).tqarg(pixmap.width()).tqarg(pixmap.height()) + .tqarg(pixmap.depth()).tqarg(pixmap.hasAlphaBuffer() ); return *this; } /* Classes that do not need to be supported: -QCollection - abstract class // Qt 2 -QBitArray - QArray implemented. -QByteArray - QAray implemented. -QPointArray - QAray implemented. -QGArray - internal class // Qt 2 -QStringList - It's just a QValueList. - -QGCache // Qt 2 -QGDict // Qt 2 -QGList // Qt 2 -QGVector // Qt 2 -QGCacheIterator // Qt 2 -QAsciiCacheIterator -QCacheIterator -QIntCacheIterator -QGDictIterator // Qt 2 -QAsciiDictIterator -QDictIterator -QIntDictIterator -QPtrDictIterator -QListIterator // Qt 2 -QStrListIterator -QGListIterator // Qt 2 -QMapConstIterator -QMapIterator -QBitVal -QValueListConstIterator -QValueListIterator -QPtrListIterator// Qt 3 -QPtrCollection// Qt 3 -QSortedList - Depricated // Qt 2 +TQCollection - abstract class // TQt 2 +TQBitArray - TQArray implemented. +TQByteArray - TQAray implemented. +TQPointArray - TQAray implemented. +TQGArray - internal class // TQt 2 +TQStringList - It's just a TQValueList. + +TQGCache // TQt 2 +TQGDict // TQt 2 +TQGList // TQt 2 +TQGVector // TQt 2 +TQGCacheIterator // TQt 2 +TQAsciiCacheIterator +TQCacheIterator +TQIntCacheIterator +TQGDictIterator // TQt 2 +TQAsciiDictIterator +TQDictIterator +TQIntDictIterator +TQPtrDictIterator +TQListIterator // TQt 2 +TQStrListIterator +TQGListIterator // TQt 2 +TQMapConstIterator +TQMapIterator +TQBitVal +TQValueListConstIterator +TQValueListIterator +TQPtrListIterator// TQt 3 +TQPtrCollection// TQt 3 +TQSortedList - Depricated // TQt 2 */ -/* Qt classes not yet supported: -QRegion -QAccel -QAccessible // Qt 3 -QAccessibleInterface// Qt 3 -QAccessibleObject// Qt 3 -QAction -QActionGroup -QApplication -QAsyncIO // Qt 2 -QBitmap -QBoxLayout -QBuffer -QButton -QButtonGroup -QCDEStyle -QCanvas -QCanvasEllipse -QCanvasItem -QCanvasItemList// Qt 3 -QCanvasLine -QCanvasPixmap -QCanvasPixmapArray -QCanvasPolygon -QCanvasPolygonalItem -QCanvasRectangle -QCanvasSpline// Qt 3 -QCanvasSprite -QCanvasText -QCanvasView -QCheckBox -QCheckListItem -QCheckTableItem// Qt 3 -QChildEvent -QClipboard -QCloseEvent -QColorDialog -QColorDrag -QComboBox -QComboTableItem// Qt 3 -QCommonStyle -QComponentFactory// Qt 3 -QComponentFactoryInterface// Qt 3 -QComponentInterface// Qt 3 -QComponentServerInterface// Qt 3 -QContextMenuEvent// Qt 3 -QCopChannel -QCustomEvent -QCustomMenuItem -QDataBrowser// Qt 3 -QDataPump // Qt 2 -QDataSink // Qt 2 -QDataSource // Qt 2 -QDataStream -QDataTable// Qt 3 -QDataView// Qt 3 -QDateEdit// Qt 3 -QDateTimeEdit// Qt 3 -QDesktopWidget// Qt 3 -QDial -QDialog -QDir -QDns -QDockArea// Qt 3 -QDockWindow// Qt 3 -QDomAttr -QDomCDATASection -QDomCharacterData -QDomComment -QDomDocument -QDomDocumentFragment -QDomDocumentType -QDomElement -QDomEntity -QDomEntityReference -QDomImplementation -QDomNamedNodeMap -QDomNode -QDomNodeList -QDomNotation -QDomProcessingInstruction -QDomText -QDoubleValidator -QDragEnterEvent -QDragLeaveEvent -QDragMoveEvent -QDragObject -QDropEvent -QDropSite // Qt 2 -QEditorFactory// Qt 3 -QErrorMessage// Qt 3 -QEucJpCodec // Qt 2 -QEucKrCodec // Qt 2 -QEvent -QFeatureListInterface// Qt 3 -QFile -QFileDialog -QFileIconProvider -QFileInfo -QFilePreview -QFocusData -QFocusEvent -QFontDatabase -QFontDialog -QFontInfo -QFontManager// Qt 3 -QFontMetrics -QFrame -QFtp -QGL -QGLColormap// Qt 3 -QGLContext -QGLFormat -QGLWidget -QGLayoutIterator -QGbkCodec // Qt 2 -QGrid -QGridLayout -QGridView// Qt 3 -QGroupBox -QGuardedPtr -QHBox -QHBoxLayout -QHButtonGroup -QHGroupBox -QHeader -QHideEvent -QHostAddress -QHttp// Qt 3 -QIMEvent// Qt 3 -QIODevice -QIODeviceSource // Qt 2 -QIconDrag -QIconDragItem -QIconSet -QIconView -QIconViewItem -QImageConsumer -QImageDecoder -QImageDrag -QImageFormat -QImageFormatType -QImageIO -QInputDialog -QIntValidator -QInterlaceStyle -QJisCodec // Qt 2 -QJpUnicodeConv // Qt 2 -QKeyEvent -QLCDNumber -QLNode // Qt 2 -QLabel -QLayout -QLayoutItem -QLayoutIterator -QLibrary// Qt 3 -QLibraryInterface// Qt 3 -QLineEdit -QListBox -QListBoxItem -QListBoxPixmap -QListBoxText -QListView -QListViewItem -QListViewItemIterator -QLocalFs -QLock// Qt 3 -QMainWindow -QMap -QMemArray// Qt 3 -QMenuBar -QMenuData -QMessageBox -QMetaObject -QMetaProperty -QMimeSource -QMimeSourceFactory -QMotifPlusStyle -QMotifStyle -QMouseEvent -QMoveEvent -QMovie -QMultiLineEdit // Qt 2 -QMutex -QNPInstance -QNPStream -QNPWidget -QNPlugin -QNetworkOperation -QNetworkProtocol -QObject -QPNGImagePacker -QPaintDevice -QPaintDeviceMetrics -QPaintEvent -QPainter -QPicture -QPixmapCache -QPlatinumStyle -QPluginManager// Qt 3 -QPopupMenu -QPrinter -QProcess// Qt 3 -QProgressBar -QProgressDialog -QPushButton -QRadioButton -QRangeControl -QRegExp -QRegExpValidator// Qt 3 -QResizeEvent -QSGIStyle -QScreen// Qt 3 -QScreenCursor // Qt 2 -QScrollBar -QScrollView -QSemaphore -QSemiModal // Qt 2 -QServerSocket -QSessionManager -QSettings// Qt 3 -QShared // Qt 2 -QShowEvent -QSignal -QSignalMapper -QSimpleRichText -QSizeGrip -QSjisCodec // Qt 2 -QSlider -QSocket -QSocketDevice -QSocketNotifier -QSound -QSpacerItem -QSpinBox -QSplitter -QSql// Qt 3 -QSqlCursor// Qt 3 -QSqlDatabase// Qt 3 -QSqlDriver// Qt 3 -QSqlEditorFactory// Qt 3 -QSqlError// Qt 3 -QSqlField// Qt 3 -QSqlForm// Qt 3 -QSqlIndex// Qt 3 -QSqlPropertyMap// Qt 3 -QSqlQuery// Qt 3 -QSqlRecord// Qt 3 -QSqlResult// Qt 3 -QStatusBar -QStoredDrag -QStyle -QStyleSheet -QStyleSheetItem -QTab -QTabBar -QTabDialog -QTabWidget -QTable -QTableItem -QTableSelection -QTableView // Qt 2 -QTabletEvent// Qt 3 -QTextBrowser -QTextCodec -QTextDecoder -QTextDrag -QTextEdit// Qt 3 -QTextEncoder -QTextIStream -QTextOStream -QTextStream -QTextView // Qt 2 -QThread -QTimeEdit// Qt 3 -QTimer -QTimerEvent -QToolBar -QToolButton -QToolTip -QToolTipGroup -QTranslator -QTranslatorMessage -QTsciiCodec // Qt 2 -QUnknownInterface// Qt 3 -QUriDrag -QUrl -QUrlInfo// Qt 3 -QUrlOperator -QUuid// Qt 3 -QVBox -QVBoxLayout -QVButtonGroup -QVGroupBox -QValidator -QVariant -QWMatrix -QWSDecoration -QWSKeyboardHandler -QWSMouseHandler -QWSServer -QWSWindow -QWaitCondition -QWhatsThis -QWheelEvent -QWidget -QWidgetFactory// Qt 3 -QWidgetItem -QWidgetStack -QWindowsMime// Qt 3 -QWindowsStyle -QWizard -QWorkspace -QXmlAttributes -QXmlContentHandler -QXmlDTDHandler -QXmlDeclHandler -QXmlDefaultHandler -QXmlEntityResolver -QXmlErrorHandler -QXmlInputSource -QXmlLexicalHandler -QXmlLocator -QXmlNamespaceSupport -QXmlParseException -QXmlReader -QXmlSimpleReader -QXtApplication -QXtWidget -Qt +/* TQt classes not yet supported: +TQRegion +TQAccel +TQAccessible // TQt 3 +TQAccessibleInterface// TQt 3 +TQAccessibleObject// TQt 3 +TQAction +TQActionGroup +TQApplication +TQAsyncIO // TQt 2 +TQBitmap +TQBoxLayout +TQBuffer +TQButton +TQButtonGroup +TQCDEStyle +TQCanvas +TQCanvasEllipse +TQCanvasItem +TQCanvasItemList// TQt 3 +TQCanvasLine +TQCanvasPixmap +TQCanvasPixmapArray +TQCanvasPolygon +TQCanvasPolygonalItem +TQCanvasRectangle +TQCanvasSpline// TQt 3 +TQCanvasSprite +TQCanvasText +TQCanvasView +TQCheckBox +TQCheckListItem +TQCheckTableItem// TQt 3 +TQChildEvent +TQClipboard +TQCloseEvent +TQColorDialog +TQColorDrag +TQComboBox +TQComboTableItem// TQt 3 +TQCommonStyle +TQComponentFactory// TQt 3 +TQComponentFactoryInterface// TQt 3 +TQComponentInterface// TQt 3 +TQComponentServerInterface// TQt 3 +TQContextMenuEvent// TQt 3 +TQCopChannel +TQCustomEvent +TQCustomMenuItem +TQDataBrowser// TQt 3 +TQDataPump // TQt 2 +TQDataSink // TQt 2 +TQDataSource // TQt 2 +TQDataStream +TQDataTable// TQt 3 +TQDataView// TQt 3 +TQDateEdit// TQt 3 +TQDateTimeEdit// TQt 3 +TQDesktopWidget// TQt 3 +TQDial +TQDialog +TQDir +TQDns +TQDockArea// TQt 3 +TQDockWindow// TQt 3 +TQDomAttr +TQDomCDATASection +TQDomCharacterData +TQDomComment +TQDomDocument +TQDomDocumentFragment +TQDomDocumentType +TQDomElement +TQDomEntity +TQDomEntityReference +TQDomImplementation +TQDomNamedNodeMap +TQDomNode +TQDomNodeList +TQDomNotation +TQDomProcessingInstruction +TQDomText +TQDoubleValidator +TQDragEnterEvent +TQDragLeaveEvent +TQDragMoveEvent +TQDragObject +TQDropEvent +TQDropSite // TQt 2 +TQEditorFactory// TQt 3 +TQErrorMessage// TQt 3 +TQEucJpCodec // TQt 2 +TQEucKrCodec // TQt 2 +TQEvent +TQFeatureListInterface// TQt 3 +TQFile +TQFileDialog +TQFileIconProvider +TQFileInfo +TQFilePreview +TQFocusData +TQFocusEvent +TQFontDatabase +TQFontDialog +TQFontInfo +TQFontManager// TQt 3 +TQFontMetrics +TQFrame +TQFtp +TQGL +TQGLColormap// TQt 3 +TQGLContext +TQGLFormat +TQGLWidget +TQGLayoutIterator +TQGbkCodec // TQt 2 +TQGrid +TQGridLayout +TQGridView// TQt 3 +TQGroupBox +TQGuardedPtr +TQHBox +TQHBoxLayout +TQHButtonGroup +TQHGroupBox +TQHeader +TQHideEvent +TQHostAddress +TQHttp// TQt 3 +TQIMEvent// TQt 3 +TQIODevice +TQIODeviceSource // TQt 2 +TQIconDrag +TQIconDragItem +TQIconSet +TQIconView +TQIconViewItem +TQImageConsumer +TQImageDecoder +TQImageDrag +TQImageFormat +TQImageFormatType +TQImageIO +TQInputDialog +TQIntValidator +TQInterlaceStyle +TQJisCodec // TQt 2 +TQJpUnicodeConv // TQt 2 +TQKeyEvent +TQLCDNumber +TQLNode // TQt 2 +TQLabel +TQLayout +TQLayoutItem +TQLayoutIterator +TQLibrary// TQt 3 +TQLibraryInterface// TQt 3 +TQLineEdit +TQListBox +TQListBoxItem +TQListBoxPixmap +TQListBoxText +TQListView +TQListViewItem +TQListViewItemIterator +TQLocalFs +TQLock// TQt 3 +TQMainWindow +TQMap +TQMemArray// TQt 3 +TQMenuBar +TQMenuData +TQMessageBox +TQMetaObject +TQMetaProperty +TQMimeSource +TQMimeSourceFactory +TQMotifPlusStyle +TQMotifStyle +TQMouseEvent +TQMoveEvent +TQMovie +TQMultiLineEdit // TQt 2 +TQMutex +TQNPInstance +TQNPStream +TQNPWidget +TQNPlugin +TQNetworkOperation +TQNetworkProtocol +TQObject +TQPNGImagePacker +TQPaintDevice +TQPaintDeviceMetrics +TQPaintEvent +TQPainter +TQPicture +TQPixmapCache +TQPlatinumStyle +TQPluginManager// TQt 3 +TQPopupMenu +TQPrinter +TQProcess// TQt 3 +TQProgressBar +TQProgressDialog +TQPushButton +TQRadioButton +TQRangeControl +TQRegExp +TQRegExpValidator// TQt 3 +TQResizeEvent +TQSGIStyle +TQScreen// TQt 3 +TQScreenCursor // TQt 2 +TQScrollBar +TQScrollView +TQSemaphore +TQSemiModal // TQt 2 +TQServerSocket +TQSessionManager +TQSettings// TQt 3 +TQShared // TQt 2 +TQShowEvent +TQSignal +TQSignalMapper +TQSimpleRichText +TQSizeGrip +TQSjisCodec // TQt 2 +TQSlider +TQSocket +TQSocketDevice +TQSocketNotifier +TQSound +TQSpacerItem +TQSpinBox +TQSplitter +TQSql// TQt 3 +TQSqlCursor// TQt 3 +TQSqlDatabase// TQt 3 +TQSqlDriver// TQt 3 +TQSqlEditorFactory// TQt 3 +TQSqlError// TQt 3 +TQSqlField// TQt 3 +TQSqlForm// TQt 3 +TQSqlIndex// TQt 3 +TQSqlPropertyMap// TQt 3 +TQSqlQuery// TQt 3 +TQSqlRecord// TQt 3 +TQSqlResult// TQt 3 +TQStatusBar +TQStoredDrag +TQStyle +TQStyleSheet +TQStyleSheetItem +TQTab +TQTabBar +TQTabDialog +TQTabWidget +TQTable +TQTableItem +TQTableSelection +TQTableView // TQt 2 +TQTabletEvent// TQt 3 +TQTextBrowser +TQTextCodec +TQTextDecoder +TQTextDrag +TQTextEdit// TQt 3 +TQTextEncoder +TQTextIStream +TQTextOStream +TQTextStream +TQTextView // TQt 2 +TQThread +TQTimeEdit// TQt 3 +TQTimer +TQTimerEvent +TQToolBar +TQToolButton +TQToolTip +TQToolTipGroup +TQTranslator +TQTranslatorMessage +TQTsciiCodec // TQt 2 +TQUnknownInterface// TQt 3 +TQUriDrag +TQUrl +TQUrlInfo// TQt 3 +TQUrlOperator +TQUuid// TQt 3 +TQVBox +TQVBoxLayout +TQVButtonGroup +TQVGroupBox +TQValidator +TQVariant +TQWMatrix +TQWSDecoration +TQWSKeyboardHandler +TQWSMouseHandler +TQWSServer +TQWSWindow +TQWaitCondition +TQWhatsThis +TQWheelEvent +TQWidget +TQWidgetFactory// TQt 3 +TQWidgetItem +TQWidgetStack +TQWindowsMime// TQt 3 +TQWindowsStyle +TQWizard +TQWorkspace +TQXmlAttributes +TQXmlContentHandler +TQXmlDTDHandler +TQXmlDeclHandler +TQXmlDefaultHandler +TQXmlEntityResolver +TQXmlErrorHandler +TQXmlInputSource +TQXmlLexicalHandler +TQXmlLocator +TQXmlNamespaceSupport +TQXmlParseException +TQXmlReader +TQXmlSimpleReader +TQXtApplication +TQXtWidget +TQt */ |