From 252b74ae40311e7e3e2ba9f4d4a0ebf2ead24472 Mon Sep 17 00:00:00 2001 From: tpearson Date: Tue, 17 May 2011 20:54:59 +0000 Subject: [PATCH] TQt4 port libkipi This enables compilation under Qt3 and Qt4 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/libraries/libkipi@1232471 283d02a7-25f6-0310-bc7c-ecb5cbfe19da --- libkipi/libkipi/KDStream.cpp | 1325 +++++++++---------- libkipi/libkipi/KDStream.h | 239 ++-- libkipi/libkipi/batchprogressdialog.cpp | 98 +- libkipi/libkipi/batchprogressdialog.h | 5 +- libkipi/libkipi/imagecollection.cpp | 22 +- libkipi/libkipi/imagecollection.h | 16 +- libkipi/libkipi/imagecollectionselector.cpp | 122 +- libkipi/libkipi/imagecollectionselector.h | 21 +- libkipi/libkipi/imagecollectionshared.cpp | 14 +- libkipi/libkipi/imagecollectionshared.h | 16 +- libkipi/libkipi/imagedialog.cpp | 130 +- libkipi/libkipi/imagedialog.h | 21 +- libkipi/libkipi/imageinfo.cpp | 24 +- libkipi/libkipi/imageinfo.h | 26 +- libkipi/libkipi/imageinfoshared.cpp | 16 +- libkipi/libkipi/imageinfoshared.h | 28 +- libkipi/libkipi/interface.cpp | 20 +- libkipi/libkipi/interface.h | 19 +- libkipi/libkipi/mainpage.cpp | 2 +- libkipi/libkipi/plugin.cpp | 28 +- libkipi/libkipi/plugin.h | 14 +- libkipi/libkipi/pluginloader.cpp | 84 +- libkipi/libkipi/pluginloader.h | 26 +- libkipi/libkipi/uploadwidget.cpp | 62 +- libkipi/libkipi/uploadwidget.h | 13 +- 25 files changed, 1164 insertions(+), 1227 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 -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#if (QT_VERSION >= 300 ) -#include -#include -#include -#endif +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include /** \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 */ diff --git a/libkipi/libkipi/KDStream.h b/libkipi/libkipi/KDStream.h index 9685645..be909dd 100644 --- a/libkipi/libkipi/KDStream.h +++ b/libkipi/libkipi/KDStream.h @@ -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.h 387954 2005-02-10 07:49:40Z blackie $ */ /**************************************************************************** -** 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. ** @@ -29,53 +29,44 @@ #define KIPI_KDSTREAM // Forward declarations. -class QImage; -class QPixmap; -class QColor; -class QColorGroup; -class QPalette; -class QCursor; -class QDate; -class QDateTime; -class QTime; -class QFont; -class QPen; -class QPoint; -class QSize; -class QRect; -class QObject; -class QVariant; -class QBrush; -class QSizePolicy; -class QKeySequence; - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#if ( QT_VERSION < 300 ) -#include -#include -#include -#include -#endif - -#if ( QT_VERSION >= 300 ) -#include -#include -#include -#include -#include -#include -#endif +class TQImage; +class TQPixmap; +class TQColor; +class TQColorGroup; +class TQPalette; +class TQCursor; +class TQDate; +class TQDateTime; +class TQTime; +class TQFont; +class TQPen; +class TQPoint; +class TQSize; +class TQRect; +class TQObject; +class TQVariant; +class TQBrush; +class TQSizePolicy; +class TQKeySequence; + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include // utility functions. class KDStream; @@ -86,7 +77,7 @@ KDStream& flush( KDStream& stream); class KDStream { public: - KDStream( QString* outputString = 0); + KDStream( TQString* outputString = 0); ~KDStream(); void flush(); @@ -105,42 +96,42 @@ public: KDStream& operator<<( const void* ); // Data holding classes. - KDStream& operator<<( const QString& ); - KDStream& operator<<( const QCString& ); - KDStream& operator<<( const QChar& ); - - KDStream& operator<<( const QColor& ); - KDStream& operator<<( const QColorGroup& ); - KDStream& operator<<( const QPalette& ); - KDStream& operator<<( const QCursor& ); - - KDStream& operator<<( const QDate& ); - KDStream& operator<<( const QDateTime& ); - KDStream& operator<<( const QTime& ); - - KDStream& operator<<( const QFont& ); - KDStream& operator<<( const QPen& ); - KDStream& operator<<( const QPoint& ); - KDStream& operator<<( const QSize& ); - KDStream& operator<<( const QRect& ); - KDStream& operator<<( const QBrush& ); - KDStream& operator<<( const QSizePolicy& ); - KDStream& operator<<( const QKeySequence& ); - KDStream& operator<<( const QPixmap& ); - KDStream& operator<<( const QImage& ); + KDStream& operator<<( const TQString& ); + KDStream& operator<<( const TQCString& ); + KDStream& operator<<( const TQChar& ); + + KDStream& operator<<( const TQColor& ); + KDStream& operator<<( const TQColorGroup& ); + KDStream& operator<<( const TQPalette& ); + KDStream& operator<<( const TQCursor& ); + + KDStream& operator<<( const TQDate& ); + KDStream& operator<<( const TQDateTime& ); + KDStream& operator<<( const TQTime& ); + + KDStream& operator<<( const TQFont& ); + KDStream& operator<<( const TQPen& ); + KDStream& operator<<( const TQPoint& ); + KDStream& operator<<( const TQSize& ); + KDStream& operator<<( const TQRect& ); + KDStream& operator<<( const TQBrush& ); + KDStream& operator<<( const TQSizePolicy& ); + KDStream& operator<<( const TQKeySequence& ); + KDStream& operator<<( const TQPixmap& ); + KDStream& operator<<( const TQImage& ); // misc KDStream& operator<<( KDSTREAMFUNC ); - KDStream& operator<<( const QVariant& ); - KDStream& operator<<( const QObject& ); - KDStream& operator<<( const QStrList& list ); + KDStream& operator<<( const TQVariant& ); + KDStream& operator<<( const TQObject& ); + KDStream& operator<<( const TQStrList& list ); protected: - QString QColor2Str( const QColor& col ); + TQString TQColor2Str( const TQColor& col ); private: - QString _output; - QString* _out; + TQString _output; + TQString* _out; }; @@ -175,7 +166,7 @@ template void KDStream_ptrListStream( KDStream& st, Iterator it, if ( doubleDeref ) st << *(*it); else { - // QStrList ought to be a value list rather than a ptr list, one less dereference is + // TQStrList ought to be a value list rather than a ptr list, one less dereference is // necesary here, otherwise we will only stream out a char, rather than a char * st << *it; } @@ -202,82 +193,52 @@ template void KDStream_ptrDictStream( KDStream& st, Iterator it // Defined as global functions to support // compilers without member templates -template KDStream& operator<<( KDStream& st, const QValueList& list ) +template KDStream& operator<<( KDStream& st, const TQValueList& list ) { KDStream_valueListStream( st, list.begin(), list.end() ); return st; } -#if ( QT_VERSION < 300 ) -template KDStream& operator<<( KDStream& st, const QList& list ) -{ - KDStream_ptrListStream ( st, QListIterator( list ) , true ); - return st; -} - -template KDStream& operator<<( KDStream& st, const QArray& array ) +template KDStream& operator<<( KDStream& st, const TQMemArray& array ) { KDStream_valueListStream( st, array.begin(), array.end() ); return st; } -template KDStream& operator<<( KDStream& st, const QVector& vector ) +template KDStream& operator<<( KDStream& st, const TQPtrList& list ) { - QList list; - vector.toList( &list ); - - KDStream_ptrListStream ( st, QListIterator( list ), true ); - return st; -} -#endif -#if ( QT_VERSION >= 300 ) -template KDStream& operator<<( KDStream& st, const QMemArray& array ) -{ - KDStream_valueListStream( st, array.begin(), array.end() ); - return st; -} - -template KDStream& operator<<( KDStream& st, const QPtrList& list ) -{ - KDStream_ptrListStream ( st, QPtrListIterator( list ), true ); + KDStream_ptrListStream ( st, TQPtrListIterator( list ), true ); return st; } -template KDStream& operator<<( KDStream& st, const QPair& pair ) +template KDStream& operator<<( KDStream& st, const TQPair& pair ) { st << "(" << pair.first << "," << pair.second << ")"; return st; } -template KDStream& operator<<( KDStream& st, const QPtrVector& vector ) +template KDStream& operator<<( KDStream& st, const TQPtrVector& vector ) { - QPtrList list; + TQPtrList list; vector.toList( &list ); - KDStream_ptrListStream( st, QPtrListIterator( list ), true ); + KDStream_ptrListStream( st, TQPtrListIterator( list ), true ); return st; } -template KDStream& operator<<( KDStream& st, const QValueVector& vector ) +template KDStream& operator<<( KDStream& st, const TQValueVector& vector ) { KDStream_valueListStream( st, vector.begin(), vector.end() ); return st; } -#endif -#if ( QT_VERSION < 300 ) -template KDStream& operator<<( KDStream& st, const QStack& stack ) -{ - // I need a copy to look at the individual elements. - QStack copy(stack); -#else -template KDStream& operator<<( KDStream& st, const QPtrStack& stack ) +template KDStream& operator<<( KDStream& st, const TQPtrStack& stack ) { // I need a copy to look at the individual elements. - QPtrStack copy(stack); + TQPtrStack copy(stack); /*}*/ -#endif + st << "["; if ( stack.count() > 1 ) st << "top| "; @@ -303,11 +264,11 @@ template KDStream& operator<<( KDStream& st, const QPtrStack& stack // Q(Ptr)Stack, as the Q(Ptr)Stack dereferences what it pops of the stack, // before streaming it: // Q(Ptr)Stack: *this << *(copy.pop()); -// QValueStack: *this << copy.pop() ; -template KDStream& operator<<( KDStream& st, const QValueStack& stack ) +// TQValueStack: *this << copy.pop() ; +template KDStream& operator<<( KDStream& st, const TQValueStack& stack ) { // I need a copy to look at the individual elements. - QValueStack copy(stack); + TQValueStack copy(stack); st << "["; if ( stack.count() > 1 ) st << "top| "; @@ -330,45 +291,45 @@ template KDStream& operator<<( KDStream& st, const QValueStack& stac } -template KDStream& operator<<( KDStream& st, const QAsciiDict& dict ) +template KDStream& operator<<( KDStream& st, const TQAsciiDict& dict ) { - KDStream_ptrDictStream( st, QAsciiDictIterator( dict ) ); + KDStream_ptrDictStream( st, TQAsciiDictIterator( dict ) ); return st; } -template KDStream& operator<<( KDStream& st, const QIntDict& dict ) +template KDStream& operator<<( KDStream& st, const TQIntDict& dict ) { - KDStream_ptrDictStream( st, QIntDictIterator( dict ) ); + KDStream_ptrDictStream( st, TQIntDictIterator( dict ) ); return st; } -template KDStream& operator<<( KDStream& st, const QPtrDict& dict ) +template KDStream& operator<<( KDStream& st, const TQPtrDict& dict ) { - KDStream_ptrDictStream( st, QPtrDictIterator( dict ) ); + KDStream_ptrDictStream( st, TQPtrDictIterator( dict ) ); return st; } -template KDStream& operator<<( KDStream& st, const QDict& dict ) +template KDStream& operator<<( KDStream& st, const TQDict& dict ) { - KDStream_ptrDictStream( st, QDictIterator( dict ) ); + KDStream_ptrDictStream( st, TQDictIterator( dict ) ); return st; } -template KDStream& operator<<( KDStream& st, const QAsciiCache& cache ) +template KDStream& operator<<( KDStream& st, const TQAsciiCache& cache ) { - KDStream_ptrDictStream( st, QAsciiCacheIterator( cache ) ); + KDStream_ptrDictStream( st, TQAsciiCacheIterator( cache ) ); return st; } -template KDStream& operator<<( KDStream& st, const QIntCache& cache ) +template KDStream& operator<<( KDStream& st, const TQIntCache& cache ) { - KDStream_ptrDictStream( st, QIntCacheIterator( cache ) ); + KDStream_ptrDictStream( st, TQIntCacheIterator( cache ) ); return st; } -template KDStream& operator<<( KDStream& st, const QCache& cache ) +template KDStream& operator<<( KDStream& st, const TQCache& cache ) { - KDStream_ptrDictStream( st, QCacheIterator( cache ) ); + KDStream_ptrDictStream( st, TQCacheIterator( cache ) ); return st; } diff --git a/libkipi/libkipi/batchprogressdialog.cpp b/libkipi/libkipi/batchprogressdialog.cpp index f516059..9ad9ad2 100644 --- a/libkipi/libkipi/batchprogressdialog.cpp +++ b/libkipi/libkipi/batchprogressdialog.cpp @@ -21,24 +21,24 @@ ////////////////////////////////////////////////////////////////////////////// -// Include files for Qt - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include +// Include files for TQt + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // Include files for KDE @@ -72,8 +72,8 @@ namespace KIPI class BatchProgressItem : public KListViewItem { public: - BatchProgressItem(KListView * parent, QListViewItem *after, const QString &message, int messageType) - : KListViewItem( parent, after), m_messagetype(messageType) + BatchProgressItem(KListView * tqparent, TQListViewItem *after, const TQString &message, int messageType) + : KListViewItem( tqparent, after), m_messagetype(messageType) { // Set the icon. @@ -106,25 +106,25 @@ public: private: int m_messagetype; - void paintCell (QPainter *p, const QColorGroup &cg, int column, int width, int alignment) + void paintCell (TQPainter *p, const TQColorGroup &cg, int column, int width, int tqalignment) { - QColorGroup _cg( cg ); + TQColorGroup _cg( cg ); if ( m_messagetype == KIPI::ErrorMessage ) { - _cg.setColor( QColorGroup::Text, Qt::red ); - KListViewItem::paintCell( p, _cg, column, width, alignment ); + _cg.setColor( TQColorGroup::Text, TQt::red ); + KListViewItem::paintCell( p, _cg, column, width, tqalignment ); return; } if ( m_messagetype == KIPI::WarningMessage ) { - _cg.setColor( QColorGroup::Text, Qt::darkYellow ); - KListViewItem::paintCell( p, _cg, column, width, alignment ); + _cg.setColor( TQColorGroup::Text, TQt::darkYellow ); + KListViewItem::paintCell( p, _cg, column, width, tqalignment ); return; } - KListViewItem::paintCell( p, cg, column, width, alignment ); + KListViewItem::paintCell( p, cg, column, width, tqalignment ); } }; @@ -135,53 +135,53 @@ struct BatchProgressDialog::Private { /////////////////////////////////// CONSTRUCTOR //////////////////////////////////////////// -BatchProgressDialog::BatchProgressDialog( QWidget *parent, const QString &caption ) - : KDialogBase( parent, "KIPIBatchProgressDialog", true /* modal */, +BatchProgressDialog::BatchProgressDialog( TQWidget *tqparent, const TQString &caption ) + : KDialogBase( tqparent, "KIPIBatchProgressDialog", true /* modal */, caption, Cancel) { d = new Private; - QWidget* box = makeVBoxMainWidget(); + TQWidget* box = makeVBoxMainWidget(); //--------------------------------------------- - QFrame *headerFrame = new QFrame( box ); - headerFrame->setFrameStyle(QFrame::Panel|QFrame::Sunken); - QHBoxLayout* layout = new QHBoxLayout( headerFrame ); - layout->setMargin( 2 ); // to make sure the frame gets displayed - layout->setSpacing( 0 ); - QLabel *pixmapLabelLeft = new QLabel( headerFrame, "pixmapLabelLeft" ); + TQFrame *headerFrame = new TQFrame( box ); + headerFrame->setFrameStyle(TQFrame::Panel|TQFrame::Sunken); + TQHBoxLayout* tqlayout = new TQHBoxLayout( headerFrame ); + tqlayout->setMargin( 2 ); // to make sure the frame gets displayed + tqlayout->setSpacing( 0 ); + TQLabel *pixmapLabelLeft = new TQLabel( headerFrame, "pixmapLabelLeft" ); pixmapLabelLeft->setScaledContents( false ); - layout->addWidget( pixmapLabelLeft ); - QLabel *labelTitle = new QLabel( caption, headerFrame, "labelTitle" ); - layout->addWidget( labelTitle ); - layout->setStretchFactor( labelTitle, 1 ); + tqlayout->addWidget( pixmapLabelLeft ); + TQLabel *labelTitle = new TQLabel( caption, headerFrame, "labelTitle" ); + tqlayout->addWidget( labelTitle ); + tqlayout->setStretchFactor( labelTitle, 1 ); - QString dir; + TQString dir; KGlobal::dirs()->addResourceType("kipi_banner_left", KGlobal::dirs()->kde_default("data") + "kipi/data"); dir = KGlobal::dirs()->findResourceDir("kipi_banner_left", "banner_left.png"); - pixmapLabelLeft->setPaletteBackgroundColor( QColor(201, 208, 255) ); - pixmapLabelLeft->setPixmap( QPixmap( dir + "banner_left.png" ) ); - labelTitle->setPaletteBackgroundColor( QColor(201, 208, 255) ); + pixmapLabelLeft->setPaletteBackgroundColor( TQColor(201, 208, 255) ); + pixmapLabelLeft->setPixmap( TQPixmap( dir + "banner_left.png" ) ); + labelTitle->setPaletteBackgroundColor( TQColor(201, 208, 255) ); //--------------------------------------------- m_actionsList = new KListView( box ); - m_actionsList->addColumn(i18n( "Status" )); + m_actionsList->addColumn(i18n( "tqStatus" )); m_actionsList->addColumn(i18n( "Current Actions" )); m_actionsList->setSorting(-1); m_actionsList->setItemMargin(1); m_actionsList->header()->hide(); - m_actionsList->setResizeMode(QListView::LastColumn); - QWhatsThis::add( m_actionsList, i18n("

This is the current tasks list released.") ); + m_actionsList->setResizeMode(TQListView::LastColumn); + TQWhatsThis::add( m_actionsList, i18n("

This is the current tasks list released.") ); //--------------------------------------------- m_progress = new KProgress( box, "Progress" ); m_progress->setTotalSteps(100); m_progress->setValue(0); - QWhatsThis::add( m_progress, i18n("

This is the list current percent task released.") ); + TQWhatsThis::add( m_progress, i18n("

This is the list current percent task released.") ); resize( 600, 400 ); } @@ -196,7 +196,7 @@ BatchProgressDialog::~BatchProgressDialog() ///////////////////////////////////// FONCTIONS ///////////////////////////////////////////// -void BatchProgressDialog::addedAction(const QString &text, int type) +void BatchProgressDialog::addedAction(const TQString &text, int type) { m_item = new KIPI::BatchProgressItem(m_actionsList, m_actionsList->lastItem(), diff --git a/libkipi/libkipi/batchprogressdialog.h b/libkipi/libkipi/batchprogressdialog.h index 6ec06fb..031e79a 100644 --- a/libkipi/libkipi/batchprogressdialog.h +++ b/libkipi/libkipi/batchprogressdialog.h @@ -53,13 +53,14 @@ enum ActionMessageType class LIBKIPI_EXPORT BatchProgressDialog : public KDialogBase { Q_OBJECT + TQ_OBJECT public: - BatchProgressDialog( QWidget *parent=0, const QString &caption=QString::null ); + BatchProgressDialog( TQWidget *tqparent=0, const TQString &caption=TQString() ); ~BatchProgressDialog(); - void addedAction(const QString &text, int type); + void addedAction(const TQString &text, int type); void reset(); void setProgress(int current, int total); diff --git a/libkipi/libkipi/imagecollection.cpp b/libkipi/libkipi/imagecollection.cpp index a499322..67b208a 100644 --- a/libkipi/libkipi/imagecollection.cpp +++ b/libkipi/libkipi/imagecollection.cpp @@ -32,29 +32,29 @@ /** @file imagecollection.cpp - returns the comment for the collection of images or QString::null if that doesn't make any sense. + returns the comment for the collection of images or TQString() if that doesn't make any sense. A comment makes sense for an album, but not for a KIPI::Interface::currentSelection(). */ -QString KIPI::ImageCollection::comment() const +TQString KIPI::ImageCollection::comment() const { if ( _data ) return _data->comment(); else { printNullError(); - return QString::null; + return TQString(); } } /** PENDING(blackie) document */ -QString KIPI::ImageCollection::name() const +TQString KIPI::ImageCollection::name() const { if ( _data ) return _data->name(); else { printNullError(); - return QString::null; + return TQString(); } } @@ -62,13 +62,13 @@ QString KIPI::ImageCollection::name() const Return the category of the image collection. For example in Digikam, a category is a sorting class like 'travels', 'friends', 'monuments', etc. */ -QString KIPI::ImageCollection::category() const +TQString KIPI::ImageCollection::category() const { if ( _data ) return _data->category(); else { printNullError(); - return QString::null; + return TQString(); } } @@ -76,13 +76,13 @@ QString KIPI::ImageCollection::category() const Return the Creation date of the image collection. The default implementation return a null date. */ -QDate KIPI::ImageCollection::date() const +TQDate KIPI::ImageCollection::date() const { if ( _data ) return _data->date(); else { printNullError(); - return QDate(); + return TQDate(); } } @@ -213,13 +213,13 @@ KURL KIPI::ImageCollection::uploadRoot() const the KIPI::UploadWidget. This name can be different for each host app (like "Images" for Kimdaba or "My Albums" for Digikam). */ -QString KIPI::ImageCollection::uploadRootName() const +TQString KIPI::ImageCollection::uploadRootName() const { if ( _data ) return _data->uploadRootName(); else { printNullError(); - return QString::null; + return TQString(); } } diff --git a/libkipi/libkipi/imagecollection.h b/libkipi/libkipi/imagecollection.h index b30f9f3..35f9f07 100644 --- a/libkipi/libkipi/imagecollection.h +++ b/libkipi/libkipi/imagecollection.h @@ -25,10 +25,10 @@ #ifndef KIPI_IMAGECOLLECTION_H #define KIPI_IMAGECOLLECTION_H -// Qt includes +// TQt includes -#include -#include +#include +#include // KDE includes. @@ -46,15 +46,15 @@ namespace KIPI class LIBKIPI_EXPORT ImageCollection { public: - QString name() const; - QString comment() const; - QString category() const; - QDate date() const; + TQString name() const; + TQString comment() const; + TQString category() const; + TQDate date() const; KURL::List images() const; KURL path() const; KURL uploadPath() const; KURL uploadRoot() const; - QString uploadRootName() const; + TQString uploadRootName() const; bool isDirectory() const; bool isValid() const; diff --git a/libkipi/libkipi/imagecollectionselector.cpp b/libkipi/libkipi/imagecollectionselector.cpp index c8a8625..e2c6d2b 100644 --- a/libkipi/libkipi/imagecollectionselector.cpp +++ b/libkipi/libkipi/imagecollectionselector.cpp @@ -20,14 +20,14 @@ * * ============================================================ */ -// Qt includes. +// TQt includes. -#include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include // KDE includes. @@ -49,12 +49,12 @@ namespace KIPI { -class ImageCollectionItem : public QCheckListItem +class ImageCollectionItem : public TQCheckListItem { public: ImageCollectionItem(ImageCollectionSelector* selector, - QListView * parent, ImageCollection collection) - : QCheckListItem( parent, collection.name(), QCheckListItem::CheckBox), + TQListView * tqparent, ImageCollection collection) + : TQCheckListItem( tqparent, collection.name(), TQCheckListItem::CheckBox), _imageCollection(collection), _selector(selector) {} @@ -64,7 +64,7 @@ protected: virtual void stateChange(bool val) { - QCheckListItem::stateChange(val); + TQCheckListItem::stateChange(val); _selector->emitSelectionChanged(); } @@ -77,68 +77,68 @@ private: struct ImageCollectionSelector::Private { Interface* _interface; KListView* _list; - QLabel* _thumbLabel; - QLabel* _textLabel; - QListViewItem* _itemToSelect; + TQLabel* _thumbLabel; + TQLabel* _textLabel; + TQListViewItem* _itemToSelect; }; -ImageCollectionSelector::ImageCollectionSelector(QWidget* parent, Interface* interface, const char* name) - : QWidget(parent, name) +ImageCollectionSelector::ImageCollectionSelector(TQWidget* tqparent, Interface* interface, const char* name) + : TQWidget(tqparent, name) { d=new Private; d->_interface=interface; d->_itemToSelect = 0; d->_list=new KListView(this); - d->_list->setResizeMode( QListView::LastColumn ); + d->_list->setResizeMode( TQListView::LastColumn ); d->_list->addColumn(""); d->_list->header()->hide(); - connect(d->_list, SIGNAL(selectionChanged(QListViewItem*)), - SLOT(slotSelectionChanged(QListViewItem*))); + connect(d->_list, TQT_SIGNAL(selectionChanged(TQListViewItem*)), + TQT_SLOT(slotSelectionChanged(TQListViewItem*))); - QHBoxLayout* mainLayout=new QHBoxLayout(this, 0, KDialog::spacingHint()); + TQHBoxLayout* mainLayout=new TQHBoxLayout(this, 0, KDialog::spacingHint()); mainLayout->addWidget(d->_list); - QVBoxLayout* rightLayout = new QVBoxLayout(mainLayout, 0); + TQVBoxLayout* rightLayout = new TQVBoxLayout(mainLayout, 0); - KButtonBox* box=new KButtonBox(this, Vertical); + KButtonBox* box=new KButtonBox(this,Qt::Vertical); rightLayout->addWidget(box); - QPushButton* selectAll=box->addButton(i18n("Select All")); - QPushButton* invertSelection=box->addButton(i18n("Invert Selection")); - QPushButton* selectNone=box->addButton(i18n("Select None")); - box->layout(); - - connect(selectAll, SIGNAL(clicked()), - this, SLOT(slotSelectAll()) ); - connect(invertSelection, SIGNAL(clicked()), - this, SLOT(slotInvertSelection()) ); - connect(selectNone, SIGNAL(clicked()), - this, SLOT(slotSelectNone()) ); - - rightLayout->addItem(new QSpacerItem(10,20,QSizePolicy::Fixed, - QSizePolicy::Expanding)); + TQPushButton* selectAll=box->addButton(i18n("Select All")); + TQPushButton* invertSelection=box->addButton(i18n("Invert Selection")); + TQPushButton* selectNone=box->addButton(i18n("Select None")); + box->tqlayout(); + + connect(selectAll, TQT_SIGNAL(clicked()), + this, TQT_SLOT(slotSelectAll()) ); + connect(invertSelection, TQT_SIGNAL(clicked()), + this, TQT_SLOT(slotInvertSelection()) ); + connect(selectNone, TQT_SIGNAL(clicked()), + this, TQT_SLOT(slotSelectNone()) ); + + rightLayout->addItem(new TQSpacerItem(10,20,TQSizePolicy::Fixed, + TQSizePolicy::Expanding)); - QVGroupBox* rightBox = new QVGroupBox(this); + TQVGroupBox* rightBox = new TQVGroupBox(this); rightBox->setInsideMargin(KDialog::marginHint()); rightBox->setInsideSpacing(KDialog::spacingHint()); rightLayout->addWidget(rightBox); if (interface->hasFeature(AlbumsUseFirstImagePreview)) { - d->_thumbLabel = new QLabel(rightBox); - d->_thumbLabel->setFixedSize(QSize(128,128)); - d->_thumbLabel->setAlignment(AlignHCenter | AlignVCenter); + d->_thumbLabel = new TQLabel(rightBox); + d->_thumbLabel->setFixedSize(TQSize(128,128)); + d->_thumbLabel->tqsetAlignment(AlignHCenter | AlignVCenter); } else { d->_thumbLabel = 0; } - d->_textLabel = new QLabel(rightBox); + d->_textLabel = new TQLabel(rightBox); fillList(); - QTimer::singleShot(0, this, SLOT(slotInitialShow())); + TQTimer::singleShot(0, this, TQT_SLOT(slotInitialShow())); } @@ -148,7 +148,7 @@ ImageCollectionSelector::~ImageCollectionSelector() { void ImageCollectionSelector::fillList() { - QValueList collections = d->_interface->allAlbums(); + TQValueList collections = d->_interface->allAlbums(); d->_list->clear(); ImageCollection current = d->_interface->currentAlbum(); bool currentWasInList = false; @@ -158,7 +158,7 @@ void ImageCollectionSelector::fillList() { them */ blockSignals(true); - for( QValueList::Iterator it = collections.begin() ; + for( TQValueList::Iterator it = collections.begin() ; it != collections.end() ; ++it ) { ImageCollectionItem* item = new ImageCollectionItem( this, d->_list, *it); @@ -182,10 +182,10 @@ void ImageCollectionSelector::emitSelectionChanged() emit selectionChanged(); } -QValueList ImageCollectionSelector::selectedImageCollections() const { - QValueList list; +TQValueList ImageCollectionSelector::selectedImageCollections() const { + TQValueList list; - QListViewItemIterator it( d->_list ); + TQListViewItemIterator it( d->_list ); for (; it.current(); ++it) { ImageCollectionItem *item = static_cast( it.current() ); @@ -199,7 +199,7 @@ QValueList ImageCollectionSelector::selectedImageCollections() } void ImageCollectionSelector::slotSelectAll() { - QListViewItemIterator it( d->_list ); + TQListViewItemIterator it( d->_list ); /* note: the extensive use of blocksignals is to prevent bombarding the plugin with too many selection changed signals. do not remove @@ -216,7 +216,7 @@ void ImageCollectionSelector::slotSelectAll() { void ImageCollectionSelector::slotInvertSelection() { - QListViewItemIterator it( d->_list ); + TQListViewItemIterator it( d->_list ); /* note: the extensive use of blocksignals is to prevent bombarding the plugin with too many selection changed signals. do not remove @@ -233,7 +233,7 @@ void ImageCollectionSelector::slotInvertSelection() { void ImageCollectionSelector::slotSelectNone() { - QListViewItemIterator it( d->_list ); + TQListViewItemIterator it( d->_list ); /* note: the extensive use of blocksignals is to prevent bombarding the plugin with too many selection changed signals. do not remove @@ -248,7 +248,7 @@ void ImageCollectionSelector::slotSelectNone() { emit selectionChanged(); } -void ImageCollectionSelector::slotSelectionChanged(QListViewItem* listItem) +void ImageCollectionSelector::slotSelectionChanged(TQListViewItem* listItem) { if (d->_thumbLabel) d->_thumbLabel->clear(); @@ -266,22 +266,22 @@ void ImageCollectionSelector::slotSelectionChanged(QListViewItem* listItem) if (!images.isEmpty()) { KIO::PreviewJob* thumbJob = KIO::filePreview(images.first(), 128); - connect( thumbJob, SIGNAL(gotPreview(const KFileItem*, const QPixmap&)), - SLOT(slotGotPreview(const KFileItem* , const QPixmap&))); + connect( thumbJob, TQT_SIGNAL(gotPreview(const KFileItem*, const TQPixmap&)), + TQT_SLOT(slotGotPreview(const KFileItem* , const TQPixmap&))); } } // Layout the ImageCollection information nicely - QString cellBeg(""); - QString cellMid(""); - QString cellEnd(""); + TQString cellBeg(""); + TQString cellMid(""); + TQString cellEnd(""); - QString text(""); + TQString text("
"); // number of images text += cellBeg + i18n("Images:") + - cellMid + QString::number(imcollItem->imageCollection().images().count()) + + cellMid + TQString::number(imcollItem->imageCollection().images().count()) + cellEnd; // Optional features ------------------------------------------------------- @@ -290,7 +290,7 @@ void ImageCollectionSelector::slotSelectionChanged(QListViewItem* listItem) if (d->_interface->hasFeature(AlbumsHaveComments)) { // Limit the comments string to 20 char... - QString comments = imcollItem->imageCollection().comment(); + TQString comments = imcollItem->imageCollection().comment(); if (!comments.isEmpty()) { comments.truncate(20); @@ -313,7 +313,7 @@ void ImageCollectionSelector::slotSelectionChanged(QListViewItem* listItem) // Album Creation Date if (d->_interface->hasFeature(AlbumsHaveCreationDate)) { - QDate date(imcollItem->imageCollection().date()); + TQDate date(imcollItem->imageCollection().date()); text += cellBeg + i18n("Date:") + cellMid + KGlobal::locale()->formatDate(date) + cellEnd; @@ -327,7 +327,7 @@ void ImageCollectionSelector::slotSelectionChanged(QListViewItem* listItem) emit selectionChanged(); } -void ImageCollectionSelector::slotGotPreview(const KFileItem*, const QPixmap& pix) +void ImageCollectionSelector::slotGotPreview(const KFileItem*, const TQPixmap& pix) { d->_thumbLabel->setPixmap(pix); } diff --git a/libkipi/libkipi/imagecollectionselector.h b/libkipi/libkipi/imagecollectionselector.h index fd7a6ae..95fe29d 100644 --- a/libkipi/libkipi/imagecollectionselector.h +++ b/libkipi/libkipi/imagecollectionselector.h @@ -23,18 +23,18 @@ #ifndef IMAGECOLLECTIONSELECTOR_H #define IMAGECOLLECTIONSELECTOR_H -// Qt includes. +// TQt includes. -#include -#include -#include +#include +#include +#include // KIPI includes. #include "libkipi/imagecollection.h" #include "libkipi/libkipi_export.h" -class QListViewItem; +class TQListViewItem; class KFileItem; namespace KIPI @@ -42,17 +42,18 @@ namespace KIPI class Interface; -class LIBKIPI_EXPORT ImageCollectionSelector : public QWidget +class LIBKIPI_EXPORT ImageCollectionSelector : public TQWidget { Q_OBJECT + TQ_OBJECT class Private; public: - ImageCollectionSelector(QWidget* parent, Interface*, const char* name=0); + ImageCollectionSelector(TQWidget* tqparent, Interface*, const char* name=0); ~ImageCollectionSelector(); - QValueList selectedImageCollections() const; + TQValueList selectedImageCollections() const; signals: @@ -70,8 +71,8 @@ private slots: void slotSelectAll(); void slotInvertSelection(); void slotSelectNone(); - void slotSelectionChanged(QListViewItem* listItem); - void slotGotPreview(const KFileItem*, const QPixmap&); + void slotSelectionChanged(TQListViewItem* listItem); + void slotGotPreview(const KFileItem*, const TQPixmap&); void slotInitialShow(); }; diff --git a/libkipi/libkipi/imagecollectionshared.cpp b/libkipi/libkipi/imagecollectionshared.cpp index c8ebd37..a893b5c 100644 --- a/libkipi/libkipi/imagecollectionshared.cpp +++ b/libkipi/libkipi/imagecollectionshared.cpp @@ -76,7 +76,7 @@ KURL KIPI::ImageCollectionShared::uploadRoot() return KURL( "file:/" ); } -QString KIPI::ImageCollectionShared::uploadRootName() +TQString KIPI::ImageCollectionShared::uploadRootName() { return (i18n("Images")); } @@ -86,28 +86,28 @@ bool KIPI::ImageCollectionShared::isDirectory() return false; } -QString KIPI::ImageCollectionShared::comment() +TQString KIPI::ImageCollectionShared::comment() { kdWarning(51000) << "KIPI::ImageCollectionShared::comment should only be invoked if the host application supports\n" "the KIPI::Features AlbumsHaveComments - if the host application do support that, then this function should\n" "have been overriden in the host application.\n"; - return QString::null; + return TQString(); } -QString KIPI::ImageCollectionShared::category() +TQString KIPI::ImageCollectionShared::category() { kdWarning(51000) << "KIPI::ImageCollectionShared::category should only be invoked if the host application supports\n" "the KIPI::Features AlbumsHaveCategory - if the host application do support that, then this function should\n" "have been overriden in the host application.\n"; - return QString::null; + return TQString(); } -QDate KIPI::ImageCollectionShared::date() +TQDate KIPI::ImageCollectionShared::date() { kdWarning(51000) << "KIPI::ImageCollectionShared::date should only be invoked if the host application supports\n" "the KIPI::Features AlbumsHaveCreationDate - if the host application do support that, then this function should\n" "have been overriden in the host application.\n"; - return QDate(); + return TQDate(); } diff --git a/libkipi/libkipi/imagecollectionshared.h b/libkipi/libkipi/imagecollectionshared.h index 6a03d4e..f4c1445 100644 --- a/libkipi/libkipi/imagecollectionshared.h +++ b/libkipi/libkipi/imagecollectionshared.h @@ -23,10 +23,10 @@ #ifndef KIPI_IMAGECOLLECTIONSHARED_H #define KIPI_IMAGECOLLECTIONSHARED_H -// Qt Includes. +// TQt Includes. -#include -#include +#include +#include // KDE includes. @@ -44,15 +44,15 @@ namespace KIPI public: ImageCollectionShared(); virtual ~ImageCollectionShared() {} - virtual QString name() = 0; - virtual QString comment(); - virtual QString category(); - virtual QDate date(); + virtual TQString name() = 0; + virtual TQString comment(); + virtual TQString category(); + virtual TQDate date(); virtual KURL::List images() = 0; virtual KURL path(); virtual KURL uploadPath(); virtual KURL uploadRoot(); - virtual QString uploadRootName(); + virtual TQString uploadRootName(); virtual bool isDirectory(); virtual bool operator==(ImageCollectionShared&); diff --git a/libkipi/libkipi/imagedialog.cpp b/libkipi/libkipi/imagedialog.cpp index da5344d..b075e85 100644 --- a/libkipi/libkipi/imagedialog.cpp +++ b/libkipi/libkipi/imagedialog.cpp @@ -20,15 +20,15 @@ * * ============================================================ */ -// Qt includes. +// TQt includes. -#include -#include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include +#include // KDE includes. @@ -57,8 +57,8 @@ namespace KIPI { struct AlbumLVI : public KListViewItem { - AlbumLVI(KListView* parent, const KIPI::ImageCollection& album) - : KListViewItem(parent, album.name()) + AlbumLVI(KListView* tqparent, const KIPI::ImageCollection& album) + : KListViewItem(tqparent, album.name()) , _album(album) {} const KIPI::ImageCollection& _album; @@ -66,8 +66,8 @@ struct AlbumLVI : public KListViewItem { struct ImageLVI : public KListViewItem { - ImageLVI(KListView* parent, const KURL& url) - : KListViewItem(parent, url.fileName()), _url(url) {} + ImageLVI(KListView* tqparent, const KURL& url) + : KListViewItem(tqparent, url.fileName()), _url(url) {} KURL _url; }; @@ -79,46 +79,46 @@ struct ImageDialog::Private { KIPI::Interface* _interface; KListView* _albumList; KListView* _imageList; - QLabel* _preview; - QValueList _albums; + TQLabel* _preview; + TQValueList _albums; bool _singleSelection; }; -ImageDialog::ImageDialog(QWidget* parent, KIPI::Interface* interface, +ImageDialog::ImageDialog(TQWidget* tqparent, KIPI::Interface* interface, bool singleSelection) : KDialogBase(KDialogBase::Plain, i18n("Select Image From Album"), Help|Ok|Cancel, - Ok, parent, "album-dialog", true, true) + Ok, tqparent, "album-dialog", true, true) { d = new Private; d->_interface=interface; d->_singleSelection = singleSelection; - QWidget* box = plainPage(); - QVBoxLayout *dvlay = new QVBoxLayout( box, 6 ); + TQWidget* box = plainPage(); + TQVBoxLayout *dvlay = new TQVBoxLayout( box, 6 ); //--------------------------------------------- - QFrame *headerFrame = new QFrame( box ); - headerFrame->setFrameStyle(QFrame::Panel|QFrame::Sunken); - QHBoxLayout* layout = new QHBoxLayout( headerFrame ); - layout->setMargin( 2 ); // to make sure the frame gets displayed - layout->setSpacing( 0 ); - QLabel *pixmapLabelLeft = new QLabel( headerFrame, "pixmapLabelLeft" ); + TQFrame *headerFrame = new TQFrame( box ); + headerFrame->setFrameStyle(TQFrame::Panel|TQFrame::Sunken); + TQHBoxLayout* tqlayout = new TQHBoxLayout( headerFrame ); + tqlayout->setMargin( 2 ); // to make sure the frame gets displayed + tqlayout->setSpacing( 0 ); + TQLabel *pixmapLabelLeft = new TQLabel( headerFrame, "pixmapLabelLeft" ); pixmapLabelLeft->setScaledContents( false ); - layout->addWidget( pixmapLabelLeft ); - QLabel *labelTitle = new QLabel( i18n("Select Image From Album"), headerFrame, "labelTitle" ); - layout->addWidget( labelTitle ); - layout->setStretchFactor( labelTitle, 1 ); + tqlayout->addWidget( pixmapLabelLeft ); + TQLabel *labelTitle = new TQLabel( i18n("Select Image From Album"), headerFrame, "labelTitle" ); + tqlayout->addWidget( labelTitle ); + tqlayout->setStretchFactor( labelTitle, 1 ); dvlay->addWidget( headerFrame ); - QString directory; + TQString directory; KGlobal::dirs()->addResourceType("kipi_banner_left", KGlobal::dirs()->kde_default("data") + "kipi/data"); directory = KGlobal::dirs()->findResourceDir("kipi_banner_left", "banner_left.png"); - pixmapLabelLeft->setPaletteBackgroundColor( QColor(201, 208, 255) ); - pixmapLabelLeft->setPixmap( QPixmap( directory + "banner_left.png" ) ); - labelTitle->setPaletteBackgroundColor( QColor(201, 208, 255) ); + pixmapLabelLeft->setPaletteBackgroundColor( TQColor(201, 208, 255) ); + pixmapLabelLeft->setPixmap( TQPixmap( directory + "banner_left.png" ) ); + labelTitle->setPaletteBackgroundColor( TQColor(201, 208, 255) ); //--------------------------------------------- @@ -133,52 +133,52 @@ ImageDialog::ImageDialog(QWidget* parent, KIPI::Interface* interface, 0, "http://extragear.kde.org/apps/kipi"); - QPushButton *helpButton = actionButton( Help ); + TQPushButton *helpButton = actionButton( Help ); KHelpMenu* helpMenu = new KHelpMenu(this, about, false); helpMenu->menu()->removeItemAt(0); - helpMenu->menu()->insertItem(i18n("Kipi Plugins Handbooks"), this, SLOT(slotHelp()), 0, -1, 0); + helpMenu->menu()->insertItem(i18n("Kipi Plugins Handbooks"), this, TQT_SLOT(slotHelp()), 0, -1, 0); helpButton->setPopup( helpMenu->menu() ); //--------------------------------------------- - QSplitter* splitter = new QSplitter(box); + TQSplitter* splitter = new TQSplitter(box); d->_albumList=new KListView(splitter); d->_albumList->addColumn(i18n("Album Name")); d->_albumList->setMinimumWidth(200); - d->_albumList->setResizeMode(QListView::LastColumn); + d->_albumList->setResizeMode(TQListView::LastColumn); d->_imageList=new KListView(splitter); d->_imageList->addColumn(i18n("Image Name")); d->_imageList->setMinimumWidth(200); - d->_imageList->setSelectionMode(singleSelection ? QListView::Single : - QListView::Extended); - d->_imageList->setResizeMode(QListView::LastColumn); + d->_imageList->setSelectionMode(singleSelection ? TQListView::Single : + TQListView::Extended); + d->_imageList->setResizeMode(TQListView::LastColumn); - d->_preview=new QLabel(splitter); - d->_preview->setAlignment(AlignHCenter | AlignVCenter | WordBreak); + d->_preview=new TQLabel(splitter); + d->_preview->tqsetAlignment(AlignHCenter | AlignVCenter | WordBreak); d->_preview->setFixedWidth(PREVIEW_SIZE); d->_preview->setText(i18n("No image selected")); dvlay->addWidget( splitter ); d->_albums=d->_interface->allAlbums(); - QValueList::ConstIterator it=d->_albums.begin(); + TQValueList::ConstIterator it=d->_albums.begin(); for(; it!=d->_albums.end(); ++it) { new AlbumLVI(d->_albumList, *it); } - QTimer::singleShot(0, this, SLOT(slotInitialShow())); + TQTimer::singleShot(0, this, TQT_SLOT(slotInitialShow())); - connect(d->_albumList, SIGNAL(selectionChanged(QListViewItem*)), - this, SLOT(fillImageList(QListViewItem*)) ); + connect(d->_albumList, TQT_SIGNAL(selectionChanged(TQListViewItem*)), + this, TQT_SLOT(fillImageList(TQListViewItem*)) ); if (singleSelection) - connect(d->_imageList, SIGNAL(selectionChanged(QListViewItem*)), - this, SLOT(slotImageSelected(QListViewItem*)) ); + connect(d->_imageList, TQT_SIGNAL(selectionChanged(TQListViewItem*)), + this, TQT_SLOT(slotImageSelected(TQListViewItem*)) ); else - connect(d->_imageList, SIGNAL(selectionChanged()), - this, SLOT(slotImagesSelected())); + connect(d->_imageList, TQT_SIGNAL(selectionChanged()), + this, TQT_SLOT(slotImagesSelected())); enableButtonOK(false); } @@ -198,19 +198,19 @@ KURL::List ImageDialog::urls() const return d->_urls; } -KURL ImageDialog::getImageURL(QWidget* parent, KIPI::Interface* interface) { - ImageDialog dlg(parent, interface, true); - if (dlg.exec() == QDialog::Accepted) { +KURL ImageDialog::getImageURL(TQWidget* tqparent, KIPI::Interface* interface) { + ImageDialog dlg(tqparent, interface, true); + if (dlg.exec() == TQDialog::Accepted) { return dlg.url(); } else { return KURL(); } } -KURL::List ImageDialog::getImageURLs(QWidget* parent, Interface* interface) +KURL::List ImageDialog::getImageURLs(TQWidget* tqparent, Interface* interface) { - ImageDialog dlg(parent, interface, false); - if (dlg.exec() == QDialog::Accepted) + ImageDialog dlg(tqparent, interface, false); + if (dlg.exec() == TQDialog::Accepted) return dlg.urls(); else { @@ -220,7 +220,7 @@ KURL::List ImageDialog::getImageURLs(QWidget* parent, Interface* interface) } -void ImageDialog::fillImageList(QListViewItem* item) { +void ImageDialog::fillImageList(TQListViewItem* item) { d->_imageList->clear(); if (!item) return; @@ -234,7 +234,7 @@ void ImageDialog::fillImageList(QListViewItem* item) { } -void ImageDialog::slotImageSelected(QListViewItem* item) { +void ImageDialog::slotImageSelected(TQListViewItem* item) { if (!item) { enableButtonOK(false); d->_preview->setText(i18n("No image selected")); @@ -246,8 +246,8 @@ void ImageDialog::slotImageSelected(QListViewItem* item) { d->_preview->clear(); KIO::PreviewJob* thumbJob = KIO::filePreview(d->_url, PREVIEW_SIZE); - connect( thumbJob, SIGNAL(gotPreview(const KFileItem*, const QPixmap&)), - SLOT(slotGotPreview(const KFileItem* , const QPixmap&))); + connect( thumbJob, TQT_SIGNAL(gotPreview(const KFileItem*, const TQPixmap&)), + TQT_SLOT(slotGotPreview(const KFileItem* , const TQPixmap&))); } void ImageDialog::slotImagesSelected() @@ -256,8 +256,8 @@ void ImageDialog::slotImagesSelected() d->_urls.clear(); d->_preview->clear(); - QListViewItem* selectedItem = 0; - QListViewItem* listItem = d->_imageList->firstChild(); + TQListViewItem* selectedItem = 0; + TQListViewItem* listItem = d->_imageList->firstChild(); while (listItem) { if (listItem->isSelected()) @@ -284,8 +284,8 @@ void ImageDialog::slotImagesSelected() d->_url = d->_urls.first(); KIO::PreviewJob* thumbJob = KIO::filePreview(d->_url, PREVIEW_SIZE); - connect( thumbJob, SIGNAL(gotPreview(const KFileItem*, const QPixmap&)), - SLOT(slotGotPreview(const KFileItem* , const QPixmap&))); + connect( thumbJob, TQT_SIGNAL(gotPreview(const KFileItem*, const TQPixmap&)), + TQT_SLOT(slotGotPreview(const KFileItem* , const TQPixmap&))); } else { @@ -294,7 +294,7 @@ void ImageDialog::slotImagesSelected() } } -void ImageDialog::slotGotPreview(const KFileItem*, const QPixmap& pix) { +void ImageDialog::slotGotPreview(const KFileItem*, const TQPixmap& pix) { d->_preview->setPixmap(pix); } @@ -308,7 +308,7 @@ void ImageDialog::slotInitialShow() { ImageCollection current = d->_interface->currentAlbum(); - QListViewItemIterator it( d->_albumList ); + TQListViewItemIterator it( d->_albumList ); while ( it.current() ) { AlbumLVI* lvi = static_cast( it.current() ); diff --git a/libkipi/libkipi/imagedialog.h b/libkipi/libkipi/imagedialog.h index d23419c..27021e2 100644 --- a/libkipi/libkipi/imagedialog.h +++ b/libkipi/libkipi/imagedialog.h @@ -23,10 +23,10 @@ #ifndef IMAGEDIALOG_H #define IMAGEDIALOG_H -// Qt includes. +// TQt includes. -#include -#include +#include +#include // KDE includes. @@ -39,7 +39,7 @@ #include "libkipi/imagecollection.h" #include "libkipi/libkipi_export.h" -class QListViewItem; +class TQListViewItem; class KFileItem; class KListView; @@ -51,26 +51,27 @@ namespace KIPI class LIBKIPI_EXPORT ImageDialog : public KDialogBase { Q_OBJECT + TQ_OBJECT class Private; public: - ImageDialog(QWidget*, Interface*, bool singleSelection=false); + ImageDialog(TQWidget*, Interface*, bool singleSelection=false); ~ImageDialog(); KURL url() const; KURL::List urls() const; - static KURL getImageURL(QWidget*, Interface*); - static KURL::List getImageURLs(QWidget*, Interface*); + static KURL getImageURL(TQWidget*, Interface*); + static KURL::List getImageURLs(TQWidget*, Interface*); private slots: - void fillImageList(QListViewItem*); - void slotImageSelected(QListViewItem*); + void fillImageList(TQListViewItem*); + void slotImageSelected(TQListViewItem*); void slotImagesSelected(); - void slotGotPreview(const KFileItem* , const QPixmap&); + void slotGotPreview(const KFileItem* , const TQPixmap&); void slotHelp( void ); void slotInitialShow(); diff --git a/libkipi/libkipi/imageinfo.cpp b/libkipi/libkipi/imageinfo.cpp index 536dbf3..01debc4 100644 --- a/libkipi/libkipi/imageinfo.cpp +++ b/libkipi/libkipi/imageinfo.cpp @@ -25,9 +25,9 @@ /** @file imageinfo.cpp */ -QString KIPI::ImageInfo::toString( const QVariant& data ) const +TQString KIPI::ImageInfo::toString( const TQVariant& data ) const { - QString string; + TQString string; KDStream stream( &string ); stream << data << flush ; @@ -37,7 +37,7 @@ QString KIPI::ImageInfo::toString( const QVariant& data ) const /** PENDING(blackie) document */ -QString KIPI::ImageInfo::title() const +TQString KIPI::ImageInfo::title() const { return _data->title(); } @@ -53,7 +53,7 @@ KURL KIPI::ImageInfo::path() const /** PENDING(blackie) document */ -QString KIPI::ImageInfo::description() const +TQString KIPI::ImageInfo::description() const { return _data->description(); } @@ -63,7 +63,7 @@ QString KIPI::ImageInfo::description() const In case the host application supports time range, the spec argument specifies if it is the start or end time that should be returned. */ -QDateTime KIPI::ImageInfo::time( TimeSpec spec ) const +TQDateTime KIPI::ImageInfo::time( TimeSpec spec ) const { return _data->time( spec ); } @@ -72,11 +72,11 @@ QDateTime KIPI::ImageInfo::time( TimeSpec spec ) const Returns a Map of attributes of the image In case the host application supports some special attributes of the image this function can be used to return them. - Tags are supported by this feature: "tags" key contains QStringList() - encapsulated in a QVariant + Tags are supported by this feature: "tags" key contains TQStringList() + encapsulated in a TQVariant */ -QMap KIPI::ImageInfo::attributes() const +TQMap KIPI::ImageInfo::attributes() const { return _data->attributes(); } @@ -105,12 +105,12 @@ KIPI::ImageInfo::~ImageInfo() _data->removeRef(); } -void KIPI::ImageInfo::setTitle( const QString& name ) +void KIPI::ImageInfo::setTitle( const TQString& name ) { _data->setTitle( name ); } -void KIPI::ImageInfo::setDescription( const QString& description ) +void KIPI::ImageInfo::setDescription( const TQString& description ) { _data->setDescription( description ); } @@ -120,7 +120,7 @@ void KIPI::ImageInfo::clearAttributes() _data->clearAttributes(); } -void KIPI::ImageInfo::addAttributes( const QMap& attributes ) +void KIPI::ImageInfo::addAttributes( const TQMap& attributes ) { _data->addAttributes( attributes ); } @@ -154,7 +154,7 @@ bool KIPI::ImageInfo::isTimeExact() const return _data->isTimeExact(); } -void KIPI::ImageInfo::setTime( const QDateTime& time, TimeSpec spec ) +void KIPI::ImageInfo::setTime( const TQDateTime& time, TimeSpec spec ) { _data->setTime( time, spec ); } diff --git a/libkipi/libkipi/imageinfo.h b/libkipi/libkipi/imageinfo.h index f9b98f2..b3bf849 100644 --- a/libkipi/libkipi/imageinfo.h +++ b/libkipi/libkipi/imageinfo.h @@ -24,10 +24,10 @@ #ifndef KIPI_IMAGEINFO_H #define KIPI_IMAGEINFO_H #include -#include -#include -#include -#include +#include +#include +#include +#include #include "libkipi/libkipi_export.h" namespace KIPI @@ -41,26 +41,26 @@ namespace KIPI class LIBKIPI_EXPORT ImageInfo { public: - QString title() const; - void setTitle( const QString& name ); + TQString title() const; + void setTitle( const TQString& name ); - QString description() const; - void setDescription( const QString& description); + TQString description() const; + void setDescription( const TQString& description); - QMap attributes() const; + TQMap attributes() const; void clearAttributes(); - void addAttributes( const QMap& ); + void addAttributes( const TQMap& ); KURL path() const; - QDateTime time( TimeSpec spec = FromInfo ) const; - void setTime( const QDateTime& time, TimeSpec spec = FromInfo ); + TQDateTime time( TimeSpec spec = FromInfo ) const; + void setTime( const TQDateTime& time, TimeSpec spec = FromInfo ); bool isTimeExact() const; int size() const; int angle() const; void setAngle( int ); - QString toString( const QVariant& ) const; + TQString toString( const TQVariant& ) const; void cloneData( const ImageInfo& other ); diff --git a/libkipi/libkipi/imageinfoshared.cpp b/libkipi/libkipi/imageinfoshared.cpp index f206e3b..b123d60 100644 --- a/libkipi/libkipi/imageinfoshared.cpp +++ b/libkipi/libkipi/imageinfoshared.cpp @@ -20,9 +20,9 @@ * * ============================================================ */ -// Qt includes. +// TQt includes. -#include +#include // KDE includes. @@ -50,17 +50,17 @@ int KIPI::ImageInfoShared::size() return 0; } else - return QFileInfo( _url.path() ).size(); + return TQFileInfo( _url.path() ).size(); } -QDateTime KIPI::ImageInfoShared::time( KIPI::TimeSpec ) +TQDateTime KIPI::ImageInfoShared::time( KIPI::TimeSpec ) { if ( ! _url.isLocalFile() ) { kdFatal() << "KIPI::ImageInfoShared::time does not yet support non local files, please fix\n"; - return QDateTime(); + return TQDateTime(); } else - return QFileInfo( _url.path() ).lastModified(); + return TQFileInfo( _url.path() ).lastModified(); } void KIPI::ImageInfoShared::addRef() @@ -90,11 +90,11 @@ bool KIPI::ImageInfoShared::isTimeExact() return true; } -void KIPI::ImageInfoShared::setTime( const QDateTime& /*time*/, TimeSpec /*spec*/ ) +void KIPI::ImageInfoShared::setTime( const TQDateTime& /*time*/, TimeSpec /*spec*/ ) { } -void KIPI::ImageInfoShared::setTitle( const QString& ) +void KIPI::ImageInfoShared::setTitle( const TQString& ) { kdWarning(51000) << "This method should only be invoked if the host application supports the KIPI::ImageTitlesWritable\n" "If the host application do support that, then this function should\n" diff --git a/libkipi/libkipi/imageinfoshared.h b/libkipi/libkipi/imageinfoshared.h index afdbc1d..d39fb02 100644 --- a/libkipi/libkipi/imageinfoshared.h +++ b/libkipi/libkipi/imageinfoshared.h @@ -23,12 +23,12 @@ #ifndef KIPI_IMAGEINFOSHARED_H #define KIPI_IMAGEINFOSHARED_H -// Qt includes. +// TQt includes. -#include -#include -#include -#include +#include +#include +#include +#include // KDE includes. @@ -48,19 +48,19 @@ namespace KIPI public: ImageInfoShared( KIPI::Interface* interface, const KURL& url ); virtual ~ImageInfoShared() {} - virtual QString title() {return QString::null;} - virtual void setTitle( const QString& ); + virtual TQString title() {return TQString();} + virtual void setTitle( const TQString& ); - virtual QString description() = 0; - virtual void setDescription( const QString& ) = 0; + virtual TQString description() = 0; + virtual void setDescription( const TQString& ) = 0; - virtual QMap attributes() = 0; + virtual TQMap attributes() = 0; virtual void clearAttributes() = 0; - virtual void addAttributes( const QMap& ) = 0; + virtual void addAttributes( const TQMap& ) = 0; virtual KURL path(); - virtual QDateTime time( KIPI::TimeSpec spec ); - virtual void setTime( const QDateTime& time, TimeSpec spec = FromInfo ); + virtual TQDateTime time( KIPI::TimeSpec spec ); + virtual void setTime( const TQDateTime& time, TimeSpec spec = FromInfo ); virtual bool isTimeExact(); @@ -69,7 +69,7 @@ namespace KIPI virtual int angle(); virtual void setAngle( int ); - QString toString( const QVariant& ); + TQString toString( const TQVariant& ); virtual void cloneData( ImageInfoShared* other ); diff --git a/libkipi/libkipi/interface.cpp b/libkipi/libkipi/interface.cpp index 8adc3b0..bc6a422 100644 --- a/libkipi/libkipi/interface.cpp +++ b/libkipi/libkipi/interface.cpp @@ -40,7 +40,7 @@ for albums. Thus before a plugin expect a decant value for the comment, it should check whether KIPI::AlbumsHaveComments are set. It does so using KIPI::Interface::hasFeature() - When adding new items, remember to update "hasFeature( const QString& feature )" + When adding new items, remember to update "hasFeature( const TQString& feature )" and the hello world plugin. */ @@ -95,8 +95,8 @@ */ -KIPI::Interface::Interface(QObject *parent, const char *name ) - : QObject(parent, name) +KIPI::Interface::Interface(TQObject *tqparent, const char *name ) + : TQObject(tqparent, name) { } @@ -120,7 +120,7 @@ bool KIPI::Interface::hasFeature( KIPI::Features feature ) return ( features() & feature ) != 0; } -bool KIPI::Interface::hasFeature( const QString& feature ) +bool KIPI::Interface::hasFeature( const TQString& feature ) { if ( feature == "AlbumsHaveComments" ) return hasFeature( KIPI::AlbumsHaveComments ); @@ -153,7 +153,7 @@ bool KIPI::Interface::hasFeature( const QString& feature ) Returns true if the host application did accept the new image, otherwise err will be filled with an error description. */ -bool KIPI::Interface::addImage( const KURL&, QString& /*err*/ ) +bool KIPI::Interface::addImage( const KURL&, TQString& /*err*/ ) { kdWarning(51000) << "Interface::addImage should only be invoked if the host application supports the KIPI::Features\n" "AcceptNewImages - if the host application do support that, then this function should\n" @@ -190,10 +190,10 @@ KIPI::ImageCollection KIPI::Interface::currentSelection() /** Returns a list of albums. */ -QValueList KIPI::Interface::allAlbums() +TQValueList KIPI::Interface::allAlbums() { // This implementation is just to be able to write documentation above. - return QValueList(); + return TQValueList(); } @@ -211,10 +211,10 @@ int KIPI::Interface::features() const to sort the files list before a treatment. The default implementation return, the supported images formats by KDE. */ -QString KIPI::Interface::fileExtensions() +TQString KIPI::Interface::fileExtensions() { - QStringList KDEImagetypes = KImageIO::mimeTypes( KImageIO::Reading ); - QString imagesFileFilter = KDEImagetypes.join(" "); + TQStringList KDEImagetypes = KImageIO::mimeTypes( KImageIO::Reading ); + TQString imagesFileFilter = KDEImagetypes.join(" "); return ( imagesFileFilter.lower() + " " + imagesFileFilter.upper() ); } diff --git a/libkipi/libkipi/interface.h b/libkipi/libkipi/interface.h index dfccf08..a33f31d 100644 --- a/libkipi/libkipi/interface.h +++ b/libkipi/libkipi/interface.h @@ -24,10 +24,10 @@ #ifndef KIPI_INTERFACE_H #define KIPI_INTERFACE_H -// Qt includes. +// TQt includes. -#include -#include +#include +#include // KDE includes. @@ -56,25 +56,26 @@ namespace KIPI }; /** class Interface */ - class LIBKIPI_EXPORT Interface : public QObject + class LIBKIPI_EXPORT Interface : public TQObject { Q_OBJECT + TQ_OBJECT public: - Interface(QObject *parent, const char *name=0); + Interface(TQObject *tqparent, const char *name=0); virtual ~Interface(); virtual ImageCollection currentAlbum() = 0; virtual ImageCollection currentSelection() = 0; - virtual QValueList allAlbums() = 0; + virtual TQValueList allAlbums() = 0; virtual ImageInfo info( const KURL& ) = 0; - virtual bool addImage( const KURL&, QString& err ); + virtual bool addImage( const KURL&, TQString& err ); virtual void delImage( const KURL& ); virtual void refreshImages( const KURL::List& ); - virtual QString fileExtensions(); + virtual TQString fileExtensions(); bool hasFeature( KIPI::Features feature ); @@ -83,7 +84,7 @@ namespace KIPI private: friend class PluginLoader; - bool hasFeature( const QString& feature ); + bool hasFeature( const TQString& feature ); signals: void selectionChanged( bool hasSelection ); diff --git a/libkipi/libkipi/mainpage.cpp b/libkipi/libkipi/mainpage.cpp index 0347fc7..ebe37b8 100644 --- a/libkipi/libkipi/mainpage.cpp +++ b/libkipi/libkipi/mainpage.cpp @@ -48,7 +48,7 @@ application. The origin of all your communication with the host application is - \ref KIPI::Interface. You obtain a pointer to this by casting the parent + \ref KIPI::Interface. You obtain a pointer to this by casting the tqparent pointer given to your plugin during construction. Selection of images can be obtained using diff --git a/libkipi/libkipi/plugin.cpp b/libkipi/libkipi/plugin.cpp index 920a31e..61a7d2a 100644 --- a/libkipi/libkipi/plugin.cpp +++ b/libkipi/libkipi/plugin.cpp @@ -20,9 +20,9 @@ * * ============================================================ */ -// Qt includes. +// TQt includes. -#include +#include // KDE includes. @@ -36,15 +36,15 @@ struct KIPI::Plugin::Private { - QMap m_actionCollection; + TQMap m_actionCollection; KInstance* m_instance; - QMap m_actions; - QWidget* m_defaultWidget; + TQMap m_actions; + TQWidget* m_defaultWidget; }; -KIPI::Plugin::Plugin( KInstance* instance, QObject *parent, const char* name) - : QObject( parent, name) +KIPI::Plugin::Plugin( KInstance* instance, TQObject *tqparent, const char* name) + : TQObject( tqparent, name) { d=new Private; d->m_instance=instance; @@ -55,13 +55,13 @@ KIPI::Plugin::~Plugin() delete d; } -KActionCollection* KIPI::Plugin::actionCollection( QWidget* widget ) +KActionCollection* KIPI::Plugin::actionCollection( TQWidget* widget ) { if ( widget == 0 ) widget = d->m_defaultWidget; - if (!d->m_actionCollection.contains( widget )) - kdWarning( 51000 ) << "Error in the plugin. The plugin needs to call Plugin::setup( QWidget* ) " + if (!d->m_actionCollection.tqcontains( widget )) + kdWarning( 51000 ) << "Error in the plugin. The plugin needs to call Plugin::setup( TQWidget* ) " << "as the very first line when overriding the setup method." << endl; return d->m_actionCollection[widget]; } @@ -71,7 +71,7 @@ void KIPI::Plugin::addAction( KAction* action ) d->m_actions[d->m_defaultWidget].append( action ); } -KActionPtrList KIPI::Plugin::actions( QWidget* widget ) +KActionPtrList KIPI::Plugin::actions( TQWidget* widget ) { if ( widget == 0 ) widget = d->m_defaultWidget; @@ -79,12 +79,12 @@ KActionPtrList KIPI::Plugin::actions( QWidget* widget ) return d->m_actions[widget]; } -void KIPI::Plugin::setup( QWidget* widget ) +void KIPI::Plugin::setup( TQWidget* widget ) { d->m_defaultWidget = widget; d->m_actions.insert( widget, KActionPtrList() ); - QString name = QString( "action collection for %1" ).arg( widget->name() ); - d->m_actionCollection.insert( widget, new KActionCollection( widget, widget, name.latin1(), d->m_instance ) ); + TQString name = TQString( "action collection for %1" ).tqarg( widget->name() ); + d->m_actionCollection.insert( widget, new KActionCollection( widget, TQT_TQOBJECT(widget), name.latin1(), d->m_instance ) ); } diff --git a/libkipi/libkipi/plugin.h b/libkipi/libkipi/plugin.h index f55942c..bd9ba68 100644 --- a/libkipi/libkipi/plugin.h +++ b/libkipi/libkipi/plugin.h @@ -23,9 +23,9 @@ #ifndef KIPI_PLUGIN_H #define KIPI_PLUGIN_H -// Qt includes. +// TQt includes. -#include +#include // KDE includes. @@ -53,15 +53,15 @@ namespace KIPI COLLECTIONSPLUGIN }; - class LIBKIPI_EXPORT Plugin : public QObject + class LIBKIPI_EXPORT Plugin : public TQObject { public: - Plugin( KInstance* instance, QObject *parent, const char* name); + Plugin( KInstance* instance, TQObject *tqparent, const char* name); virtual ~Plugin(); - virtual void setup( QWidget* widget ) = 0; - KActionPtrList actions( QWidget* parent = 0 ); - KActionCollection* actionCollection( QWidget* parent = 0 ); + virtual void setup( TQWidget* widget ) = 0; + KActionPtrList actions( TQWidget* tqparent = 0 ); + KActionCollection* actionCollection( TQWidget* tqparent = 0 ); virtual Category category( KAction* action ) const = 0; protected: diff --git a/libkipi/libkipi/pluginloader.cpp b/libkipi/libkipi/pluginloader.cpp index f7f8aa5..9afe858 100644 --- a/libkipi/libkipi/pluginloader.cpp +++ b/libkipi/libkipi/pluginloader.cpp @@ -21,7 +21,7 @@ /** @file pluginloader.cpp */ -#include +#include #include #include @@ -32,8 +32,8 @@ #include "pluginloader.h" #include "interface.h" #include -#include -#include +#include +#include /** \author Renchi Raju @@ -55,13 +55,13 @@ Then plugin plugins into menus could be done with code similiar to this from KimDaBa: \code void slotReplug() { - unplugActionList( QString::fromLatin1("file_actions") ); - unplugActionList( QString::fromLatin1("image_actions") ); - unplugActionList( QString::fromLatin1("tool_actions") ); + unplugActionList( TQString::tqfromLatin1("file_actions") ); + unplugActionList( TQString::tqfromLatin1("image_actions") ); + unplugActionList( TQString::tqfromLatin1("tool_actions") ); - QPtrList fileActions; - QPtrList imageActions; - QPtrList toolsActions; + TQPtrList fileActions; + TQPtrList imageActions; + TQPtrList toolsActions; KIPI::PluginLoader::PluginList list = _pluginLoader->pluginList(); for( KIPI::PluginLoader::PluginList::Iterator it = list.begin(); it != list.end(); ++it ) { @@ -70,7 +70,7 @@ continue; plugin->setup( this ); - QPtrList* popup = 0; + TQPtrList* popup = 0; if ( plugin->category() == KIPI::IMAGESPLUGIN ) popup = &imageActions; @@ -94,9 +94,9 @@ } // For this to work I need to pass false as second arg for createGUI - plugActionList( QString::fromLatin1("file_actions"), fileActions ); - plugActionList( QString::fromLatin1("image_actions"), imageActions ); - plugActionList( QString::fromLatin1("tool_actions"), toolsActions ); + plugActionList( TQString::tqfromLatin1("file_actions"), fileActions ); + plugActionList( TQString::tqfromLatin1("image_actions"), imageActions ); + plugActionList( TQString::tqfromLatin1("tool_actions"), toolsActions ); } \endcode @@ -112,15 +112,15 @@ namespace KIPI { // //--------------------------------------------------------------------- struct PluginLoader::Info::Private { - QString m_name; - QString m_comment; - QString m_library; + TQString m_name; + TQString m_comment; + TQString m_library; Plugin* m_plugin; bool m_shouldLoad; }; -PluginLoader::Info::Info(const QString& name, const QString& comment, const QString& library, bool shouldLoad) +PluginLoader::Info::Info(const TQString& name, const TQString& comment, const TQString& library, bool shouldLoad) { d=new Private; d->m_name=name; @@ -137,19 +137,19 @@ PluginLoader::Info::~Info() } -QString PluginLoader::Info::name() const +TQString PluginLoader::Info::name() const { return d->m_name; } -QString PluginLoader::Info::comment() const +TQString PluginLoader::Info::comment() const { return d->m_comment; } -QString PluginLoader::Info::library() const +TQString PluginLoader::Info::library() const { return d->m_library; } @@ -191,11 +191,11 @@ struct PluginLoader::Private { PluginList m_pluginList; Interface* m_interface; - QStringList m_ignores; + TQStringList m_ignores; }; -PluginLoader::PluginLoader( const QStringList& ignores, Interface* interface ) +PluginLoader::PluginLoader( const TQStringList& ignores, Interface* interface ) { Q_ASSERT( s_instance == 0 ); s_instance = this; @@ -206,29 +206,29 @@ PluginLoader::PluginLoader( const QStringList& ignores, Interface* interface ) KTrader::OfferList offers = KTrader::self()->query("KIPI/Plugin"); KConfig* config = KGlobal::config(); - config->setGroup( QString::fromLatin1( "KIPI/EnabledPlugin" ) ); + config->setGroup( TQString::tqfromLatin1( "KIPI/EnabledPlugin" ) ); KTrader::OfferList::ConstIterator iter; for(iter = offers.begin(); iter != offers.end(); ++iter) { KService::Ptr service = *iter; - QString name = service->name(); - QString comment = service->comment(); - QString library = service->library(); - QStringList reqFeatures = service->property( QString::fromLatin1( "X-KIPI-ReqFeatures" ) ).toStringList(); + TQString name = service->name(); + TQString comment = service->comment(); + TQString library = service->library(); + TQStringList reqFeatures = service->property( TQString::tqfromLatin1( "X-KIPI-ReqFeatures" ) ).toStringList(); if (library.isEmpty() || name.isEmpty() ) { kdWarning( 51001 ) << "KIPI::PluginLoader: Plugin had an empty name or library file - this should not happen." << endl; continue; } - if ( d->m_ignores.contains( name ) ) { + if ( d->m_ignores.tqcontains( name ) ) { kdDebug( 51001 ) << "KIPI::PluginLoader: plugin " << name << " is in the ignore list for host application" << endl; continue; } bool appHasAllReqFeatures=true; - for( QStringList::Iterator featureIt = reqFeatures.begin(); featureIt != reqFeatures.end(); ++featureIt ) { + for( TQStringList::Iterator featureIt = reqFeatures.begin(); featureIt != reqFeatures.end(); ++featureIt ) { if ( !d->m_interface->hasFeature( *featureIt ) ) { kdDebug( 51001 ) << "Plugin " << name << " was not loaded because the host application is missing\n" << "the feature " << *featureIt << endl; @@ -267,7 +267,7 @@ void PluginLoader::loadPlugin( Info* info ) int error; plugin = KParts::ComponentFactory ::createInstanceFromLibrary(info->library().local8Bit().data(), - d->m_interface, 0, QStringList(), &error); + d->m_interface, 0, TQStringList(), &error); if (plugin) kdDebug( 51001 ) << "KIPI::PluginLoader: Loaded plugin " << plugin->name()<< endl; @@ -306,17 +306,17 @@ PluginLoader* PluginLoader::instance() // ConfigWidget // //--------------------------------------------------------------------- -ConfigWidget* PluginLoader::configWidget( QWidget* parent ) +ConfigWidget* PluginLoader::configWidget( TQWidget* tqparent ) { - return new ConfigWidget( parent ); + return new ConfigWidget( tqparent ); } -class PluginCheckBox :public QCheckBox +class PluginCheckBox :public TQCheckBox { public: - PluginCheckBox( PluginLoader::Info* info, QWidget* parent ) - : QCheckBox( info->comment(), parent ), info( info ) + PluginCheckBox( PluginLoader::Info* info, TQWidget* tqparent ) + : TQCheckBox( info->comment(), tqparent ), info( info ) { setChecked( info->shouldLoad() ); } @@ -326,19 +326,19 @@ public: struct ConfigWidget::Private { - QValueList< PluginCheckBox* > _boxes; + TQValueList< PluginCheckBox* > _boxes; }; -ConfigWidget::ConfigWidget( QWidget* parent ) - :QScrollView( parent, "KIPI::PluginLoader::ConfigWidget" ) +ConfigWidget::ConfigWidget( TQWidget* tqparent ) + :TQScrollView( tqparent, "KIPI::PluginLoader::ConfigWidget" ) { d=new Private; - QWidget* top = new QWidget( viewport() ); + TQWidget* top = new TQWidget( viewport() ); addChild( top ); setResizePolicy( AutoOneFit ); - QVBoxLayout* lay = new QVBoxLayout( top, KDialog::marginHint(), KDialog::spacingHint() ); + TQVBoxLayout* lay = new TQVBoxLayout( top, KDialog::marginHint(), KDialog::spacingHint() ); PluginLoader::PluginList list = PluginLoader::instance()->d->m_pluginList; for( PluginLoader::PluginList::Iterator it = list.begin(); it != list.end(); ++it ) { @@ -360,10 +360,10 @@ ConfigWidget::~ConfigWidget() void ConfigWidget::apply() { KConfig* config = KGlobal::config(); - config->setGroup( QString::fromLatin1( "KIPI/EnabledPlugin" ) ); + config->setGroup( TQString::tqfromLatin1( "KIPI/EnabledPlugin" ) ); bool changes = false; - for( QValueList::Iterator it = d->_boxes.begin(); it != d->_boxes.end(); ++it ) { + for( TQValueList::Iterator it = d->_boxes.begin(); it != d->_boxes.end(); ++it ) { bool orig = (*it)->info->shouldLoad(); bool load = (*it)->isChecked(); if ( orig != load ) { diff --git a/libkipi/libkipi/pluginloader.h b/libkipi/libkipi/pluginloader.h index 28455ca..8f3dd96 100644 --- a/libkipi/libkipi/pluginloader.h +++ b/libkipi/libkipi/pluginloader.h @@ -24,8 +24,8 @@ #include "libkipi/interface.h" #include "libkipi/libkipi_export.h" -#include -#include +#include +#include namespace KIPI @@ -34,20 +34,21 @@ namespace KIPI class Interface; class ConfigWidget; - class LIBKIPI_EXPORT PluginLoader :public QObject + class LIBKIPI_EXPORT PluginLoader :public TQObject { Q_OBJECT + TQ_OBJECT public: class LIBKIPI_EXPORT Info { public: - Info( const QString& name, const QString& comment, const QString& library, bool shouldLoad ); + Info( const TQString& name, const TQString& comment, const TQString& library, bool shouldLoad ); ~Info(); - QString name() const; + TQString name() const; - QString comment() const; + TQString comment() const; - QString library() const; + TQString library() const; Plugin* plugin() const; void setPlugin(Plugin*); @@ -60,13 +61,13 @@ namespace KIPI Private* d; }; - PluginLoader( const QStringList& ignores, Interface* interface ); + PluginLoader( const TQStringList& ignores, Interface* interface ); virtual ~PluginLoader(); void loadPlugins(); static PluginLoader* instance(); - ConfigWidget* configWidget( QWidget* parent ); + ConfigWidget* configWidget( TQWidget* tqparent ); - typedef QValueList PluginList; + typedef TQValueList PluginList; const PluginList& pluginList(); @@ -85,11 +86,12 @@ namespace KIPI Private* d; }; - class LIBKIPI_EXPORT ConfigWidget :public QScrollView + class LIBKIPI_EXPORT ConfigWidget :public TQScrollView { Q_OBJECT + TQ_OBJECT public: - ConfigWidget( QWidget* parent ); + ConfigWidget( TQWidget* tqparent ); ~ConfigWidget(); public slots: void apply(); diff --git a/libkipi/libkipi/uploadwidget.cpp b/libkipi/libkipi/uploadwidget.cpp index 80e0a5c..50bdae8 100644 --- a/libkipi/libkipi/uploadwidget.cpp +++ b/libkipi/libkipi/uploadwidget.cpp @@ -20,12 +20,12 @@ * * ============================================================ */ -// Qt includes. +// TQt includes. -#include -#include -#include -#include +#include +#include +#include +#include // KDE includes @@ -52,7 +52,7 @@ struct KIPI::UploadWidget::Private { KFileTreeView* m_treeView; KFileTreeBranch* m_branch; - QStringList m_pendingPath; + TQStringList m_pendingPath; }; @@ -61,15 +61,15 @@ struct KIPI::UploadWidget::Private This widget is used to specify an upload directory for new images. */ -KIPI::UploadWidget::UploadWidget( KIPI::Interface* interface, QWidget* parent, const char* name ) - : QWidget( parent, name ) +KIPI::UploadWidget::UploadWidget( KIPI::Interface* interface, TQWidget* tqparent, const char* name ) + : TQWidget( tqparent, name ) { d = new Private; - QVBoxLayout* layout = new QVBoxLayout( this, 0 ); + TQVBoxLayout* tqlayout = new TQVBoxLayout( this, 0 ); d->m_treeView = new KFileTreeView( this ); d->m_treeView->setRootIsDecorated( true ); - layout->addWidget( d->m_treeView ); + tqlayout->addWidget( d->m_treeView ); // Fetch the current album, so we can start out there. KIPI::ImageCollection album = interface->currentAlbum(); @@ -78,7 +78,7 @@ KIPI::UploadWidget::UploadWidget( KIPI::Interface* interface, QWidget* parent, c if ( !album.isValid() || !album.isDirectory() ) album = interface->allAlbums().first(); - d->m_branch = d->m_treeView->addBranch( QDir::cleanDirPath(album.uploadRoot().path()), + d->m_branch = d->m_treeView->addBranch( TQDir::cleanDirPath(album.uploadRoot().path()), album.uploadRootName() ); d->m_treeView->setDirOnlyMode( d->m_branch, true ); @@ -87,11 +87,11 @@ KIPI::UploadWidget::UploadWidget( KIPI::Interface* interface, QWidget* parent, c d->m_treeView->header()->setStretchEnabled( true, 0 ); d->m_treeView->header()->hide(); - QString root = album.uploadRoot().path(); - QString uploadPath = album.isDirectory() ? album.uploadPath().path() : root; + TQString root = album.uploadRoot().path(); + TQString uploadPath = album.isDirectory() ? album.uploadPath().path() : root; - root = QDir::cleanDirPath(root); - uploadPath = QDir::cleanDirPath(uploadPath); + root = TQDir::cleanDirPath(root); + uploadPath = TQDir::cleanDirPath(uploadPath); if ( !uploadPath.startsWith( root ) ) { @@ -103,16 +103,16 @@ KIPI::UploadWidget::UploadWidget( KIPI::Interface* interface, QWidget* parent, c { uploadPath = uploadPath.mid( root.length() ); - d->m_pendingPath = QStringList::split( "/", uploadPath, false ); + d->m_pendingPath = TQStringList::split( "/", uploadPath, false ); - connect( d->m_branch, SIGNAL( populateFinished(KFileTreeViewItem *) ), - this, SLOT( slotPopulateFinished(KFileTreeViewItem *) ) ); + connect( d->m_branch, TQT_SIGNAL( populateFinished(KFileTreeViewItem *) ), + this, TQT_SLOT( slotPopulateFinished(KFileTreeViewItem *) ) ); d->m_branch->setOpen(true); } - connect( d->m_treeView, SIGNAL( executed(QListViewItem *) ), - this, SLOT( slotFolderSelected(QListViewItem *) ) ); + connect( d->m_treeView, TQT_SIGNAL( executed(TQListViewItem *) ), + this, TQT_SLOT( slotFolderSelected(TQListViewItem *) ) ); } KIPI::UploadWidget::~UploadWidget() @@ -130,21 +130,21 @@ void KIPI::UploadWidget::load( ) kdWarning() << "KIPI::UploadWidget::load(): This method is obsolete\n"; } -void KIPI::UploadWidget::slotPopulateFinished( KFileTreeViewItem * parentItem ) +void KIPI::UploadWidget::slotPopulateFinished( KFileTreeViewItem * tqparentItem ) { if ( d->m_pendingPath.isEmpty() ) { - disconnect( d->m_branch, SIGNAL( populateFinished(KFileTreeViewItem *) ), - this, SLOT( slotPopulateFinished(KFileTreeViewItem *) ) ); + disconnect( d->m_branch, TQT_SIGNAL( populateFinished(KFileTreeViewItem *) ), + this, TQT_SLOT( slotPopulateFinished(KFileTreeViewItem *) ) ); return; } - QString itemName = d->m_pendingPath.front(); + TQString itemName = d->m_pendingPath.front(); d->m_pendingPath.pop_front(); - QListViewItem * item; - for ( item = parentItem->firstChild(); item; item = item->nextSibling() ) + TQListViewItem * item; + for ( item = tqparentItem->firstChild(); item; item = item->nextSibling() ) { if ( item->text(0) == itemName ) { @@ -178,9 +178,9 @@ void KIPI::UploadWidget::mkdir() } bool ok; - QString dir = KInputDialog::getText( i18n("Create Directory"), + TQString dir = KInputDialog::getText( i18n("Create Directory"), i18n("Enter new directory name (to be created as subdir of %1):") - .arg(path().prettyURL()), "", &ok, this); + .tqarg(path().prettyURL()), "", &ok, this); if (!ok) return; @@ -189,8 +189,8 @@ void KIPI::UploadWidget::mkdir() KIO::SimpleJob* job = KIO::mkdir(url); - connect(job, SIGNAL(result(KIO::Job*)), - this, SLOT(slotAlbumCreated(KIO::Job*))); + connect(job, TQT_SIGNAL(result(KIO::Job*)), + this, TQT_SLOT(slotAlbumCreated(KIO::Job*))); } void KIPI::UploadWidget::slotAlbumCreated(KIO::Job* job) @@ -201,7 +201,7 @@ void KIPI::UploadWidget::slotAlbumCreated(KIO::Job* job) job->showErrorDialog( this ); } -void KIPI::UploadWidget::slotFolderSelected(QListViewItem *) +void KIPI::UploadWidget::slotFolderSelected(TQListViewItem *) { emit folderItemSelected(d->m_treeView->currentURL()); } diff --git a/libkipi/libkipi/uploadwidget.h b/libkipi/libkipi/uploadwidget.h index 3c8dacc..283ab7c 100644 --- a/libkipi/libkipi/uploadwidget.h +++ b/libkipi/libkipi/uploadwidget.h @@ -24,9 +24,9 @@ #ifndef KIPI_UPLOADWIDGET_H #define KIPI_UPLOADWIDGET_H -// Qt includes. +// TQt includes. -#include +#include // KDE includes. @@ -38,16 +38,17 @@ #include "libkipi/interface.h" #include "libkipi/libkipi_export.h" -class QListViewItem; +class TQListViewItem; namespace KIPI { - class LIBKIPI_EXPORT UploadWidget :public QWidget + class LIBKIPI_EXPORT UploadWidget :public TQWidget { Q_OBJECT + TQ_OBJECT public: - UploadWidget( KIPI::Interface* interface, QWidget* parent, const char* name = 0 ); + UploadWidget( KIPI::Interface* interface, TQWidget* tqparent, const char* name = 0 ); ~UploadWidget(); KURL path() const; @@ -60,7 +61,7 @@ namespace KIPI protected slots: void load(); void slotAlbumCreated(KIO::Job* job); - void slotFolderSelected(QListViewItem *); + void slotFolderSelected(TQListViewItem *); private slots: void slotPopulateFinished(KFileTreeViewItem *);