TQt4 port koffice

This should enable compilation under both Qt3 and Qt4; fixes for any missed components will be forthcoming


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/koffice@1238284 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 82 insertions, 82 deletions

diff --git a/kword/mailmerge/sql/KWQtSqlPowerSerialDataSource.cpp b/kword/mailmerge/sql/KWQtSqlPowerSerialDataSource.cpp
index 8f89274a8..dd88750ab 100644
--- a/kword/mailmerge/sql/KWQtSqlPowerSerialDataSource.cpp
+++ b/kword/mailmerge/sql/KWQtSqlPowerSerialDataSource.cpp
@@ -17,43 +17,43 @@
  * Boston, MA 02110-1301, USA.
 */
 
-#include "KWQtSqlPowerSerialDataSource.h"
-#include "KWQtSqlPowerSerialDataSource.moc"
-#include "KWQtSqlMailMergeOpen.h"
-#include <qlayout.h>
-#include <qdom.h>
+#include "KWTQtSqlPowerSerialDataSource.h"
+#include "KWTQtSqlPowerSerialDataSource.moc"
+#include "KWTQtSqlMailMergeOpen.h"
+#include <tqlayout.h>
+#include <tqdom.h>
 #include <kcombobox.h>
 #include <klineedit.h>
 #include <kpushbutton.h>
-#include <qsqldatabase.h>
-#include <qmessagebox.h>
+#include <tqsqldatabase.h>
+#include <tqmessagebox.h>
 #include <kpassdlg.h>
-#include <qsqlrecord.h>
-#include <qsqlcursor.h>
-#include <qdatatable.h>
+#include <tqsqlrecord.h>
+#include <tqsqlcursor.h>
+#include <tqdatatable.h>
 #include <kdebug.h>
 
-#define KWQtSqlBarIcon( x ) BarIcon( x, db->KWInstance() )
+#define KWTQtSqlBarIcon( x ) BarIcon( x, db->KWInstance() )
 
 /******************************************************************
  *
- * Class: KWQtSqlSerialDataSource
+ * Class: KWTQtSqlSerialDataSource
  *
  ******************************************************************/
 
-KWQtSqlPowerSerialDataSource::KWQtSqlPowerSerialDataSource(KInstance *inst,QObject *parent)
-	: KWQtSqlSerialDataSourceBase(inst,parent),myquery(0)
+KWTQtSqlPowerSerialDataSource::KWTQtSqlPowerSerialDataSource(KInstance *inst,TQObject *tqparent)
+	: KWTQtSqlSerialDataSourceBase(inst,tqparent),myquery(0)
 {
 	port=i18n("default");
 }
 
-KWQtSqlPowerSerialDataSource::~KWQtSqlPowerSerialDataSource()
+KWTQtSqlPowerSerialDataSource::~KWTQtSqlPowerSerialDataSource()
 {
 	if (myquery) delete myquery;
-	QSqlDatabase::removeDatabase("KWQTSQLPOWER");
+	TQSqlDatabase::removeDatabase("KWTQTSTQLPOWER");
 }
 
-void KWQtSqlPowerSerialDataSource::refresh(bool force)
+void KWTQtSqlPowerSerialDataSource::refresh(bool force)
 {
 	if ((force) || (myquery==0))
 	{
@@ -62,16 +62,16 @@ void KWQtSqlPowerSerialDataSource::refresh(bool force)
 			delete myquery;
 			myquery=0;
 		}
-		QString tmp=query.upper();
+		TQString tmp=query.upper();
 		if (!tmp.startsWith("SELECT")) return;
 		if ((!database) || (!database->isOpen()))openDatabase();
 		myquery=new KWMySqlCursor(query,true,database);
-		myquery->setMode(QSqlCursor::ReadOnly);
+		myquery->setMode(TQSqlCursor::ReadOnly);
 	}
-	kdDebug()<<QString("There were %1 rows in the query").arg(myquery->size())<<endl;
+	kdDebug()<<TQString("There were %1 rows in the query").tqarg(myquery->size())<<endl;
 }
 
-QString KWQtSqlPowerSerialDataSource::getValue( const QString &name, int record ) const
+TQString KWTQtSqlPowerSerialDataSource::getValue( const TQString &name, int record ) const
 {
 	int num=record;
 
@@ -79,145 +79,145 @@ QString KWQtSqlPowerSerialDataSource::getValue( const QString &name, int record
 	if ( num < 0 || num > (int)myquery->size() )
 		return name;
 	if (!myquery->seek(num,false)) return i18n(">>>Illegal position within datasource<<<");
-	if (!myquery->contains(name)) return i18n(">>>Field %1 is unknown in the current database query<<<").arg(name);
+	if (!myquery->tqcontains(name)) return i18n(">>>Field %1 is unknown in the current database query<<<").tqarg(name);
 	return (myquery->value(name)).toString();
 }
 
-void KWQtSqlPowerSerialDataSource::save( QDomDocument &doc, QDomElement &parent)
+void KWTQtSqlPowerSerialDataSource::save( TQDomDocument &doc, TQDomElement &tqparent)
 {
-        QDomElement def=doc.createElement(QString::fromLatin1("DEFINITION"));
-        parent.appendChild(def);
+        TQDomElement def=doc.createElement(TQString::tqfromLatin1("DEFINITION"));
+        tqparent.appendChild(def);
         {
-                QDomElement defEnt=doc.createElement(QString::fromLatin1("DATABASE"));
-                defEnt.setAttribute(QString::fromLatin1("hostname"),hostname);
-                defEnt.setAttribute(QString::fromLatin1("port"),port);
-                defEnt.setAttribute(QString::fromLatin1("driver"),driver);
-                defEnt.setAttribute(QString::fromLatin1("databasename"),databasename);
-                defEnt.setAttribute(QString::fromLatin1("username"),username);
+                TQDomElement defEnt=doc.createElement(TQString::tqfromLatin1("DATABASE"));
+                defEnt.setAttribute(TQString::tqfromLatin1("hostname"),hostname);
+                defEnt.setAttribute(TQString::tqfromLatin1("port"),port);
+                defEnt.setAttribute(TQString::tqfromLatin1("driver"),driver);
+                defEnt.setAttribute(TQString::tqfromLatin1("databasename"),databasename);
+                defEnt.setAttribute(TQString::tqfromLatin1("username"),username);
                 def.appendChild(defEnt);
 
-		defEnt=doc.createElement(QString::fromLatin1("QUERY"));
-		defEnt.setAttribute(QString::fromLatin1("value"),query);
+		defEnt=doc.createElement(TQString::tqfromLatin1("TQUERY"));
+		defEnt.setAttribute(TQString::tqfromLatin1("value"),query);
 		def.appendChild(defEnt);
 
-		QDomElement sampleEnt=doc.createElement(QString::fromLatin1("SAMPLERECORD"));
-		parent.appendChild(sampleEnt);
+		TQDomElement sampleEnt=doc.createElement(TQString::tqfromLatin1("SAMPLERECORD"));
+		tqparent.appendChild(sampleEnt);
 	        for (DbRecord::Iterator it=sampleRecord.begin();it!=sampleRecord.end();++it)
         	{
-                	QDomElement fieldEnt=doc.createElement(QString::fromLatin1("FIELD"));
-	                fieldEnt.setAttribute(QString::fromLatin1("name"),it.key());
+                	TQDomElement fieldEnt=doc.createElement(TQString::tqfromLatin1("FIELD"));
+	                fieldEnt.setAttribute(TQString::tqfromLatin1("name"),it.key());
 	                sampleEnt.appendChild(fieldEnt);
 	        }
         }
 }
 
-void KWQtSqlPowerSerialDataSource::load( QDomElement& parentElem )
+void KWTQtSqlPowerSerialDataSource::load( TQDomElement& tqparentElem )
 {
         clearSampleRecord();
-        QDomNode defNd=parentElem.namedItem("DEFINITION");
+        TQDomNode defNd=tqparentElem.namedItem("DEFINITION");
         if (!defNd.isNull())
 	{
-	        QDomElement def=defNd.toElement();
-		QDomNode dbNd=def.namedItem("DATABASE");
+	        TQDomElement def=defNd.toElement();
+		TQDomNode dbNd=def.namedItem("DATABASE");
 		if (!dbNd.isNull())
 		{
-			QDomElement dbEnt=dbNd.toElement();
-			if (dbEnt.tagName()==QString::fromLatin1("DATABASE"))
+			TQDomElement dbEnt=dbNd.toElement();
+			if (dbEnt.tagName()==TQString::tqfromLatin1("DATABASE"))
 			{
-				hostname=dbEnt.attribute(QString::fromLatin1("hostname"));
-				port=dbEnt.attribute(QString::fromLatin1("port"));
-				driver=dbEnt.attribute(QString::fromLatin1("driver"));
-				databasename=dbEnt.attribute(QString::fromLatin1("databasename"));
-				username=dbEnt.attribute(QString::fromLatin1("username"));
+				hostname=dbEnt.attribute(TQString::tqfromLatin1("hostname"));
+				port=dbEnt.attribute(TQString::tqfromLatin1("port"));
+				driver=dbEnt.attribute(TQString::tqfromLatin1("driver"));
+				databasename=dbEnt.attribute(TQString::tqfromLatin1("databasename"));
+				username=dbEnt.attribute(TQString::tqfromLatin1("username"));
 			}
 		}
-		QDomNode queryNd=def.namedItem("QUERY");
+		TQDomNode queryNd=def.namedItem("TQUERY");
 		if (!queryNd.isNull())
 		{
-			query=queryNd.toElement().attribute(QString::fromLatin1("value"));
+			query=queryNd.toElement().attribute(TQString::tqfromLatin1("value"));
 		}
         }
 
-        defNd=parentElem.namedItem("SAMPLERECORD");
+        defNd=tqparentElem.namedItem("SAMPLERECORD");
         if (!defNd.isNull())
 	{
-		QDomElement def1=defNd.toElement();
-	        for (QDomElement defEnt=defNd.firstChild().toElement();!defEnt.isNull();defEnt=defEnt.nextSibling().toElement())
+		TQDomElement def1=defNd.toElement();
+	        for (TQDomElement defEnt=defNd.firstChild().toElement();!defEnt.isNull();defEnt=defEnt.nextSibling().toElement())
 	        {
-	               addSampleRecordEntry(defEnt.attribute(QString::fromLatin1("name")));
+	               addSampleRecordEntry(defEnt.attribute(TQString::tqfromLatin1("name")));
 	        }
 	}
 }
 
-bool KWQtSqlPowerSerialDataSource::showConfigDialog(QWidget *par,int action)
+bool KWTQtSqlPowerSerialDataSource::showConfigDialog(TQWidget *par,int action)
 {
    bool ret=false;
    if (action==KWSLEdit)
    {
         if ((!database) || (!database->isOpen()))openDatabase();
-	KWQtSqlPowerMailMergeEditor *dia=new KWQtSqlPowerMailMergeEditor(par,this);
+	KWTQtSqlPowerMailMergeEditor *dia=new KWTQtSqlPowerMailMergeEditor(par,this);
 	ret=dia->exec();
 	delete dia;
    }
-	else ret=KWQtSqlSerialDataSourceBase::showConfigDialog(par,action);
+	else ret=KWTQtSqlSerialDataSourceBase::showConfigDialog(par,action);
    return ret;
 }
 
-void KWQtSqlPowerSerialDataSource::clearSampleRecord() {sampleRecord.clear();}
+void KWTQtSqlPowerSerialDataSource::clearSampleRecord() {sampleRecord.clear();}
 
-void KWQtSqlPowerSerialDataSource::addSampleRecordEntry(QString name)
+void KWTQtSqlPowerSerialDataSource::addSampleRecordEntry(TQString name)
 {sampleRecord[name]=name; }//i18n("No Value");}
 
 
 /******************************************************************
  *
- * Class: KWQtSqlMailMergeEditor
+ * Class: KWTQtSqlMailMergeEditor
  *
  ******************************************************************/
 
-KWQtSqlPowerMailMergeEditor::KWQtSqlPowerMailMergeEditor( QWidget *parent, KWQtSqlPowerSerialDataSource *db_ )
-	:KDialogBase( Plain, i18n( "Mail Merge - Editor" ), Ok | Cancel, Ok, parent, "", true ), db( db_ )
+KWTQtSqlPowerMailMergeEditor::KWTQtSqlPowerMailMergeEditor( TQWidget *tqparent, KWTQtSqlPowerSerialDataSource *db_ )
+	:KDialogBase( Plain, i18n( "Mail Merge - Editor" ), Ok | Cancel, Ok, tqparent, "", true ), db( db_ )
 {
-        (new QVBoxLayout(plainPage()))->setAutoAdd(true);
-        setMainWidget(widget=new KWQtSqlPowerWidget(plainPage()));
-	connect(widget->setup,SIGNAL(clicked()),this,SLOT(openSetup()));
-	connect(widget->tables,SIGNAL(currentChanged(QListBoxItem*)),this,SLOT(slotTableChanged(QListBoxItem*)));
-	connect(widget->execute,SIGNAL(clicked()),this,SLOT(slotExecute()));
-	connect(this,SIGNAL(okClicked()),this,SLOT(slotSetQuery()));
+        (new TQVBoxLayout(plainPage()))->setAutoAdd(true);
+        setMainWidget(widget=new KWTQtSqlPowerWidget(plainPage()));
+	connect(widget->setup,TQT_SIGNAL(clicked()),this,TQT_SLOT(openSetup()));
+	connect(widget->tables,TQT_SIGNAL(currentChanged(TQListBoxItem*)),this,TQT_SLOT(slotTableChanged(TQListBoxItem*)));
+	connect(widget->execute,TQT_SIGNAL(clicked()),this,TQT_SLOT(slotExecute()));
+	connect(this,TQT_SIGNAL(okClicked()),this,TQT_SLOT(slotSetQuery()));
 	widget->query->setText(db->query);
 	updateDBViews();
 }
 
-void KWQtSqlPowerMailMergeEditor::slotSetQuery()
+void KWTQtSqlPowerMailMergeEditor::slotSetQuery()
 {
 	db->query=widget->query->text();
 	db->refresh(true);
 }
 
-void KWQtSqlPowerMailMergeEditor::slotExecute()
+void KWTQtSqlPowerMailMergeEditor::slotExecute()
 {
 	if (!db->database) if (!db->openDatabase()) return;
-	QString tmp=widget->query->text().upper();
+	TQString tmp=widget->query->text().upper();
 	if (!tmp.startsWith("SELECT")) return;
 	KWMySqlCursor *cur=new KWMySqlCursor(widget->query->text(),true,db->database);
-	cur->setMode(QSqlCursor::ReadOnly);
+	cur->setMode(TQSqlCursor::ReadOnly);
 
 	db->clearSampleRecord();
-	kdDebug()<<QString("Fieldname count %1").arg(cur->count())<<endl;
+	kdDebug()<<TQString("Fieldname count %1").tqarg(cur->count())<<endl;
 	for (uint i=0;i<cur->count();i++)
 		db->addSampleRecordEntry(cur->fieldName(i));
 
 	widget->queryresult->setSqlCursor(cur,true,true);
-	widget->queryresult->refresh(QDataTable::RefreshAll);
+	widget->queryresult->refresh(TQDataTable::RefreshAll);
 }
 
-void KWQtSqlPowerMailMergeEditor::slotTableChanged ( QListBoxItem * item )
+void KWTQtSqlPowerMailMergeEditor::slotTableChanged ( TQListBoxItem * item )
 {
 	widget->fields->clear();
 	if (item)
 	{
 		if (!db->database) return;
-		QSqlRecord rec=db->database->record(item->text());
+		TQSqlRecord rec=db->database->record(item->text());
 		for (uint i=0;i<rec.count();i++)
 		{
 			widget->fields->insertItem(rec.fieldName(i));
@@ -225,9 +225,9 @@ void KWQtSqlPowerMailMergeEditor::slotTableChanged ( QListBoxItem * item )
 	}
 }
 
-void KWQtSqlPowerMailMergeEditor::openSetup()
+void KWTQtSqlPowerMailMergeEditor::openSetup()
 {
-        KWQtSqlMailMergeOpen *dia=new KWQtSqlMailMergeOpen(this,db);
+        KWTQtSqlMailMergeOpen *dia=new KWTQtSqlMailMergeOpen(this,db);
         if (dia->exec())
 	{
 		 db->openDatabase();
@@ -237,7 +237,7 @@ void KWQtSqlPowerMailMergeEditor::openSetup()
 }
 
 
-void KWQtSqlPowerMailMergeEditor::updateDBViews()
+void KWTQtSqlPowerMailMergeEditor::updateDBViews()
 {
 	widget->fields->clear();
 	widget->tables->clear();
@@ -245,12 +245,12 @@ void KWQtSqlPowerMailMergeEditor::updateDBViews()
 	widget->tables->insertStringList(db->database->tables());
 }
 
-KWQtSqlPowerMailMergeEditor::~KWQtSqlPowerMailMergeEditor(){;}
+KWTQtSqlPowerMailMergeEditor::~KWTQtSqlPowerMailMergeEditor(){;}
 
 
 extern "C" {
-        KWORD_MAILMERGE_EXPORT KWMailMergeDataSource *create_kwmailmerge_qtsqldb_power(KInstance *inst,QObject *parent)
+        KWORD_MAILMERGE_EXPORT KWMailMergeDataSource *create_kwmailmerge_qtsqldb_power(KInstance *inst,TQObject *tqparent)
         {
-                return new KWQtSqlPowerSerialDataSource(inst,parent);
+                return new KWTQtSqlPowerSerialDataSource(inst,tqparent);
         }
 }