Browse Source

Trinity Qt initial conversion


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdenetwork@1157648 283d02a7-25f6-0310-bc7c-ecb5cbfe19
tags/v3.5.13
tpearson 9 years ago
parent
commit
47c8a359c5
100 changed files with 2471 additions and 2471 deletions
  1. 3
    3
      dcoprss/article.cpp
  2. 23
    23
      dcoprss/cache.cpp
  3. 15
    15
      dcoprss/cache.h
  4. 17
    17
      dcoprss/client.cpp
  5. 33
    33
      dcoprss/document.cpp
  6. 31
    31
      dcoprss/feedbrowser.cpp
  7. 14
    14
      dcoprss/feedbrowser.h
  8. 45
    45
      dcoprss/query.cpp
  9. 19
    19
      dcoprss/query.h
  10. 47
    47
      dcoprss/rssnewsfeed.h
  11. 11
    11
      dcoprss/service.cpp
  12. 41
    41
      dcoprss/service.h
  13. 101
    101
      dcoprss/xmlrpciface.cpp
  14. 66
    66
      dcoprss/xmlrpciface.h
  15. 7
    7
      filesharing/advanced/kcm_sambaconf/common.cpp
  16. 3
    3
      filesharing/advanced/kcm_sambaconf/common.h
  17. 33
    33
      filesharing/advanced/kcm_sambaconf/dictmanager.cpp
  18. 12
    12
      filesharing/advanced/kcm_sambaconf/dictmanager.h
  19. 9
    9
      filesharing/advanced/kcm_sambaconf/filemodedlgimpl.cpp
  20. 4
    4
      filesharing/advanced/kcm_sambaconf/filemodedlgimpl.h
  21. 8
    8
      filesharing/advanced/kcm_sambaconf/groupselectdlg.ui.h
  22. 73
    73
      filesharing/advanced/kcm_sambaconf/hiddenfileview.cpp
  23. 19
    19
      filesharing/advanced/kcm_sambaconf/hiddenfileview.h
  24. 1
    1
      filesharing/advanced/kcm_sambaconf/joindomaindlg.ui.h
  25. 2
    2
      filesharing/advanced/kcm_sambaconf/kcmprinterdlg.ui.h
  26. 117
    117
      filesharing/advanced/kcm_sambaconf/kcmsambaconf.cpp
  27. 16
    16
      filesharing/advanced/kcm_sambaconf/kcmsambaconf.h
  28. 18
    18
      filesharing/advanced/kcm_sambaconf/linuxpermissionchecker.cpp
  29. 7
    7
      filesharing/advanced/kcm_sambaconf/linuxpermissionchecker.h
  30. 12
    12
      filesharing/advanced/kcm_sambaconf/passwd.cpp
  31. 11
    11
      filesharing/advanced/kcm_sambaconf/passwd.h
  32. 21
    21
      filesharing/advanced/kcm_sambaconf/printerdlgimpl.cpp
  33. 1
    1
      filesharing/advanced/kcm_sambaconf/printerdlgimpl.h
  34. 18
    18
      filesharing/advanced/kcm_sambaconf/qmultichecklistitem.cpp
  35. 8
    8
      filesharing/advanced/kcm_sambaconf/qmultichecklistitem.h
  36. 77
    77
      filesharing/advanced/kcm_sambaconf/sambafile.cpp
  37. 30
    30
      filesharing/advanced/kcm_sambaconf/sambafile.h
  38. 41
    41
      filesharing/advanced/kcm_sambaconf/sambashare.cpp
  39. 32
    32
      filesharing/advanced/kcm_sambaconf/sambashare.h
  40. 4
    4
      filesharing/advanced/kcm_sambaconf/share.ui.h
  41. 42
    42
      filesharing/advanced/kcm_sambaconf/sharedlgimpl.cpp
  42. 4
    4
      filesharing/advanced/kcm_sambaconf/sharedlgimpl.h
  43. 13
    13
      filesharing/advanced/kcm_sambaconf/smbconfconfigwidget.cpp
  44. 4
    4
      filesharing/advanced/kcm_sambaconf/smbconfconfigwidget.h
  45. 26
    26
      filesharing/advanced/kcm_sambaconf/smbpasswdfile.cpp
  46. 11
    11
      filesharing/advanced/kcm_sambaconf/smbpasswdfile.h
  47. 7
    7
      filesharing/advanced/kcm_sambaconf/socketoptionsdlg.ui.h
  48. 5
    5
      filesharing/advanced/kcm_sambaconf/userselectdlg.ui.h
  49. 77
    77
      filesharing/advanced/kcm_sambaconf/usertabimpl.cpp
  50. 24
    24
      filesharing/advanced/kcm_sambaconf/usertabimpl.h
  51. 25
    25
      filesharing/advanced/nfs/nfsdialog.cpp
  52. 3
    3
      filesharing/advanced/nfs/nfsdialog.h
  53. 23
    23
      filesharing/advanced/nfs/nfsentry.cpp
  54. 23
    23
      filesharing/advanced/nfs/nfsentry.h
  55. 23
    23
      filesharing/advanced/nfs/nfsfile.cpp
  56. 6
    6
      filesharing/advanced/nfs/nfsfile.h
  57. 19
    19
      filesharing/advanced/nfs/nfshostdlg.cpp
  58. 5
    5
      filesharing/advanced/nfs/nfshostdlg.h
  59. 35
    35
      filesharing/advanced/propsdlgplugin/propertiespage.cpp
  60. 7
    7
      filesharing/advanced/propsdlgplugin/propertiespage.h
  61. 14
    14
      filesharing/advanced/propsdlgplugin/propsdlgshareplugin.cpp
  62. 1
    1
      filesharing/advanced/propsdlgplugin/propsdlgshareplugin.h
  63. 58
    58
      filesharing/simple/fileshare.cpp
  64. 7
    7
      filesharing/simple/fileshare.h
  65. 66
    66
      filesharing/simple/groupconfigdlg.cpp
  66. 8
    8
      filesharing/simple/groupconfigdlg.h
  67. 1
    1
      filesharing/simple/groupconfiggui.ui.h
  68. 21
    21
      filesharing/simple/krichtextlabel.cpp
  69. 9
    9
      filesharing/simple/krichtextlabel.h
  70. 28
    28
      kdict/actions.cpp
  71. 22
    22
      kdict/actions.h
  72. 60
    60
      kdict/applet/kdictapplet.cpp
  73. 13
    13
      kdict/applet/kdictapplet.h
  74. 2
    2
      kdict/application.cpp
  75. 2
    2
      kdict/application.h
  76. 9
    9
      kdict/dcopinterface.h
  77. 50
    50
      kdict/dict.cpp
  78. 28
    28
      kdict/dict.h
  79. 72
    72
      kdict/matchview.cpp
  80. 24
    24
      kdict/matchview.h
  81. 127
    127
      kdict/options.cpp
  82. 62
    62
      kdict/options.h
  83. 71
    71
      kdict/queryview.cpp
  84. 23
    23
      kdict/queryview.h
  85. 39
    39
      kdict/sets.cpp
  86. 5
    5
      kdict/sets.h
  87. 87
    87
      kdict/toplevel.cpp
  88. 18
    18
      kdict/toplevel.h
  89. 31
    31
      kdnssd/ioslave/dnssd.cpp
  90. 15
    15
      kdnssd/ioslave/dnssd.h
  91. 7
    7
      kdnssd/kdedmodule/dnssdwatcher.cpp
  92. 7
    7
      kdnssd/kdedmodule/dnssdwatcher.h
  93. 8
    8
      kdnssd/kdedmodule/watcher.cpp
  94. 5
    5
      kdnssd/kdedmodule/watcher.h
  95. 3
    3
      kfile-plugins/torrent/bbase.h
  96. 11
    11
      kfile-plugins/torrent/bdict.cpp
  97. 11
    11
      kfile-plugins/torrent/bdict.h
  98. 9
    9
      kfile-plugins/torrent/bint.cpp
  99. 5
    5
      kfile-plugins/torrent/bint.h
  100. 0
    0
      kfile-plugins/torrent/blist.cpp

+ 3
- 3
dcoprss/article.cpp View File

@@ -32,18 +32,18 @@ RSSArticle::~RSSArticle()
32 32
 	delete m_Art;
33 33
 }
34 34
 
35
-QString RSSArticle::title()
35
+TQString RSSArticle::title()
36 36
 {
37 37
 	//kdDebug() << "Get title " <<  m_Art->title() << endl;
38 38
 	return m_Art->title();
39 39
 }
40 40
 
41
-QString RSSArticle::description()
41
+TQString RSSArticle::description()
42 42
 {
43 43
 	return m_Art->description();
44 44
 }
45 45
 
46
-QString RSSArticle::link()
46
+TQString RSSArticle::link()
47 47
 {
48 48
 	return m_Art->link().prettyURL();
49 49
 }

+ 23
- 23
dcoprss/cache.cpp View File

@@ -28,14 +28,14 @@
28 28
 #include <kdebug.h>
29 29
 #include <kstandarddirs.h>
30 30
 
31
-#include <qdatastream.h>
32
-#include <qfile.h>
31
+#include <tqdatastream.h>
32
+#include <tqfile.h>
33 33
 
34 34
 bool CacheEntry::isValid() const
35 35
 {
36 36
 	// Cache entries get invalid after on hour. One shouldn't hardcode this
37 37
 	// but for now it'll do.
38
-	return m_timeStamp.secsTo( QDateTime::currentDateTime() ) < 3600;
38
+	return m_timeStamp.secsTo( TQDateTime::currentDateTime() ) < 3600;
39 39
 }
40 40
 
41 41
 Cache *Cache::m_instance = 0;
@@ -47,14 +47,14 @@ Cache &Cache::self()
47 47
 	return *m_instance;
48 48
 }
49 49
 
50
-QString Cache::getCacheKey( const QString &server, const QString &method,
51
-                            const QValueList<QVariant> &args )
50
+TQString Cache::getCacheKey( const TQString &server, const TQString &method,
51
+                            const TQValueList<TQVariant> &args )
52 52
 {
53
-	QString key;
54
-	key = server + QString::fromLatin1( "__" );
55
-	key += method + QString::fromLatin1( "__" );
56
-	QValueList<QVariant>::ConstIterator it = args.begin();
57
-	QValueList<QVariant>::ConstIterator end = args.end();
53
+	TQString key;
54
+	key = server + TQString::fromLatin1( "__" );
55
+	key += method + TQString::fromLatin1( "__" );
56
+	TQValueList<TQVariant>::ConstIterator it = args.begin();
57
+	TQValueList<TQVariant>::ConstIterator end = args.end();
58 58
 	for ( ; it != end; ++it )
59 59
 		key += KXMLRPC::Query::marshal( *it );
60 60
 	
@@ -73,56 +73,56 @@ Cache::~Cache()
73 73
 
74 74
 void Cache::load()
75 75
 {
76
-	QFile file( cacheFileName() );
76
+	TQFile file( cacheFileName() );
77 77
 	if ( !file.open( IO_ReadOnly ) ) {
78 78
 		kdDebug() << "Failed to open cache file " << cacheFileName() << endl;
79 79
 		return;
80 80
 	}
81 81
 	
82
-	QDataStream stream( &file );
82
+	TQDataStream stream( &file );
83 83
 	while ( !stream.atEnd() ) {
84
-		QString key;
84
+		TQString key;
85 85
 		stream >> key;
86 86
 
87 87
 		CacheEntry *entry = new CacheEntry;
88 88
 		stream >> *entry;
89 89
 
90
-		QDict<CacheEntry>::insert( key, entry );
90
+		TQDict<CacheEntry>::insert( key, entry );
91 91
 	}
92 92
 }
93 93
 
94 94
 void Cache::save()
95 95
 {
96
-	QFile file( cacheFileName() );
96
+	TQFile file( cacheFileName() );
97 97
 	if ( !file.open( IO_WriteOnly ) ) {
98 98
 		kdDebug() << "Failed to open cache file " << cacheFileName() << endl;
99 99
 		return;
100 100
 	}
101 101
 
102
-	QDataStream stream( &file );
102
+	TQDataStream stream( &file );
103 103
 
104
-	QDictIterator<CacheEntry> it( *this );
104
+	TQDictIterator<CacheEntry> it( *this );
105 105
 	for ( ; it.current() != 0; ++it )
106 106
 		stream << it.currentKey() << *it.current();
107 107
 }
108 108
 
109
-void Cache::touch( const QString &key )
109
+void Cache::touch( const TQString &key )
110 110
 {
111 111
 	CacheEntry *entry = find( key );
112 112
 	if ( !entry )
113 113
 		return;
114
-	entry->m_timeStamp = QDateTime::currentDateTime();
114
+	entry->m_timeStamp = TQDateTime::currentDateTime();
115 115
 }
116 116
 
117
-void Cache::insert( const QString &key, const KXMLRPC::Query::Result &result )
117
+void Cache::insert( const TQString &key, const KXMLRPC::Query::Result &result )
118 118
 {
119 119
 	CacheEntry *entry = new CacheEntry;
120
-	entry->m_timeStamp = QDateTime::currentDateTime();
120
+	entry->m_timeStamp = TQDateTime::currentDateTime();
121 121
 	entry->m_result = result;
122
-	QDict<CacheEntry>::insert( key, entry );
122
+	TQDict<CacheEntry>::insert( key, entry );
123 123
 }
124 124
 
125
-QString Cache::cacheFileName() const
125
+TQString Cache::cacheFileName() const
126 126
 {
127 127
 	return locateLocal( "appdata", "cache/dcoprss.cache" );
128 128
 }

+ 15
- 15
dcoprss/cache.h View File

@@ -25,41 +25,41 @@
25 25
 #ifndef CACHE_H
26 26
 #define CACHE_H
27 27
 
28
-#include <qcstring.h>
29
-#include <qdatetime.h>
30
-#include <qdict.h>
28
+#include <tqcstring.h>
29
+#include <tqdatetime.h>
30
+#include <tqdict.h>
31 31
 
32 32
 #include <xmlrpciface.h>
33 33
 
34 34
 class CacheEntry
35 35
 {
36 36
 	friend class Cache;
37
-	friend QDataStream &operator>>( QDataStream &s, CacheEntry &e );
37
+	friend TQDataStream &operator>>( TQDataStream &s, CacheEntry &e );
38 38
 	public:
39
-		const QDateTime &timeStamp() const { return m_timeStamp; }
39
+		const TQDateTime &timeStamp() const { return m_timeStamp; }
40 40
 		const KXMLRPC::Query::Result result() const { return m_result; }
41 41
 		bool isValid() const;
42 42
 	
43 43
 	private:
44
-		QDateTime m_timeStamp;
44
+		TQDateTime m_timeStamp;
45 45
 		KXMLRPC::Query::Result m_result;
46 46
 };
47 47
 
48
-class Cache : public QDict<CacheEntry>
48
+class Cache : public TQDict<CacheEntry>
49 49
 {
50 50
 	public:
51 51
 		static Cache &self();
52 52
 
53
-		static QString getCacheKey( const QString &server,
54
-		                            const QString &method,
55
-		                            const QValueList<QVariant> &args );
53
+		static TQString getCacheKey( const TQString &server,
54
+		                            const TQString &method,
55
+		                            const TQValueList<TQVariant> &args );
56 56
 
57 57
 		void load();
58 58
 		void save();
59 59
 
60
-		void touch( const QString &key );
60
+		void touch( const TQString &key );
61 61
 
62
-		void insert( const QString &key, const KXMLRPC::Query::Result &result );
62
+		void insert( const TQString &key, const KXMLRPC::Query::Result &result );
63 63
 
64 64
 	private:
65 65
 		Cache();
@@ -67,17 +67,17 @@ class Cache : public QDict<CacheEntry>
67 67
 		Cache &operator=( const Cache &rhs ); // disabled
68 68
 		~Cache();
69 69
 
70
-		QString cacheFileName() const;
70
+		TQString cacheFileName() const;
71 71
 
72 72
 		static Cache *m_instance;
73 73
 };
74 74
 
75
-inline QDataStream &operator<<( QDataStream &s, const CacheEntry &e )
75
+inline TQDataStream &operator<<( TQDataStream &s, const CacheEntry &e )
76 76
 {
77 77
 	return s << e.timeStamp() << e.result();
78 78
 }
79 79
 
80
-inline QDataStream &operator>>( QDataStream &s, CacheEntry &e )
80
+inline TQDataStream &operator>>( TQDataStream &s, CacheEntry &e )
81 81
 {
82 82
 	return s >> e.m_timeStamp >> e.m_result;
83 83
 }

+ 17
- 17
dcoprss/client.cpp View File

@@ -2,10 +2,10 @@
2 2
 #include <kapplication.h>
3 3
 #include <dcopclient.h>
4 4
 #include <dcopref.h>
5
-#include <qdatastream.h>
6
-#include <qstring.h>
7
-#include <qstringlist.h>
8
-#include <qcstring.h>
5
+#include <tqdatastream.h>
6
+#include <tqstring.h>
7
+#include <tqstringlist.h>
8
+#include <tqcstring.h>
9 9
 #include <kdebug.h>
10 10
 #include <stdlib.h>
11 11
 /*
@@ -19,13 +19,13 @@ public:
19 19
 		// get our DCOP client and attach so that we may use it
20 20
 		DCOPClient *client = app->dcopClient();
21 21
 		client->attach();
22
-		QString error;
23
-		QCString appID;
22
+		TQString error;
23
+		TQCString appID;
24 24
 		kdDebug() << "Looking for rss service..." << endl;
25 25
 		if (!client->isApplicationRegistered("rssservice"))
26 26
 		{
27 27
 			kdDebug() << "Could not find service so I am starting it..." << endl;
28
-			if(KApplication::startServiceByName("rssservice",QStringList(), &error, &appID ))
28
+			if(KApplication::startServiceByName("rssservice",TQStringList(), &error, &appID ))
29 29
 			{
30 30
 				kdDebug() << "Starting rssservice failed with message: " << error << endl;
31 31
 				exit(0);
@@ -39,14 +39,14 @@ public:
39 39
 		else
40 40
 			kdDebug() << "attached dcop signals..." << endl;
41 41
 
42
-		QString url("http://freshmeat.net/backend/fm.rdf");
42
+		TQString url("http://freshmeat.net/backend/fm.rdf");
43 43
 		DCOPRef m_rssservice("rssservice","RSSService");
44
-		m_rssservice.call("load(QString)", url);
45
-		QStringList returnList = m_rssservice.call("list()");
46
-		DCOPRef doc = m_rssservice.call("document(QString)", returnList[0]);
47
-		QString title = doc.call("title()");
48
-		QString link = doc.call("link()");
49
-		QString description = doc.call("description()");
44
+		m_rssservice.call("load(TQString)", url);
45
+		TQStringList returnList = m_rssservice.call("list()");
46
+		DCOPRef doc = m_rssservice.call("document(TQString)", returnList[0]);
47
+		TQString title = doc.call("title()");
48
+		TQString link = doc.call("link()");
49
+		TQString description = doc.call("description()");
50 50
 		kdDebug() << title << endl;
51 51
 		kdDebug() << link << endl;
52 52
 		kdDebug() << description << endl;
@@ -55,9 +55,9 @@ public:
55 55
 	k_dcop:
56 56
 	virtual void refresh(DCOPRef doc)
57 57
 	{
58
-		QString title = doc.call("title()");
59
-		QString link = doc.call("link()");
60
-		QString description = doc.call("description()");
58
+		TQString title = doc.call("title()");
59
+		TQString link = doc.call("link()");
60
+		TQString description = doc.call("description()");
61 61
 		kdDebug() << title << endl;
62 62
 		kdDebug() << link << endl;
63 63
 		kdDebug() << description << endl;

+ 33
- 33
dcoprss/document.cpp View File

@@ -16,20 +16,20 @@
16 16
  *                                                                         *
17 17
  ***************************************************************************/
18 18
 #include <kdebug.h>
19
-#include <qdatetime.h>
19
+#include <tqdatetime.h>
20 20
 #include <kurl.h>
21 21
 #include "service.h"
22 22
 
23
-RSSDocument::RSSDocument(const QString& url) :
24
-	QObject(), DCOPObject(), m_Url(url)
23
+RSSDocument::RSSDocument(const TQString& url) :
24
+	TQObject(), DCOPObject(), m_Url(url)
25 25
 {
26 26
 
27 27
 	m_list.setAutoDelete( true );
28 28
 	m_Doc = 0L;
29
-	m_pix = QPixmap();
29
+	m_pix = TQPixmap();
30 30
 	m_isLoading = false;
31 31
 	m_maxAge = 60;
32
-	m_Timeout = QDateTime::currentDateTime();
32
+	m_Timeout = TQDateTime::currentDateTime();
33 33
 	m_state.clear();
34 34
 }
35 35
 
@@ -79,8 +79,8 @@ void RSSDocument::loadingComplete(Loader *ldr, Document doc, Status stat)
79 79
 		Image *img = m_Doc->image();
80 80
 		if ( img )
81 81
 		{
82
-			connect(img, SIGNAL(gotPixmap(const QPixmap &)),
83
-				SLOT(pixmapLoaded(const QPixmap &)));
82
+			connect(img, TQT_SIGNAL(gotPixmap(const TQPixmap &)),
83
+				TQT_SLOT(pixmapLoaded(const TQPixmap &)));
84 84
 			img->getPixmap();
85 85
 			pixmapUpdating(DCOPRef(this));
86 86
 		}
@@ -94,13 +94,13 @@ void RSSDocument::loadingComplete(Loader *ldr, Document doc, Status stat)
94 94
 	}
95 95
 }
96 96
 
97
-void RSSDocument::pixmapLoaded(const QPixmap &pix )
97
+void RSSDocument::pixmapLoaded(const TQPixmap &pix )
98 98
 {
99 99
 	m_pix = pix;
100 100
 	pixmapUpdated(DCOPRef(this));
101 101
 }
102 102
 
103
-QString RSSDocument::webMaster()
103
+TQString RSSDocument::webMaster()
104 104
 {
105 105
 	if( m_Doc != 0L)
106 106
 		return m_Doc->webMaster();
@@ -108,7 +108,7 @@ QString RSSDocument::webMaster()
108 108
 		return "";
109 109
 }
110 110
 
111
-QString RSSDocument::managingEditor()
111
+TQString RSSDocument::managingEditor()
112 112
 {
113 113
 	if( m_Doc != 0L)
114 114
 			return m_Doc->managingEditor();
@@ -116,7 +116,7 @@ QString RSSDocument::managingEditor()
116 116
 		return "";
117 117
 }
118 118
 
119
-QString RSSDocument::rating()
119
+TQString RSSDocument::rating()
120 120
 {
121 121
 	if( m_Doc != 0L)
122 122
 		return m_Doc->rating();
@@ -124,23 +124,23 @@ QString RSSDocument::rating()
124 124
 		return "";
125 125
 }
126 126
 
127
-QDateTime RSSDocument::lastBuildDate()
127
+TQDateTime RSSDocument::lastBuildDate()
128 128
 {
129 129
 	if( m_Doc != 0L)
130 130
 		return m_Doc->lastBuildDate();
131 131
 	else
132
-		return QDateTime::currentDateTime();
132
+		return TQDateTime::currentDateTime();
133 133
 }
134 134
 
135
-QDateTime RSSDocument::pubDate()
135
+TQDateTime RSSDocument::pubDate()
136 136
 {
137 137
 	if( m_Doc != 0L)
138 138
 		return m_Doc->pubDate();
139 139
 	else
140
-		return QDateTime::currentDateTime();
140
+		return TQDateTime::currentDateTime();
141 141
 }
142 142
 
143
-QString RSSDocument::copyright()
143
+TQString RSSDocument::copyright()
144 144
 {
145 145
 	if( m_Doc != 0L)
146 146
 		return m_Doc->copyright();
@@ -148,20 +148,20 @@ QString RSSDocument::copyright()
148 148
 		return "";
149 149
 }
150 150
 
151
-QStringList RSSDocument::articles()
151
+TQStringList RSSDocument::articles()
152 152
 {
153 153
 	if( m_Doc != 0L)
154 154
 	{
155 155
 		kdDebug() << "Document giving articles..." << endl;
156 156
 		Article::List list = m_Doc->articles();
157
-		QStringList stringList;
157
+		TQStringList stringList;
158 158
 
159 159
 		for(Article::List::ConstIterator it = list.begin(); it != list.end(); ++it)
160 160
 				stringList.append((*it).title());
161 161
 		return stringList;
162 162
 	}
163 163
 	else
164
-		return QStringList();
164
+		return TQStringList();
165 165
 }
166 166
 
167 167
 DCOPRef RSSDocument::article(int idx)
@@ -179,7 +179,7 @@ int RSSDocument::count()
179 179
 	return 0;
180 180
 }
181 181
 
182
-QString RSSDocument::link()
182
+TQString RSSDocument::link()
183 183
 {
184 184
 	if( m_Doc != 0L)
185 185
 		return m_Doc->link().prettyURL();
@@ -187,7 +187,7 @@ QString RSSDocument::link()
187 187
 		return "";
188 188
 }
189 189
 
190
-QString RSSDocument::description()
190
+TQString RSSDocument::description()
191 191
 {
192 192
 	if( m_Doc != 0L)
193 193
 		return m_Doc->description();
@@ -195,7 +195,7 @@ QString RSSDocument::description()
195 195
 		return "";
196 196
 }
197 197
 
198
-QString RSSDocument::title()
198
+TQString RSSDocument::title()
199 199
 {
200 200
 	if( m_Doc != 0L)
201 201
 		return m_Doc->title();
@@ -203,7 +203,7 @@ QString RSSDocument::title()
203 203
 		return "";
204 204
 }
205 205
 
206
-QString RSSDocument::verbVersion()
206
+TQString RSSDocument::verbVersion()
207 207
 {
208 208
 	if( m_Doc != 0L)
209 209
 		return m_Doc->verbVersion();
@@ -211,7 +211,7 @@ QString RSSDocument::verbVersion()
211 211
 		return "";
212 212
 }
213 213
 
214
-QString RSSDocument::pixmapURL()
214
+TQString RSSDocument::pixmapURL()
215 215
 {
216 216
 	if( m_Doc != 0L)
217 217
 		if( m_Doc->image() )
@@ -222,7 +222,7 @@ QString RSSDocument::pixmapURL()
222 222
 		return "";
223 223
 }
224 224
 
225
-QPixmap RSSDocument::pixmap()
225
+TQPixmap RSSDocument::pixmap()
226 226
 {
227 227
 	return m_pix;
228 228
 }
@@ -243,14 +243,14 @@ bool RSSDocument::pixmapValid()
243 243
 void RSSDocument::refresh()
244 244
 {
245 245
 	kdDebug() << "Mod time " << m_Timeout.toString() << endl;
246
-	kdDebug() << "Current time " << QDateTime::currentDateTime().toString() << endl;
246
+	kdDebug() << "Current time " << TQDateTime::currentDateTime().toString() << endl;
247 247
 
248
-	if(!m_isLoading  && (QDateTime::currentDateTime() >= m_Timeout))
248
+	if(!m_isLoading  && (TQDateTime::currentDateTime() >= m_Timeout))
249 249
 	{
250 250
 		kdDebug() << "Document going to refresh" << endl;
251 251
 		m_isLoading = true;
252 252
 		Loader *loader = Loader::create(this,
253
-			SLOT(loadingComplete(Loader *, Document, Status)));
253
+			TQT_SLOT(loadingComplete(Loader *, Document, Status)));
254 254
 		loader->loadFrom(KURL( m_Url ),  new FileRetriever());
255 255
 		documentUpdating(DCOPRef(this));
256 256
 	}
@@ -266,8 +266,8 @@ void RSSDocument::refresh()
266 266
 			Image *img = m_Doc->image();
267 267
 			if ( img )
268 268
 			{
269
-				connect(img, SIGNAL(gotPixmap(const QPixmap &)),
270
-					SLOT(pixmapLoaded(const QPixmap &)));
269
+				connect(img, TQT_SIGNAL(gotPixmap(const TQPixmap &)),
270
+					TQT_SLOT(pixmapLoaded(const TQPixmap &)));
271 271
 				img->getPixmap();
272 272
 				pixmapUpdating(DCOPRef(this));
273 273
 			}
@@ -289,17 +289,17 @@ void RSSDocument::setMaxAge(int _min)
289 289
 	m_Timeout.addSecs(m_maxAge);
290 290
 }
291 291
 
292
-int RSSDocument::state( const QString &title) const
292
+int RSSDocument::state( const TQString &title) const
293 293
 {
294 294
 	return m_state[title];
295 295
 }
296 296
 
297
-void RSSDocument::setState( const QString &title, int s )
297
+void RSSDocument::setState( const TQString &title, int s )
298 298
 {
299 299
 	m_state[title] = s;
300 300
 }
301 301
 
302
-void RSSDocument::read( const QString &title)
302
+void RSSDocument::read( const TQString &title)
303 303
 {
304 304
 	m_state[title] = 3;
305 305
 }

+ 31
- 31
dcoprss/feedbrowser.cpp View File

@@ -9,18 +9,18 @@
9 9
 #include <klocale.h>
10 10
 #include <dcopclient.h>
11 11
 
12
-#include <qcstring.h>
13
-#include <qdatastream.h>
14
-#include <qvbox.h>
12
+#include <tqcstring.h>
13
+#include <tqdatastream.h>
14
+#include <tqvbox.h>
15 15
 
16
-CategoryItem::CategoryItem( KListView *parent, const QString &category )
16
+CategoryItem::CategoryItem( KListView *parent, const TQString &category )
17 17
 	: KListViewItem( parent ),
18 18
 	m_category( category )
19 19
 {
20 20
 	init();
21 21
 }
22 22
 
23
-CategoryItem::CategoryItem( KListViewItem *parent, const QString &category )
23
+CategoryItem::CategoryItem( KListViewItem *parent, const TQString &category )
24 24
 	: KListViewItem( parent ),
25 25
 	m_category( category )
26 26
 {
@@ -47,18 +47,18 @@ void CategoryItem::setOpen( bool open )
47 47
 void CategoryItem::populate()
48 48
 {
49 49
 	m_dcopIface = new DCOPRSSIface( this, "m_dcopIface" );
50
-	connect( m_dcopIface, SIGNAL( gotCategories( const QStringList & ) ),
51
-	         this, SLOT( gotCategories( const QStringList & ) ) );
50
+	connect( m_dcopIface, TQT_SIGNAL( gotCategories( const TQStringList & ) ),
51
+	         this, TQT_SLOT( gotCategories( const TQStringList & ) ) );
52 52
 	m_dcopIface->getCategories( m_category );
53 53
 }
54 54
 
55
-void CategoryItem::gotCategories( const QStringList &categories )
55
+void CategoryItem::gotCategories( const TQStringList &categories )
56 56
 {
57 57
 	delete m_dcopIface;
58 58
 	m_dcopIface = 0;
59 59
 
60
-	QStringList::ConstIterator it = categories.begin();
61
-	QStringList::ConstIterator end = categories.end();
60
+	TQStringList::ConstIterator it = categories.begin();
61
+	TQStringList::ConstIterator end = categories.end();
62 62
 	for ( ; it != end; ++it )
63 63
 		new CategoryItem( this, *it );
64 64
 
@@ -66,45 +66,45 @@ void CategoryItem::gotCategories( const QStringList &categories )
66 66
 		KListViewItem::setOpen( true );
67 67
 }
68 68
 
69
-DCOPRSSIface::DCOPRSSIface( QObject *parent, const char *name ) :
70
-	QObject( parent, name ), DCOPObject( "FeedBrowser" )
69
+DCOPRSSIface::DCOPRSSIface( TQObject *parent, const char *name ) :
70
+	TQObject( parent, name ), DCOPObject( "FeedBrowser" )
71 71
 {
72
-	connectDCOPSignal( "rssservice", "RSSQuery", "gotCategories(QStringList)",
73
-	                   "slotGotCategories(QStringList)", false );
72
+	connectDCOPSignal( "rssservice", "RSSQuery", "gotCategories(TQStringList)",
73
+	                   "slotGotCategories(TQStringList)", false );
74 74
 }
75 75
 
76
-void DCOPRSSIface::getCategories( const QString &cat )
76
+void DCOPRSSIface::getCategories( const TQString &cat )
77 77
 {
78
-	QByteArray data;
79
-	QDataStream stream( data, IO_WriteOnly );
78
+	TQByteArray data;
79
+	TQDataStream stream( data, IO_WriteOnly );
80 80
 	stream << cat;
81 81
 	kapp->dcopClient()->send( "rssservice", "RSSQuery",
82
-	                          "getCategories(QString)", data );
82
+	                          "getCategories(TQString)", data );
83 83
 }
84 84
 
85
-void DCOPRSSIface::slotGotCategories( const QStringList &categories )
85
+void DCOPRSSIface::slotGotCategories( const TQStringList &categories )
86 86
 {
87 87
 	emit gotCategories( categories );
88 88
 }
89 89
 
90
-FeedBrowserDlg::FeedBrowserDlg( QWidget *parent, const char *name )
90
+FeedBrowserDlg::FeedBrowserDlg( TQWidget *parent, const char *name )
91 91
 	: KDialogBase( parent, name, true, i18n( "DCOPRSS Feed Browser" ),
92 92
 	               Close, Close, true )
93 93
 {
94 94
 	m_dcopIface = new DCOPRSSIface( this, "m_dcopIface" );
95
-	connect( m_dcopIface, SIGNAL( gotCategories( const QStringList & ) ),
96
-	         this, SLOT( gotTopCategories( const QStringList & ) ) );
95
+	connect( m_dcopIface, TQT_SIGNAL( gotCategories( const TQStringList & ) ),
96
+	         this, TQT_SLOT( gotTopCategories( const TQStringList & ) ) );
97 97
 
98
-	QVBox *mainWidget = makeVBoxMainWidget();
98
+	TQVBox *mainWidget = makeVBoxMainWidget();
99 99
 
100 100
 	m_feedList = new KListView( mainWidget, "m_feedList" );
101 101
 	m_feedList->setAllColumnsShowFocus( true );
102 102
 	m_feedList->setRootIsDecorated( true );
103 103
 	m_feedList->addColumn( i18n( "Name" ) );
104
-	connect( m_feedList, SIGNAL( executed( QListViewItem * ) ),
105
-	         this, SLOT( itemSelected( QListViewItem * ) ) );
106
-	connect( m_feedList, SIGNAL( returnPressed( QListViewItem * ) ),
107
-	         this, SLOT( itemSelected( QListViewItem * ) ) );
104
+	connect( m_feedList, TQT_SIGNAL( executed( TQListViewItem * ) ),
105
+	         this, TQT_SLOT( itemSelected( TQListViewItem * ) ) );
106
+	connect( m_feedList, TQT_SIGNAL( returnPressed( TQListViewItem * ) ),
107
+	         this, TQT_SLOT( itemSelected( TQListViewItem * ) ) );
108 108
 
109 109
 	resize( 500, 400 );
110 110
 
@@ -116,15 +116,15 @@ void FeedBrowserDlg::getTopCategories()
116 116
 	m_dcopIface->getCategories( "Top" );
117 117
 }
118 118
 
119
-void FeedBrowserDlg::gotTopCategories( const QStringList &categories )
119
+void FeedBrowserDlg::gotTopCategories( const TQStringList &categories )
120 120
 {
121
-	QStringList::ConstIterator it = categories.begin();
122
-	QStringList::ConstIterator end = categories.end();
121
+	TQStringList::ConstIterator it = categories.begin();
122
+	TQStringList::ConstIterator end = categories.end();
123 123
 	for ( ; it != end; ++it )
124 124
 		new CategoryItem( m_feedList, *it );
125 125
 }
126 126
 
127
-void FeedBrowserDlg::itemSelected( QListViewItem *item )
127
+void FeedBrowserDlg::itemSelected( TQListViewItem *item )
128 128
 {
129 129
 	item->setOpen( !item->isOpen() );
130 130
 }

+ 14
- 14
dcoprss/feedbrowser.h View File

@@ -1,45 +1,45 @@
1 1
 #ifndef FEEDBROWSER_H
2 2
 #define FEEDBROWSER_H
3 3
 
4
-#include <qobject.h>
4
+#include <tqobject.h>
5 5
 #include <dcopobject.h>
6 6
 #include <kdialogbase.h>
7 7
 #include <klistview.h>
8 8
 
9
-class DCOPRSSIface : public QObject, public DCOPObject
9
+class DCOPRSSIface : public TQObject, public DCOPObject
10 10
 {
11 11
 	K_DCOP
12 12
 	Q_OBJECT
13 13
 	public:
14
-		DCOPRSSIface( QObject *parent, const char *name = 0 );
14
+		DCOPRSSIface( TQObject *parent, const char *name = 0 );
15 15
 
16 16
 	k_dcop:
17
-		void slotGotCategories( const QStringList &categories );
17
+		void slotGotCategories( const TQStringList &categories );
18 18
 
19 19
 	public slots:
20
-		void getCategories( const QString &cat = "Top" );
20
+		void getCategories( const TQString &cat = "Top" );
21 21
 
22 22
 	signals:
23
-		void gotCategories( const QStringList &categories );
23
+		void gotCategories( const TQStringList &categories );
24 24
 };
25 25
 
26
-class CategoryItem : public QObject, public KListViewItem
26
+class CategoryItem : public TQObject, public KListViewItem
27 27
 {
28 28
 	Q_OBJECT
29 29
 	public:
30
-		CategoryItem( KListView *parent, const QString &category );
31
-		CategoryItem( KListViewItem *parent, const QString &category );
30
+		CategoryItem( KListView *parent, const TQString &category );
31
+		CategoryItem( KListViewItem *parent, const TQString &category );
32 32
 
33 33
 		virtual void setOpen( bool open );
34 34
 
35 35
 	private slots:
36
-		void gotCategories( const QStringList &categories );
36
+		void gotCategories( const TQStringList &categories );
37 37
 
38 38
 	private:
39 39
 		void populate();
40 40
 		void init();
41 41
 
42
-		QString m_category;
42
+		TQString m_category;
43 43
 		bool m_populated;
44 44
 		DCOPRSSIface *m_dcopIface;
45 45
 };
@@ -49,11 +49,11 @@ class FeedBrowserDlg : public KDialogBase
49 49
 	Q_OBJECT
50 50
 	friend class CategoryItem;
51 51
 	public:
52
-		FeedBrowserDlg( QWidget *parent, const char *name = 0 );
52
+		FeedBrowserDlg( TQWidget *parent, const char *name = 0 );
53 53
 
54 54
 	private slots:
55
-		void itemSelected( QListViewItem *item );
56
-		void gotTopCategories( const QStringList &categories );
55
+		void itemSelected( TQListViewItem *item );
56
+		void gotTopCategories( const TQStringList &categories );
57 57
 
58 58
 	private:
59 59
 		void getTopCategories();

+ 45
- 45
dcoprss/query.cpp View File

@@ -27,35 +27,35 @@
27 27
 
28 28
 using KXMLRPC::Server;
29 29
 
30
-void SlotCaller::call( QObject *object, const char *slot,
30
+void SlotCaller::call( TQObject *object, const char *slot,
31 31
                        const KXMLRPC::Query::Result &result )
32 32
 {
33 33
 	SlotCaller caller;
34
-	connect( &caller, SIGNAL( signal( const KXMLRPC::Query::Result &) ),
34
+	connect( &caller, TQT_SIGNAL( signal( const KXMLRPC::Query::Result &) ),
35 35
 	         object, slot );
36 36
 	emit caller.signal( result );
37 37
 }
38 38
 
39
-QueryService::QueryService( RSSService *service ) : QObject(), DCOPObject( "RSSQuery" ),
39
+QueryService::QueryService( RSSService *service ) : TQObject(), DCOPObject( "RSSQuery" ),
40 40
 	m_service( service )
41 41
 {
42 42
 	m_xmlrpcServer = new KXMLRPC::Server( KURL( "http://www.syndic8.com/xmlrpc.php"), this );
43 43
 }
44 44
 
45
-QStringList QueryService::listActive()
45
+TQStringList QueryService::listActive()
46 46
 {
47 47
 	if ( !m_service )
48
-		return QStringList();
48
+		return TQStringList();
49 49
 	return m_service->list();
50 50
 }
51 51
 
52
-void QueryService::cachedCall( const QString &method,
53
-                               const QValueList<QVariant> &args,
52
+void QueryService::cachedCall( const TQString &method,
53
+                               const TQValueList<TQVariant> &args,
54 54
                                const char *slot )
55 55
 {
56 56
 	kdDebug() << "Calling " << method << endl;
57 57
 
58
-	const QString cacheKey = Cache::getCacheKey( m_xmlrpcServer->url().url(),
58
+	const TQString cacheKey = Cache::getCacheKey( m_xmlrpcServer->url().url(),
59 59
 	                                             method, args );
60 60
 
61 61
 	CacheEntry *cacheEntry = Cache::self().find( cacheKey );
@@ -70,7 +70,7 @@ void QueryService::cachedCall( const QString &method,
70 70
 
71 71
 void QueryService::updateCache( const KXMLRPC::Query::Result &result )
72 72
 {
73
-	const QString cacheKey = Cache::getCacheKey( result.server(),
73
+	const TQString cacheKey = Cache::getCacheKey( result.server(),
74 74
 	                                             result.method(),
75 75
 	                                             result.args() );
76 76
 
@@ -81,57 +81,57 @@ void QueryService::updateCache( const KXMLRPC::Query::Result &result )
81 81
 	}
82 82
 }
83 83
 
84
-void QueryService::findFeeds( const QString &query )
84
+void QueryService::findFeeds( const TQString &query )
85 85
 {
86 86
 	kdDebug() << "QueryService::findFeeds()" << endl;
87 87
 
88
-	QStringList args;
88
+	TQStringList args;
89 89
 	args << query << "headlines_rank";
90 90
 
91 91
 	cachedCall( "syndic8.FindFeeds", Server::toVariantList( args ),
92
-	            SLOT( slotFoundFeeds( const KXMLRPC::Query::Result & ) ) );
92
+	            TQT_SLOT( slotFoundFeeds( const KXMLRPC::Query::Result & ) ) );
93 93
 }
94 94
 
95
-void QueryService::findSites( const QString& query )
95
+void QueryService::findSites( const TQString& query )
96 96
 {
97 97
 	kdDebug() << "QueryService::findSites()" << endl;
98 98
 
99 99
 	cachedCall( "syndic8.FindSites", Server::toVariantList( query ),
100
-	            SLOT( slotFoundFeeds( const KXMLRPC::Query::Result & ) ) );
100
+	            TQT_SLOT( slotFoundFeeds( const KXMLRPC::Query::Result & ) ) );
101 101
 }
102 102
 
103
-void QueryService::getFeedInfo( const QVariant& ids )
103
+void QueryService::getFeedInfo( const TQVariant& ids )
104 104
 {
105 105
 	kdDebug() << "QueryService::getFeedInfo()" << endl;
106 106
 
107 107
 	cachedCall( "syndic8.GetFeedInfo", Server::toVariantList( ids ),
108
-	            SLOT( slotGotFeedInfo( const KXMLRPC::Query::Result & ) ) );
108
+	            TQT_SLOT( slotGotFeedInfo( const KXMLRPC::Query::Result & ) ) );
109 109
 }
110 110
 
111
-void QueryService::getCategories( const QString &category )
111
+void QueryService::getCategories( const TQString &category )
112 112
 {
113 113
 	kdDebug() << "QueryService::getCategories()" << endl;
114 114
 
115 115
 	if ( category == "Top" ) {
116
-		cachedCall( "syndic8.GetCategoryRoots", Server::toVariantList( QString::fromLatin1( "DMOZ" ) ),
117
-		            SLOT( slotGotCategories( const KXMLRPC::Query::Result & ) ) );
116
+		cachedCall( "syndic8.GetCategoryRoots", Server::toVariantList( TQString::fromLatin1( "DMOZ" ) ),
117
+		            TQT_SLOT( slotGotCategories( const KXMLRPC::Query::Result & ) ) );
118 118
 	} else {
119
-		QStringList args;
119
+		TQStringList args;
120 120
 		args << "DMOZ" << category;
121 121
 		cachedCall( "syndic8.GetCategoryChildren", Server::toVariantList( args ),
122
-		            SLOT( slotGotCategories( const KXMLRPC::Query::Result & ) ) );
122
+		            TQT_SLOT( slotGotCategories( const KXMLRPC::Query::Result & ) ) );
123 123
 	}
124 124
 }
125 125
 
126
-void QueryService::getFeedsInCategory( const QString &category )
126
+void QueryService::getFeedsInCategory( const TQString &category )
127 127
 {
128 128
 	kdDebug() << "QueryService::getFeedsInCategory()" << endl;
129 129
 
130
-	QStringList args;
130
+	TQStringList args;
131 131
 	args << "DMOZ" << category;
132 132
 
133 133
 	cachedCall( "syndic8.GetFeedsInCategory", Server::toVariantList( args ),
134
-	            SLOT( slotGotFeedsInCategory( const KXMLRPC::Query::Result & ) ) );
134
+	            TQT_SLOT( slotGotFeedsInCategory( const KXMLRPC::Query::Result & ) ) );
135 135
 }
136 136
 
137 137
 void QueryService::slotFoundFeeds( const KXMLRPC::Query::Result &result )
@@ -144,11 +144,11 @@ void QueryService::slotFoundFeeds( const KXMLRPC::Query::Result &result )
144 144
 
145 145
 	updateCache( result );
146 146
 
147
-	QValueList<int> ids;
147
+	TQValueList<int> ids;
148 148
 
149
-	const QValueList<QVariant> values = result.data()[ 0 ].toList();
150
-	QValueList<QVariant>::ConstIterator it = values.begin();
151
-	QValueList<QVariant>::ConstIterator end = values.end();
149
+	const TQValueList<TQVariant> values = result.data()[ 0 ].toList();
150
+	TQValueList<TQVariant>::ConstIterator it = values.begin();
151
+	TQValueList<TQVariant>::ConstIterator end = values.end();
152 152
 	for ( ; it != end; ++it ) {
153 153
 		ids << ( *it ).toInt();
154 154
 		kdDebug() << "Found feed #" << ( *it ).toInt() << endl;
@@ -166,17 +166,17 @@ void QueryService::slotGotFeedInfo( const KXMLRPC::Query::Result &result )
166 166
 
167 167
 	updateCache( result );
168 168
 
169
-	QMap<QString, QString> links;
170
-	QValueList<RSSNewsFeed> feeds;
169
+	TQMap<TQString, TQString> links;
170
+	TQValueList<RSSNewsFeed> feeds;
171 171
 
172
-	const QValueList<QVariant> feedInfos = result.data();
173
-	QValueList<QVariant>::ConstIterator it = feedInfos.begin();
174
-	QValueList<QVariant>::ConstIterator end = feedInfos.end();
172
+	const TQValueList<TQVariant> feedInfos = result.data();
173
+	TQValueList<TQVariant>::ConstIterator it = feedInfos.begin();
174
+	TQValueList<TQVariant>::ConstIterator end = feedInfos.end();
175 175
 	for ( ; it != end; ++it ) {
176
-		const QMap<QString, QVariant> feedInfo = ( *it ).toMap();
176
+		const TQMap<TQString, TQVariant> feedInfo = ( *it ).toMap();
177 177
 
178
-		const QString name = feedInfo[ "sitename" ].toString();
179
-		const QString link = feedInfo[ "dataurl" ].toString();
178
+		const TQString name = feedInfo[ "sitename" ].toString();
179
+		const TQString link = feedInfo[ "dataurl" ].toString();
180 180
 		links[ name ] = link;
181 181
 
182 182
 		RSSNewsFeed feed;
@@ -189,7 +189,7 @@ void QueryService::slotGotFeedInfo( const KXMLRPC::Query::Result &result )
189 189
 		feed.m_editor = feedInfo[ "editor" ].toString();
190 190
 		feed.m_publisher = feedInfo[ "publisher" ].toString();
191 191
 		feed.m_creator = feedInfo[ "creator" ].toString();
192
-		QDateTime dateTime;
192
+		TQDateTime dateTime;
193 193
 		dateTime.setTime_t( KRFCDate::parseDate( feedInfo[ "date_created" ].toString() ) );
194 194
 		feed.m_dateCreated = dateTime;
195 195
 		dateTime.setTime_t( KRFCDate::parseDate( feedInfo[ "date_approved" ].toString() ) );
@@ -231,11 +231,11 @@ void QueryService::slotGotCategories( const KXMLRPC::Query::Result &result )
231 231
 
232 232
 	updateCache( result );
233 233
 
234
-	QStringList categories;
234
+	TQStringList categories;
235 235
 
236
-	const QValueList<QVariant> cats = result.data()[ 0 ].toList();
237
-	QValueList<QVariant>::ConstIterator it = cats.begin();
238
-	QValueList<QVariant>::ConstIterator end = cats.end();
236
+	const TQValueList<TQVariant> cats = result.data()[ 0 ].toList();
237
+	TQValueList<TQVariant>::ConstIterator it = cats.begin();
238
+	TQValueList<TQVariant>::ConstIterator end = cats.end();
239 239
 	for (  ; it != end; ++it )
240 240
 		categories << (  *it ).toString();
241 241
 
@@ -254,11 +254,11 @@ void QueryService::slotGotFeedsInCategory( const KXMLRPC::Query::Result &result
254 254
 
255 255
 	updateCache( result );
256 256
 
257
-	QValueList<int> ids;
257
+	TQValueList<int> ids;
258 258
 
259
-	const QValueList<QVariant> values = result.data()[ 0 ].toList();
260
-	QValueList<QVariant>::ConstIterator it = values.begin();
261
-	QValueList<QVariant>::ConstIterator end = values.end();
259
+	const TQValueList<TQVariant> values = result.data()[ 0 ].toList();
260
+	TQValueList<TQVariant>::ConstIterator it = values.begin();
261
+	TQValueList<TQVariant>::ConstIterator end = values.end();
262 262
 	for (  ; it != end; ++it ) {
263 263
 		ids << (  *it ).toInt();
264 264
 		kdDebug() << "Got feed in category: #" << ( *it ).toInt() << endl;

+ 19
- 19
dcoprss/query.h View File

@@ -24,10 +24,10 @@
24 24
 
25 25
 #include <dcopobject.h>
26 26
 
27
-#include <qmap.h>
28
-#include <qobject.h>
29
-#include <qvaluelist.h>
30
-#include <qvariant.h>
27
+#include <tqmap.h>
28
+#include <tqobject.h>
29
+#include <tqvaluelist.h>
30
+#include <tqvariant.h>
31 31
 
32 32
 class RSSService;
33 33
 
@@ -39,7 +39,7 @@ class SlotCaller : public QObject
39 39
 {
40 40
 	Q_OBJECT
41 41
 	public:
42
-		static void call( QObject *object, const char *slot,
42
+		static void call( TQObject *object, const char *slot,
43 43
 		                  const KXMLRPC::Query::Result &value );
44 44
 
45 45
 	signals:
@@ -49,7 +49,7 @@ class SlotCaller : public QObject
49 49
 		SlotCaller() { }
50 50
 };
51 51
 
52
-class QueryService : public QObject, public DCOPObject
52
+class QueryService : public TQObject, public DCOPObject
53 53
 {
54 54
 	K_DCOP
55 55
 	Q_OBJECT
@@ -57,23 +57,23 @@ class QueryService : public QObject, public DCOPObject
57 57
 		QueryService( RSSService *service );
58 58
 
59 59
 	k_dcop_signals:
60
-		void feedIds( QValueList<int> ids );
61
-		void feedInfo(QMap<QString, QString> links);
62
-		void feedInfo(QValueList<RSSNewsFeed> feeds);
63
-		void gotCategories( const QStringList &categories );
64
-		void gotFeedsInCategory( const QValueList<int> &ids );
60
+		void feedIds( TQValueList<int> ids );
61
+		void feedInfo(TQMap<TQString, TQString> links);
62
+		void feedInfo(TQValueList<RSSNewsFeed> feeds);
63
+		void gotCategories( const TQStringList &categories );
64
+		void gotFeedsInCategory( const TQValueList<int> &ids );
65 65
 
66 66
 	k_dcop:
67 67
 		/**
68 68
 		 * Lists the active feeds in use...
69 69
 		 **/
70
-		QStringList listActive(); // just for testing...
70
+		TQStringList listActive(); // just for testing...
71 71
 
72 72
 		/**
73 73
 		 * Query the www.syndic8.com XML-RPC interface for the
74 74
 		 * string. The RSS ids are treturned in a integer list.
75 75
 		 **/
76
-		void findFeeds( const QString& query );
76
+		void findFeeds( const TQString& query );
77 77
 
78 78
 		/**
79 79
 		 * Query the www.syndic8.com XML-RPC interface for the
@@ -81,26 +81,26 @@ class QueryService : public QObject, public DCOPObject
81 81
 		 * each feed in the feed list. The RSS ids are treturned 
82 82
 		 * in a integer list.
83 83
 		 **/
84
-		void findSites( const QString& query );
84
+		void findSites( const TQString& query );
85 85
 
86 86
 		/**
87 87
 		 * Query the www.syndic8.com XML-RPC interface for the
88
-		 * requested RSS feed(s).  Returned is a QMap with the format
88
+		 * requested RSS feed(s).  Returned is a TQMap with the format
89 89
 		 * of Name (Site URL), RSS URL
90 90
 		 **/
91
-		void getFeedInfo( const QVariant& ids );
91
+		void getFeedInfo( const TQVariant& ids );
92 92
 
93 93
 		/**
94 94
 		 * Returns the list of subcategories in the specified category.
95 95
 		 * If no "Top" is specified, the root categories are returned.
96 96
 		 */
97
-		void getCategories( const QString &category );
97
+		void getCategories( const TQString &category );
98 98
 
99 99
 		/**
100 100
 		 * Queries the database for the list of needsfeed ID's which are
101 101
 		 * associated with the given category.
102 102
 		 */
103
-		void getFeedsInCategory( const QString &category );
103
+		void getFeedsInCategory( const TQString &category );
104 104
 
105 105
 
106 106
 	private slots:
@@ -110,7 +110,7 @@ class QueryService : public QObject, public DCOPObject
110 110
 		void slotGotFeedsInCategory( const KXMLRPC::Query::Result &result );
111 111
 
112 112
 	private:
113
-		void cachedCall( const QString &method, const QValueList<QVariant> &args,
113
+		void cachedCall( const TQString &method, const TQValueList<TQVariant> &args,
114 114
 		                 const char *slot );
115 115
 		void updateCache( const KXMLRPC::Query::Result &result );
116 116
 

+ 47
- 47
dcoprss/rssnewsfeed.h View File

@@ -11,76 +11,76 @@
11 11
 #ifndef RSSNEWSFEED_H
12 12
 #define RSSNEWSFEED_H
13 13
 
14
-#include <qdatetime.h>
15
-#include <qstringlist.h>
16
-#include <qvariant.h>
14
+#include <tqdatetime.h>
15
+#include <tqstringlist.h>
16
+#include <tqvariant.h>
17 17
 #include <kdatastream.h>
18 18
 
19 19
 class QueryService;
20 20
 
21 21
 class RSSNewsFeed
22 22
 {
23
-	friend QDataStream &operator>>( QDataStream &stream, RSSNewsFeed &feed );
24
-	friend QDataStream &operator<<( QDataStream &stream, const RSSNewsFeed &feed );
23
+	friend TQDataStream &operator>>( TQDataStream &stream, RSSNewsFeed &feed );
24
+	friend TQDataStream &operator<<( TQDataStream &stream, const RSSNewsFeed &feed );
25 25
 	friend class QueryService;
26 26
 	public:
27 27
 		unsigned int id() const { return m_id; }
28
-		QString name() const { return m_name; }
29
-		QString description() const { return m_description; }
30
-		QString origin() const { return m_origin; }
31
-		QString languageCode() const { return m_languageCode; }
32
-		QString status() const { return m_status; }
33
-		QString version() const { return m_version; }
34
-		QString homePage() const { return m_homePage; }
35
-		QString sourceFile() const { return m_sourceFile; }
36
-		QString imageUrl() const { return m_imageUrl; }
37
-		QString webmaster() const { return m_webmaster; }
38
-		QString editor() const { return m_editor; }
39
-		QString publisher() const { return m_publisher; }
40
-		QString creator() const { return m_creator; }
41
-		const QDateTime &dateCreated() const { return m_dateCreated; }
42
-		const QDateTime &dateApproved() const { return m_dateApproved; }
43
-		const QDateTime dateXmlChanged() const { return m_dateXmlChanged; }
28
+		TQString name() const { return m_name; }
29
+		TQString description() const { return m_description; }
30
+		TQString origin() const { return m_origin; }
31
+		TQString languageCode() const { return m_languageCode; }
32
+		TQString status() const { return m_status; }
33
+		TQString version() const { return m_version; }
34
+		TQString homePage() const { return m_homePage; }
35
+		TQString sourceFile() const { return m_sourceFile; }
36
+		TQString imageUrl() const { return m_imageUrl; }
37
+		TQString webmaster() const { return m_webmaster; }
38
+		TQString editor() const { return m_editor; }
39
+		TQString publisher() const { return m_publisher; }
40
+		TQString creator() const { return m_creator; }
41
+		const TQDateTime &dateCreated() const { return m_dateCreated; }
42
+		const TQDateTime &dateApproved() const { return m_dateApproved; }
43
+		const TQDateTime dateXmlChanged() const { return m_dateXmlChanged; }
44 44
 		bool fetchable() const { return m_fetchable; }
45 45
 		unsigned int views() const { return m_views; }
46 46
 		unsigned int headlinesPerDay() const { return m_headlinesPerDay; }
47 47
 		unsigned int headlinesRank() const { return m_headlinesRank; }
48
-		QString toolkit() const { return m_toolkit; }
49
-		QString toolkitVersion() const { return m_toolkitVersion; }
48
+		TQString toolkit() const { return m_toolkit; }
49
+		TQString toolkitVersion() const { return m_toolkitVersion; }
50 50
 		unsigned int pollingInterval() const { return m_pollingInterval; }
51
-		const QDateTime &lastPoll() const { return m_lastPoll; }
52
-		QStringList categories() const { return m_categories; }
51
+		const TQDateTime &lastPoll() const { return m_lastPoll; }
52
+		TQStringList categories() const { return m_categories; }
53 53
 	
54 54
 	private:
55 55
 		unsigned int m_id;
56
-		QString m_name;
57
-		QString m_description;
58
-		QString m_origin;
59
-		QString m_languageCode;
60
-		QString m_status;
61
-		QString m_version;
62
-		QString m_homePage;
63
-		QString m_sourceFile;
64
-		QString m_imageUrl;
65
-		QString m_webmaster;
66
-		QString m_editor;
67
-		QString m_publisher;
68
-		QString m_creator;
69
-		QDateTime m_dateCreated;
70
-		QDateTime m_dateApproved;
71
-		QDateTime m_dateXmlChanged;
56
+		TQString m_name;
57
+		TQString m_description;
58
+		TQString m_origin;
59
+		TQString m_languageCode;
60
+		TQString m_status;
61
+		TQString m_version;
62
+		TQString m_homePage;
63
+		TQString m_sourceFile;
64
+		TQString m_imageUrl;
65
+		TQString m_webmaster;
66
+		TQString m_editor;
67
+		TQString m_publisher;
68
+		TQString m_creator;
69
+		TQDateTime m_dateCreated;
70
+		TQDateTime m_dateApproved;
71
+		TQDateTime m_dateXmlChanged;
72 72
 		bool m_fetchable;
73 73
 		unsigned int m_views;
74 74
 		unsigned int m_headlinesPerDay;
75 75
 		unsigned int m_headlinesRank;
76
-		QString m_toolkit;
77
-		QString m_toolkitVersion;
76
+		TQString m_toolkit;
77
+		TQString m_toolkitVersion;
78 78
 		unsigned int m_pollingInterval;
79
-		QDateTime m_lastPoll;
80
-		QStringList m_categories;
79
+		TQDateTime m_lastPoll;
80
+		TQStringList m_categories;
81 81
 };
82 82
 
83
-inline QDataStream &operator<<( QDataStream &stream, const RSSNewsFeed &feed )
83
+inline TQDataStream &operator<<( TQDataStream &stream, const RSSNewsFeed &feed )
84 84
 {
85 85
 	return stream << feed.m_id << feed.m_name << feed.m_description
86 86
 	              << feed.m_origin << feed.m_languageCode << feed.m_status
@@ -94,7 +94,7 @@ inline QDataStream &operator<<( QDataStream &stream, const RSSNewsFeed &feed )
94 94
 	              << feed.m_categories;
95 95
 }
96 96
 
97
-inline QDataStream &operator>>( QDataStream &stream, RSSNewsFeed &feed )
97
+inline TQDataStream &operator>>( TQDataStream &stream, RSSNewsFeed &feed )
98 98
 {
99 99
 	int i;
100 100
 	stream >> feed.m_id >> feed.m_name >> feed.m_description

+ 11
- 11
dcoprss/service.cpp View File

@@ -34,16 +34,16 @@ RSSService::~RSSService()
34 34
 }
35 35
 
36 36
 
37
-QStringList RSSService::list()
37
+TQStringList RSSService::list()
38 38
 {
39
-	QStringList lst;
40
-	QDictIterator<RSSDocument> itr(m_list);
39
+	TQStringList lst;
40
+	TQDictIterator<RSSDocument> itr(m_list);
41 41
 	for(; itr.current(); ++itr)
42 42
 		lst.append(itr.currentKey());
43 43
 	return lst;
44 44
 }
45 45
 
46
-DCOPRef RSSService::add(QString id)
46
+DCOPRef RSSService::add(TQString id)
47 47
 {
48 48
 	if(m_list.find(id) == 0L) { // add a new one only if we need to
49 49
 		m_list.insert(id, new RSSDocument(id));
@@ -53,14 +53,14 @@ DCOPRef RSSService::add(QString id)
53 53
 	return document(id);
54 54
 }
55 55
 
56
-void RSSService::remove(QString id)
56
+void RSSService::remove(TQString id)
57 57
 {
58 58
 	m_list.remove(id);
59 59
 	removed(id);
60 60
 	saveLinks();
61 61
 }
62 62
 
63
-DCOPRef RSSService::document(QString id)
63
+DCOPRef RSSService::document(TQString id)
64 64
 {
65 65
 	if( m_list[id] )
66 66
 		return DCOPRef(m_list[id]);
@@ -81,9 +81,9 @@ void RSSService::loadLinks()
81 81
 {
82 82
 	KConfig *conf = kapp->config();
83 83
 	conf->setGroup("RSS Links");	
84
-	const QStringList links = conf->readListEntry ("links"); 
85
-	QStringList::ConstIterator it = links.begin();
86
-	QStringList::ConstIterator end = links.end();
84
+	const TQStringList links = conf->readListEntry ("links"); 
85
+	TQStringList::ConstIterator it = links.begin();
86
+	TQStringList::ConstIterator end = links.end();
87 87
 	for ( ; it != end; ++it )
88 88
 		add( *it );
89 89
 }
@@ -92,8 +92,8 @@ void RSSService::saveLinks()
92 92
 {
93 93
 	KConfig *conf = kapp->config();
94 94
 	conf->setGroup("RSS Links");	
95
-        QStringList lst;
96
-        QDictIterator<RSSDocument> itr(m_list);
95
+        TQStringList lst;
96
+        TQDictIterator<RSSDocument> itr(m_list);
97 97
         for(; itr.current(); ++itr)
98 98
                 lst.append(itr.currentKey());
99 99
 

+ 41
- 41
dcoprss/service.h View File

@@ -21,12 +21,12 @@
21 21
 
22 22
 #include <dcopobject.h>
23 23
 #include <dcopref.h>
24
-#include <qdict.h>
25
-#include <qptrlist.h>
26
-#include <qstringlist.h>
27
-#include <qstring.h>
28
-#include <qdatetime.h>
29
-#include <qpixmap.h>
24
+#include <tqdict.h>
25
+#include <tqptrlist.h>
26
+#include <tqstringlist.h>
27
+#include <tqstring.h>
28
+#include <tqdatetime.h>
29
+#include <tqpixmap.h>
30 30
 #include <librss/global.h>
31 31
 #include <librss/loader.h>
32 32
 #include <librss/document.h>
@@ -47,7 +47,7 @@ class RSSService : public DCOPObject
47 47
 
48 48
 	private:
49 49
 
50
-		QDict<RSSDocument> m_list;
50
+		TQDict<RSSDocument> m_list;
51 51
 
52 52
 	public:
53 53
 		RSSService();
@@ -59,14 +59,14 @@ class RSSService : public DCOPObject
59 59
 	k_dcop_signals:
60 60
 		/**
61 61
 		* Emmitted when a new document has been added.  You can then
62
-		* use document(QString) to get the dcop ref for the object.
62
+		* use document(TQString) to get the dcop ref for the object.
63 63
 		* Note: this document may or may not be valid at this
64 64
 		* point so you should connect your dcop signals and then
65 65
 		* do a documentValid() on the dcop ref to make sure of its
66 66
 		* state.
67 67
 		**/
68 68
 
69
-		void added(QString);
69
+		void added(TQString);
70 70
 		/**
71 71
 		* Emmitted when the document has been removed.
72 72
 		* note at this point the DCOPRef for this object is
@@ -75,7 +75,7 @@ class RSSService : public DCOPObject
75 75
 		* process of loading the document call will be safely ignored
76 76
 		* and you will be notified of the updates.
77 77
 		**/
78
-		void removed(QString);
78
+		void removed(TQString);
79 79
 	k_dcop:
80 80
 		/**
81 81
 		* Add a new rdf file resource.  This will return a dcop reference to the resource.  If its a new
@@ -83,50 +83,50 @@ class RSSService : public DCOPObject
83 83
 		* once this reference has been returned you may connect dcop signals and then call
84 84
 		* refresh on the RSSDocument.  The document will not be updated until refresh is called.
85 85
 		**/
86
-		DCOPRef add(QString url);
86
+		DCOPRef add(TQString url);
87 87
 		/**
88 88
 		* Return a list of current rss documents
89 89
 		**/
90
-		QStringList list();
90
+		TQStringList list();
91 91
 		/**
92 92
 		* Remove an rss document resource.  NOTE: Be aware that others may be using this
93 93
 		* resource and if you remove it they may break.  Likewise be aware that someone may
94 94
 		* decide to remove your resource on you so you should always check to see if the resource
95 95
 		* is valid before you access it.
96 96
 		**/
97
-		void remove(QString url);
97
+		void remove(TQString url);
98 98
 		/**
99 99
 		* Return the reference to a requested resource.  If this resource is not present a null dcopref is
100 100
 		* returned.
101 101
 		**/
102
-		DCOPRef document(QString url);
102
+		DCOPRef document(TQString url);
103 103
 		/**
104 104
 		* Exit the RSSService.  This will clean everything up and exit.
105 105
 		**/
106 106
 		void exit();
107 107
 };
108 108
 
109
-class RSSDocument :  public QObject, public DCOPObject
109
+class RSSDocument :  public TQObject, public DCOPObject
110 110
 {
111 111
 	Q_OBJECT
112 112
 	K_DCOP
113 113
 
114 114
 	private:
115 115
 		bool m_isLoading;
116
-		QString m_Url;
116
+		TQString m_Url;
117 117
 		Document *m_Doc;
118
-		QPixmap m_pix;
119
-		QPtrList<RSSArticle> m_list;
120
-		QMap<QString,int> m_state;
121
-		QDateTime m_Timeout;
118
+		TQPixmap m_pix;
119
+		TQPtrList<RSSArticle> m_list;
120
+		TQMap<TQString,int> m_state;
121
+		TQDateTime m_Timeout;
122 122
 		int m_maxAge;
123 123
 
124 124
 	private slots:
125
-		void pixmapLoaded(const QPixmap&);
125
+		void pixmapLoaded(const TQPixmap&);
126 126
 		void loadingComplete(Loader *, Document, Status);
127 127
 
128 128
 	public:
129
-		RSSDocument(const QString& url);
129
+		RSSDocument(const TQString& url);
130 130
 		~RSSDocument();
131 131
 
132 132
 	k_dcop_signals:
@@ -161,31 +161,31 @@ class RSSDocument :  public QObject, public DCOPObject
161 161
 		/**
162 162
 		* Return the webmaster information from the RSS::Document
163 163
 		**/
164
-		QString webMaster();
164
+		TQString webMaster();
165 165
 		/**
166 166
 		* Return the manageing editor from the RSS::Document
167 167
 		**/
168
-		QString managingEditor();
168
+		TQString managingEditor();
169 169
 		/**
170 170
 		* Returns the rating of the RSS::Document
171 171
 		**/
172
-		QString rating();
172
+		TQString rating();
173 173
 		/**
174 174
 		* Returns the last build date from the RSS::Document
175 175
 		**/
176
-		QDateTime lastBuildDate();
176
+		TQDateTime lastBuildDate();
177 177
 		/**
178 178
 		* Returns the publication date from the RSS::Document
179 179
 		**/
180
-		QDateTime pubDate();
180
+		TQDateTime pubDate();
181 181
 		/**
182 182
 		* Returns the copyright information from the RSS::Document
183 183
 		**/
184
-		QString copyright();
184
+		TQString copyright();
185 185
 		/**
186 186
 		* Returns a list of article titles
187 187
 		**/
188
-		QStringList articles();
188
+		TQStringList articles();
189 189
 		/**
190 190
 		* Returns the number of articles
191 191
 		**/
@@ -197,27 +197,27 @@ class RSSDocument :  public QObject, public DCOPObject
197 197
 		/**
198 198
 		* Returns the link from the  RSS::Document
199 199
 		**/
200
-		QString link();
200
+		TQString link();
201 201
 		/**
202 202
 		* Returns the description from the RSS::Document
203 203
 		**/
204
-		QString description();
204
+		TQString description();
205 205
 		/**
206 206
 		* Returns the title from the RSS::Document
207 207
 		**/
208
-		QString title();
208
+		TQString title();
209 209
 		/**
210 210
 		*  Returns the text version from the RSS::Document
211 211
 		**/
212
-		QString verbVersion();
212
+		TQString verbVersion();
213 213
 		/**
214 214
 		*  Returns the url for the pixmap from the RSS::Document
215 215
 		**/
216
-		QString pixmapURL();
216
+		TQString pixmapURL();
217 217
 		/**
218 218
 		* Returns the actual pixmap from the RSS::Document's RSS::Image
219 219
 		**/
220
-		QPixmap pixmap();
220
+		TQPixmap pixmap();
221 221
 		/**
222 222
 		* Returns if the RSSDocument contains a valid RSS::Document yet.
223 223
 		**/
@@ -249,17 +249,17 @@ class RSSDocument :  public QObject, public DCOPObject
249 249
 		 * 2 - unread
250 250
 		 * 3 - read
251 251
 		 */
252
-		int state( const QString &title) const;
252
+		int state( const TQString &title) const;
253 253
 		
254 254
 		/**
255 255
 		 * Set the article state
256 256
 		 */
257
-		void setState( const QString &title, int s );
257
+		void setState( const TQString &title, int s );
258 258
 		
259 259
 		/**
260 260
 		 * Convience method that will set a title to read.
261 261
 		 */
262
-		void read( const QString &title);
262
+		void read( const TQString &title);
263 263
 };
264 264
 
265 265
 class RSSArticle : public DCOPObject
@@ -277,14 +277,14 @@ class RSSArticle : public DCOPObject
277 277
 		/**
278 278
 		* Return the articles title
279 279
 		**/
280
-		QString title();
280
+		TQString title();
281 281
 		/**
282 282
 		* Return the articles description
283 283
 		**/
284
-		QString description();
284
+		TQString description();
285 285
 		/**
286 286
 		* Return the link to the article
287 287
 		**/
288
-		QString link();
288
+		TQString link();
289 289
 };
290 290
 #endif

+ 101
- 101
dcoprss/xmlrpciface.cpp View File

@@ -29,46 +29,46 @@
29 29
 #include <klocale.h>
30 30
 #include <kmdcodec.h>
31 31
 
32
-#include <qdom.h>
32
+#include <tqdom.h>
33 33
 
34 34
 using namespace KXMLRPC;
35 35
 
36
-Query *Query::create( QObject *parent, const char *name )
36
+Query *Query::create( TQObject *parent, const char *name )
37 37
 {
38 38
 	return new Query( parent, name );
39 39
 }
40 40
 
41
-void Query::call( const QString &server, const QString &method,
42
-                  const QValueList<QVariant> &args, const QString &userAgent )
41
+void Query::call( const TQString &server, const TQString &method,
42
+                  const TQValueList<TQVariant> &args, const TQString &userAgent )
43 43
 {
44 44
 	m_buffer.open( IO_ReadWrite );
45 45
 	m_server = server;
46 46
 	m_method = method;
47 47
 	m_args = args;
48 48
 
49
-	const QString xmlMarkup = markupCall( method, args );
49
+	const TQString xmlMarkup = markupCall( method, args );
50 50
 
51
-	QByteArray postData;
52
-	QDataStream stream( postData, IO_WriteOnly );
51
+	TQByteArray postData;
52
+	TQDataStream stream( postData, IO_WriteOnly );
53 53
 	stream.writeRawBytes( xmlMarkup.utf8(), xmlMarkup.length() );
54 54
 
55 55
 	KIO::TransferJob *job = KIO::http_post( KURL( server ), postData, false );
56 56
 	job->addMetaData( "UserAgent", userAgent );
57 57
 	job->addMetaData( "content-type", "Content-Type: text/xml; charset=utf-8" );
58
-	connect( job, SIGNAL( infoMessage( KIO::Job *, const QString & ) ),
59
-	         this, SLOT( slotInfoMessage( KIO::Job *, const QString & ) ) );
60
-	connect( job, SIGNAL( data( KIO::Job *, const QByteArray & ) ),
61
-	         this, SLOT( slotData( KIO::Job *, const QByteArray & ) ) );
62
-	connect( job, SIGNAL( result( KIO::Job * ) ),
63
-	         this, SLOT( slotResult( KIO::Job * ) ) );
58
+	connect( job, TQT_SIGNAL( infoMessage( KIO::Job *, const TQString & ) ),
59
+	         this, TQT_SLOT( slotInfoMessage( KIO::Job *, const TQString & ) ) );
60
+	connect( job, TQT_SIGNAL( data( KIO::Job *, const TQByteArray & ) ),
61
+	         this, TQT_SLOT( slotData( KIO::Job *, const TQByteArray & ) ) );
62
+	connect( job, TQT_SIGNAL( result( KIO::Job * ) ),
63
+	         this, TQT_SLOT( slotResult( KIO::Job * ) ) );
64 64
 }
65 65
 
66
-void Query::slotInfoMessage( KIO::Job *, const QString &msg )
66
+void Query::slotInfoMessage( KIO::Job *, const TQString &msg )
67 67
 {
68 68
 	emit infoMessage( msg );
69 69
 }
70 70
 
71
-void Query::slotData( KIO::Job *, const QByteArray &data )
71
+void Query::slotData( KIO::Job *, const TQByteArray &data )
72 72
 {
73 73
 	m_buffer.writeBlock( data );
74 74
 }
@@ -90,7 +90,7 @@ void Query::slotResult( KIO::Job *job )
90 90
 		return;
91 91
 	}
92 92
 
93
-	QDomDocument doc;
93
+	TQDomDocument doc;
94 94
 	if ( !doc.setContent( m_buffer.buffer() ) ) {
95 95
 			response.m_errorCode = -1;
96 96
 			response.m_errorString = i18n( "Received invalid XML markup" );
@@ -119,17 +119,17 @@ void Query::slotResult( KIO::Job *job )
119 119
 	delete this;
120 120
 }
121 121
 
122
-bool Query::isMessageResponse( const QDomDocument &doc ) const
122
+bool Query::isMessageResponse( const TQDomDocument &doc ) const
123 123
 {
124 124
 	return doc.documentElement().firstChild().toElement().tagName().lower() == "params";
125 125
 }
126 126
 
127
-Query::Result Query::parseMessageResponse( const QDomDocument &doc ) const
127
+Query::Result Query::parseMessageResponse( const TQDomDocument &doc ) const
128 128
 {
129 129
 	Result response;
130 130
 	response.m_success = true;
131 131
 
132
-	QDomNode paramNode = doc.documentElement().firstChild().firstChild();
132
+	TQDomNode paramNode = doc.documentElement().firstChild().firstChild();
133 133
 	while ( !paramNode.isNull() ) {
134 134
 		response.m_data << demarshal( paramNode.firstChild().toElement() );
135 135
 		paramNode = paramNode.nextSibling();
@@ -138,35 +138,35 @@ Query::Result Query::parseMessageResponse( const QDomDocument &doc ) const
138 138
 	return response;
139 139
 }
140 140
 
141
-bool Query::isFaultResponse( const QDomDocument &doc ) const
141
+bool Query::isFaultResponse( const TQDomDocument &doc ) const
142 142
 {
143 143
 	return doc.documentElement().firstChild().toElement().tagName().lower() == "fault";
144 144
 }
145 145
 
146
-Query::Result Query::parseFaultResponse( const QDomDocument &doc ) const
146
+Query::Result Query::parseFaultResponse( const TQDomDocument &doc ) const
147 147
 {
148 148
 	Result response;
149 149
 	response.m_success = false;
150 150
 
151
-	QDomNode errorNode = doc.documentElement().firstChild().firstChild();
152
-	const QVariant errorVariant = demarshal( errorNode.toElement() );
151
+	TQDomNode errorNode = doc.documentElement().firstChild().firstChild();
152
+	const TQVariant errorVariant = demarshal( errorNode.toElement() );
153 153
 	response.m_errorCode = errorVariant.toMap()[ "faultCode" ].toInt();
154 154
 	response.m_errorString = errorVariant.toMap()[ "faultString" ].toString();
155 155
 
156 156
 	return response;
157 157
 }
158 158
 
159
-QString Query::markupCall( const QString &cmd,
160
-                           const QValueList<QVariant> &args ) const
159
+TQString Query::markupCall( const TQString &cmd,
160
+                           const TQValueList<TQVariant> &args ) const
161 161
 {
162
-	QString markup = "<?xml version='1.0' ?><methodCall>";
162
+	TQString markup = "<?xml version='1.0' ?><methodCall>";
163 163
 
164 164
 	markup += "<methodName>" + cmd + "</methodName>";
165 165
 
166 166
 	if ( !args.isEmpty() ) {
167 167
 		markup += "<params>";
168
-		QValueList<QVariant>::ConstIterator it = args.begin();
169
-		QValueList<QVariant>::ConstIterator end = args.end();
168
+		TQValueList<TQVariant>::ConstIterator it = args.begin();
169
+		TQValueList<TQVariant>::ConstIterator end = args.end();
170 170
 		for ( ; it != end; ++it )
171 171
 			markup += "<param>" + marshal( *it ) + "</param>";
172 172
 		markup += "</params>";
@@ -177,46 +177,46 @@ QString Query::markupCall( const QString &cmd,
177 177
 	return markup;
178 178
 }
179 179
 
180
-QString Query::marshal( const QVariant &arg )
180
+TQString Query::marshal( const TQVariant &arg )
181 181
 {
182
-	QString s = "<value>";
182
+	TQString s = "<value>";
183 183
 	switch ( arg.type() ) {
184
-		case QVariant::String:
185
-		case QVariant::CString:
184
+		case TQVariant::String:
185
+		case TQVariant::CString:
186 186
 			s += "<string>" + arg.toString() + "</string>";
187 187
 			break;
188
-		case QVariant::Int:
189
-			s += "<int>" + QString::number( arg.toInt() ) + "</int>";
188
+		case TQVariant::Int:
189
+			s += "<int>" + TQString::number( arg.toInt() ) + "</int>";
190 190
 			break;
191
-		case QVariant::Double:
192
-			s += "<double>" + QString::number( arg.toDouble() ) + "</double>";
191
+		case TQVariant::Double:
192
+			s += "<double>" + TQString::number( arg.toDouble() ) + "</double>";
193 193
 			break;
194
-		case QVariant::Bool:
194
+		case TQVariant::Bool:
195 195
 			s += "<boolean>";
196 196
 			s += arg.toBool() ? "true" : "false";
197 197
 			s += "</boolean>";
198 198
 			break;
199
-		case QVariant::ByteArray:
199
+		case TQVariant::ByteArray:
200 200
 			s += "<base64>" + KCodecs::base64Encode( arg.toByteArray() ) + "</base64>";
201 201
 			break;
202
-		case QVariant::DateTime:
202
+		case TQVariant::DateTime:
203 203
 			s += "<datetime.iso8601>" + arg.toDateTime().toString( Qt::ISODate ) + "</datetime.iso8601>";
204 204
 			break;
205
-		case QVariant::List: {
205
+		case TQVariant::List: {
206 206
 			s += "<array><data>";
207
-			const QValueList<QVariant> args = arg.toList();
208
-			QValueList<QVariant>::ConstIterator it = args.begin();
209
-			QValueList<QVariant>::ConstIterator end = args.end();
207
+			const TQValueList<TQVariant> args = arg.toList();
208
+			TQValueList<TQVariant>::ConstIterator it = args.begin();
209
+			TQValueList<TQVariant>::ConstIterator end = args.end();
210 210
 			for ( ; it != end; ++it )
211 211
 				s += marshal( *it );
212 212
 			s += "</data></array>";
213 213
 			break;
214 214
 		}
215
-		case QVariant::Map: {
215
+		case TQVariant::Map: {
216 216
 			s += "<struct>";
217
-			QMap<QString, QVariant> map = arg.toMap();
218
-			QMap<QString, QVariant>::ConstIterator it = map.begin();
219
-			QMap<QString, QVariant>::ConstIterator end = map.end();
217
+			TQMap<TQString, TQVariant> map = arg.toMap();
218
+			TQMap<TQString, TQVariant>::ConstIterator it = map.begin();
219
+			TQMap<TQString, TQVariant>::ConstIterator end = map.end();
220 220
 			for ( ; it != end; ++it ) {
221 221
 				s += "<member>";
222 222
 				s += "<name>" + it.key() + "</name>";
@@ -233,127 +233,127 @@ QString Query::marshal( const QVariant &arg )
233 233
 	return s + "</value>";
234 234
 }
235 235
 
236
-QVariant Query::demarshal( const QDomElement &elem )
236
+TQVariant Query::demarshal( const TQDomElement &elem )
237 237
 {
238 238
 	Q_ASSERT( elem.tagName().lower() == "value" );
239 239
 
240 240
 	if ( !elem.firstChild().isElement() )
241
-		return QVariant( elem.text() );
241
+		return TQVariant( elem.text() );
242 242
 
243
-	const QDomElement typeElement = elem.firstChild().toElement();
244
-	const QString typeName = typeElement.tagName().lower();
243
+	const TQDomElement typeElement = elem.firstChild().toElement();
244
+	const TQString typeName = typeElement.tagName().lower();
245 245
 
246 246
 	if ( typeName == "string" )
247
-		return QVariant( typeElement.text() );
247
+		return TQVariant( typeElement.text() );
248 248
 	else if ( typeName == "i4" || typeName == "int" )
249
-		return QVariant( typeElement.text().toInt() );
249
+		return TQVariant( typeElement.text().toInt() );
250 250
 	else if ( typeName == "double" )
251
-		return QVariant( typeElement.text().toDouble() );
251
+		return TQVariant( typeElement.text().toDouble() );
252 252
 	else if ( typeName == "boolean" ) {
253 253
 		if ( typeElement.text().lower() == "true" || typeElement.text() == "1" )
254
-			return QVariant( true );
254
+			return TQVariant( true );
255 255
 		else
256
-			return QVariant( false );
256
+			return TQVariant( false );
257 257
 	} else if ( typeName == "base64" )
258
-		return QVariant( KCodecs::base64Decode( typeElement.text().latin1() ) );
258
+		return TQVariant( KCodecs::base64Decode( typeElement.text().latin1() ) );
259 259
 	else if ( typeName == "datetime" || typeName == "datetime.iso8601" )
260
-		return QVariant( QDateTime::fromString( typeElement.text(), Qt::ISODate ) );
260
+		return TQVariant( TQDateTime::fromString( typeElement.text(), Qt::ISODate ) );
261 261
 	else if ( typeName == "array" ) {
262
-		QValueList<QVariant> values;
263
-		QDomNode valueNode = typeElement.firstChild().firstChild();
262
+		TQValueList<TQVariant> values;
263
+		TQDomNode valueNode = typeElement.firstChild().firstChild();
264 264
 		while ( !valueNode.isNull() ) {
265 265
 			values << demarshal( valueNode.toElement() );
266 266
 			valueNode = valueNode.nextSibling();
267 267
 		}
268
-		return QVariant( values );
268
+		return TQVariant( values );
269 269
 	} else if ( typeName == "struct" ) {
270
-		QMap<QString, QVariant> map;
271
-		QDomNode memberNode = typeElement.firstChild();
270
+		TQMap<TQString, TQVariant> map;
271
+		TQDomNode memberNode = typeElement.firstChild();
272 272
 		while ( !memberNode.isNull() ) {
273
-			const QString key = memberNode.toElement().elementsByTagName( "name" ).item( 0 ).toElement().text();
274
-			const QVariant data = demarshal( memberNode.toElement().elementsByTagName( "value" ).item( 0 ).toElement() );
273
+			const TQString key = memberNode.toElement().elementsByTagName( "name" ).item( 0 ).toElement().text();
274
+			const TQVariant data = demarshal( memberNode.toElement().elementsByTagName( "value" ).item( 0 ).toElement() );
275 275
 			map[ key ] = data;
276 276
 			memberNode = memberNode.nextSibling();
277 277
 		}
278
-		return QVariant( map );
278
+		return TQVariant( map );
279 279
 	} else
280 280
 		kdWarning() << "Cannot demarshal unknown type " << typeName << endl;
281 281
 
282
-	return QVariant();
282
+	return TQVariant();
283 283
 }
284 284
 
285
-Query::Query( QObject *parent, const char *name ) : QObject( parent, name )
285
+Query::Query( TQObject *parent, const char *name ) : TQObject( parent, name )
286 286
 {
287 287
 }
288 288
 
289
-QValueList<QVariant> Server::toVariantList( const QVariant &arg )
289
+TQValueList<TQVariant> Server::toVariantList( const TQVariant &arg )
290 290
 {
291
-	QValueList<QVariant> args;
291
+	TQValueList<TQVariant> args;
292 292
 	args << arg ;
293 293
 	return args;
294 294
 }
295 295
 
296
-QValueList<QVariant> Server::toVariantList( int arg )
296
+TQValueList<TQVariant> Server::toVariantList( int arg )
297 297
 {
298
-	QValueList<QVariant> args;
298
+	TQValueList<TQVariant> args;
299 299
 	args << arg ;
300 300
 	return args;
301 301
 }
302 302
 
303
-QValueList<QVariant> Server::toVariantList( bool arg )
303
+TQValueList<TQVariant> Server::toVariantList( bool arg )
304 304
 {
305
-	QValueList<QVariant> args;
305
+	TQValueList<TQVariant> args;
306 306
 	args << arg ;
307 307
 	return args;
308 308
 }
309 309
 
310
-QValueList<QVariant> Server::toVariantList( double arg )
310
+TQValueList<TQVariant> Server::toVariantList( double arg )
311 311
 {
312
-	QValueList<QVariant> args;
312
+	TQValueList<TQVariant> args;
313 313
 	args << arg ;
314 314
 	return args;
315 315
 }
316 316
 
317
-QValueList<QVariant> Server::toVariantList( const QString &arg )
317
+TQValueList<TQVariant> Server::toVariantList( const TQString &arg )
318 318
 {
319
-	QValueList<QVariant> args;
319
+	TQValueList<TQVariant> args;
320 320
 	args << arg ;
321 321
 	return args;
322 322
 }
323 323
 
324
-QValueList<QVariant> Server::toVariantList( const QCString &arg )
324
+TQValueList<TQVariant> Server::toVariantList( const TQCString &arg )
325 325
 {
326
-	QValueList<QVariant> args;
326
+	TQValueList<TQVariant> args;
327 327
 	args << arg ;
328 328
 	return args;
329 329
 }
330 330
 
331
-QValueList<QVariant> Server::toVariantList( const QByteArray &arg )
331
+TQValueList<TQVariant> Server::toVariantList( const TQByteArray &arg )
332 332
 {
333
-	QValueList<QVariant> args;
333
+	TQValueList<TQVariant> args;
334 334
 	args << arg ;
335 335
 	return args;
336 336
 }
337 337
 
338
-QValueList<QVariant> Server::toVariantList( const QDateTime &arg )
338
+TQValueList<TQVariant> Server::toVariantList( const TQDateTime &arg )
339 339
 {
340
-	QValueList<QVariant> args;
340
+	TQValueList<TQVariant> args;
341 341
 	args << arg ;
342 342
 	return args;
343 343
 }
344 344
 
345
-QValueList<QVariant> Server::toVariantList( const QStringList &arg )
345
+TQValueList<TQVariant> Server::toVariantList( const TQStringList &arg )
346 346
 {
347
-	QValueList<QVariant> args;
348
-	QStringList::ConstIterator it = arg.begin();
349
-	QStringList::ConstIterator end = arg.end();
347
+	TQValueList<TQVariant> args;
348
+	TQStringList::ConstIterator it = arg.begin();
349
+	TQStringList::ConstIterator end = arg.end();
350 350
 	for ( ; it != end; ++it )
351
-		args << QVariant( *it );
351
+		args << TQVariant( *it );
352 352
 	return args;
353 353
 }
354 354
 
355
-Server::Server( const KURL &url, QObject *parent, const char *name )
356
-	: QObject( parent, name )
355
+Server::Server( const KURL &url, TQObject *parent, const char *name )
356
+	: TQObject( parent, name )
357 357
 {
358 358
 	if ( url.isValid() )
359 359
 		m_url = url;
@@ -364,8 +364,8 @@ void Server::setUrl( const KURL &url )
364 364
 	m_url = url.isValid() ? url : KURL();
365 365
 }
366 366
 
367
-void Server::call( const QString &method, const QValueList<QVariant> &args,
368
-                   QObject *receiver, const char *slot )
367
+void Server::call( const TQString &method, const TQValueList<TQVariant> &args,
368
+                   TQObject *receiver, const char *slot )
369 369
 {
370 370
 	if ( m_url.isEmpty() ) {
371 371
 		kdWarning() << "Cannot execute call to " << method << ": empty server URL" << endl;
@@ -373,16 +373,16 @@ void Server::call( const QString &method, const QValueList<QVariant> &args,
373 373
 	}
374 374
 
375 375
 	Query *query = Query::create( this );
376
-	connect( query, SIGNAL( infoMessage( const QString & ) ),
377
-	         this, SIGNAL( infoMessage( const QString & ) ) );
378
-	connect( query, SIGNAL( finished( const KXMLRPC::Query::Result & ) ),
376
+	connect( query, TQT_SIGNAL( infoMessage( const TQString & ) ),
377
+	         this, TQT_SIGNAL( infoMessage( const TQString & ) ) );
378
+	connect( query, TQT_SIGNAL( finished( const KXMLRPC::Query::Result & ) ),
379 379
 	         receiver, slot );
380 380
 	query->call( m_url.url(), method, args, m_userAgent );
381 381
 }
382 382
 
383
-void Server::call( const QString &method, const QValueList<QVariant> &args,
384
-                   QObject *receiver, const char *slot,
385
-                   QObject *infoObject, const char *infoSlot )
383
+void Server::call( const TQString &method, const TQValueList<TQVariant> &args,
384
+                   TQObject *receiver, const char *slot,
385
+                   TQObject *infoObject, const char *infoSlot )
386 386
 {
387 387
 	if ( m_url.isEmpty() ) {
388 388
 		kdWarning() << "Cannot execute call to " << method << ": empty server URL" << endl;
@@ -390,9 +390,9 @@ void Server::call( const QString &method, const QValueList<QVariant> &args,
390 390
 	}
391 391
 
392 392
 	Query *query = Query::create( this );
393
-	connect( query, SIGNAL( infoMessage( const QString &msg ) ),
393
+	connect( query, TQT_SIGNAL( infoMessage( const TQString &msg ) ),
394 394
 	         infoObject, infoSlot );
395
-	connect( query, SIGNAL( finished( const KXMLRPC::Query::Result & ) ),
395
+	connect( query, TQT_SIGNAL( finished( const KXMLRPC::Query::Result & ) ),
396 396
 	         receiver, slot );
397 397
 	query->call( m_url.url(), method, args, m_userAgent );
398 398
 }

+ 66
- 66
dcoprss/xmlrpciface.h View File

@@ -27,11 +27,11 @@
27 27
 
28 28
 #include <kurl.h>
29 29
 
30
-#include <qbuffer.h>
31
-#include <qdatastream.h>
32
-#include <qobject.h>
33
-#include <qvariant.h>
34
-#include <qvaluelist.h>
30
+#include <tqbuffer.h>
31
+#include <tqdatastream.h>
32
+#include <tqobject.h>
33
+#include <tqvariant.h>
34
+#include <tqvaluelist.h>
35 35
 
36 36
 class QDomDocument;
37 37
 class QDomElement;
@@ -54,62 +54,62 @@ namespace KXMLRPC
54 54
 			class Result
55 55
 			{
56 56
 				friend class Query;
57
-				friend QDataStream &operator>>( QDataStream &s, Query::Result &r );
57
+				friend TQDataStream &operator>>( TQDataStream &s, Query::Result &r );
58 58
 				public:
59 59
 					Result() { }
60 60
 
61 61
 					bool success() const { return m_success; }
62 62
 					int errorCode() const { return m_errorCode; }
63
-					QString errorString() const { return m_errorString; }
64
-					QValueList<QVariant> data() const { return m_data; }
65
-					QString server() const { return m_server; }
66
-					QString method() const { return m_method; }
67
-					QValueList<QVariant> args() const { return m_args; }
63
+					TQString errorString() const { return m_errorString; }
64
+					TQValueList<TQVariant> data() const { return m_data; }
65
+					TQString server() const { return m_server; }
66
+					TQString method() const { return m_method; }
67
+					TQValueList<TQVariant> args() const { return m_args; }
68 68
 
69 69
 				private:
70 70
 					bool m_success;
71 71
 					int m_errorCode;
72
-					QString m_errorString;
73
-					QValueList<QVariant> m_data;
74
-					QString m_server;
75
-					QString m_method;
76
-					QValueList<QVariant> m_args;
72
+					TQString m_errorString;
73
+					TQValueList<TQVariant> m_data;
74
+					TQString m_server;
75
+					TQString m_method;
76
+					TQValueList<TQVariant> m_args;
77 77
 			};
78 78
 
79
-			static Query *create( QObject *parent = 0, const char *name = 0 );
80
-			static QString marshal( const QVariant &v );
81
-			static QVariant demarshal( const QDomElement &e );
79
+			static Query *create( TQObject *parent = 0, const char *name = 0 );
80
+			static TQString marshal( const TQVariant &v );
81
+			static TQVariant demarshal( const TQDomElement &e );
82 82
 
83 83
 		public slots:
84
-			void call( const QString &server, const QString &method,
85
-			           const QValueList<QVariant> &args = QValueList<QVariant>(),
86
-			           const QString &userAgent = "KDE-XMLRPC" );
84
+			void call( const TQString &server, const TQString &method,
85
+			           const TQValueList<TQVariant> &args = TQValueList<TQVariant>(),
86
+			           const TQString &userAgent = "KDE-XMLRPC" );
87 87
 
88 88
 		signals:
89
-			void infoMessage( const QString &msg );
89
+			void infoMessage( const TQString &msg );
90 90
 			void finished( const KXMLRPC::Query::Result &result );
91 91
 
92 92
 		private slots:
93
-			void slotInfoMessage( KIO::Job *job, const QString &msg );
94
-			void slotData( KIO::Job *job, const QByteArray &data );
93
+			void slotInfoMessage( KIO::Job *job, const TQString &msg );
94
+			void slotData( KIO::Job *job, const TQByteArray &data );
95 95
 			void slotResult( KIO::Job *job );
96 96
 
97 97
 		private:
98
-			bool isMessageResponse( const QDomDocument &doc ) const;
99
-			bool isFaultResponse( const QDomDocument &doc ) const;
98
+			bool isMessageResponse( const TQDomDocument &doc ) const;
99
+			bool isFaultResponse( const TQDomDocument &doc ) const;
100 100
 
101
-			Result parseMessageResponse( const QDomDocument &doc ) const;
102
-			Result parseFaultResponse( const QDomDocument &doc ) const;
101
+			Result parseMessageResponse( const TQDomDocument &doc ) const;
102
+			Result parseFaultResponse( const TQDomDocument &doc ) const;
103 103
 
104
-			QString markupCall( const QString &method,
105
-			                    const QValueList<QVariant> &args ) const;
104
+			TQString markupCall( const TQString &method,
105
+			                    const TQValueList<TQVariant> &args ) const;
106 106
 
107
-			Query( QObject *parent = 0, const char *name = 0 );
107
+			Query( TQObject *parent = 0, const char *name = 0 );
108 108
 
109
-			QBuffer m_buffer;
110
-			QString m_server;
111
-			QString m_method;
112
-			QValueList<QVariant> m_args;
109
+			TQBuffer m_buffer;
110
+			TQString m_server;
111
+			TQString m_method;
112
+			TQValueList<TQVariant> m_args;
113 113
 	};
114 114
 
115 115
 	class Server : public QObject
@@ -117,44 +117,44 @@ namespace KXMLRPC
117 117
 		Q_OBJECT
118 118
 		public:
119 119
 			Server( const KURL &url = KURL(),
120
-			        QObject *parent = 0, const char *name = 0 );
120
+			        TQObject *parent = 0, const char *name = 0 );
121 121
 
122 122
 			const KURL &url() const { return m_url; }
123 123
 			void setUrl( const KURL &url );
124 124
 
125
-			QString userAgent() const { return m_userAgent; }
126
-			void setUserAgent( const QString &userAgent) { m_userAgent = userAgent; }
125
+			TQString userAgent() const { return m_userAgent; }
126
+			void setUserAgent( const TQString &userAgent) { m_userAgent = userAgent; }
127 127
 
128 128
 			template <typename T>
129
-			void call( const QString &method, const QValueList<T> &arg,
130
-			           QObject *object, const char *slot );
131
-
132
-			static QValueList<QVariant> toVariantList( const QVariant &arg );
133
-			static QValueList<QVariant> toVariantList( int arg );
134
-			static QValueList<QVariant> toVariantList( bool arg );
135
-			static QValueList<QVariant> toVariantList( double arg );
136
-			static QValueList<QVariant> toVariantList( const QString &arg );
137
-			static QValueList<QVariant> toVariantList( const QCString &arg );
138
-			static QValueList<QVariant> toVariantList( const QByteArray &arg );
139
-			static QValueList<QVariant> toVariantList( const QDateTime &arg );
140
-			static QValueList<QVariant> toVariantList( const QStringList &arg );
129
+			void call( const TQString &method, const TQValueList<T> &arg,
130
+			           TQObject *object, const char *slot );
131
+
132
+			static TQValueList<TQVariant> toVariantList( const TQVariant &arg );
133
+			static TQValueList<TQVariant> toVariantList( int arg );
134
+			static TQValueList<TQVariant> toVariantList( bool arg );
135
+			static TQValueList<TQVariant> toVariantList( double arg );
136
+			static TQValueList<TQVariant> toVariantList( const TQString &arg );
137
+			static TQValueList<TQVariant> toVariantList( const TQCString &arg );
138
+			static TQValueList<TQVariant> toVariantList( const TQByteArray &arg );
139
+			static TQValueList<TQVariant> toVariantList( const TQDateTime &arg );
140
+			static TQValueList<TQVariant> toVariantList( const TQStringList &arg );
141 141
 
142 142
 		signals:
143
-			void infoMessage( const QString &msg );
143
+			void infoMessage( const TQString &msg );
144 144
 
145 145
 		public slots:
146
-			void call( const QString &method, const QValueList<QVariant> &args,
147
-			           QObject *object, const char *slot );
148
-			void call( const QString &method, const QValueList<QVariant> &args,
149
-			           QObject *object, const char *slot,
150
-			           QObject *infoObject, const char *infoSlot );
146
+			void call( const TQString &method, const TQValueList<TQVariant> &args,
147
+			           TQObject *object, const char *slot );
148
+			void call( const TQString &method, const TQValueList<TQVariant> &args,
149
+			           TQObject *object, const char *slot,
150
+			           TQObject *infoObject, const char *infoSlot );
151 151
 
152 152
 		private:
153 153
 			KURL m_url;
154
-			QString m_userAgent;
154
+			TQString m_userAgent;
155 155
 	};
156 156
 
157
-	inline QDataStream &operator>>( QDataStream &s, Query::Result &r )
157
+	inline TQDataStream &operator>>( TQDataStream &s, Query::Result &r )
158 158
 	{
159 159
 		return s >> r.m_errorCode >> r.m_errorString >> r.m_data
160 160
 		         >> r.m_server >> r.m_method >> r.m_args;
@@ -162,20 +162,20 @@ namespace KXMLRPC
162 162
 }
163 163
 
164 164
 template <typename T>
165
-void KXMLRPC::Server::call( const QString &method, const QValueList<T> &arg,
166
-                            QObject *object, const char *slot )
165
+void KXMLRPC::Server::call( const TQString &method, const TQValueList<T> &arg,
166
+                            TQObject *object, const char *slot )
167 167
 {
168
-	QValueList<QVariant> args;
168
+	TQValueList<TQVariant> args;
169 169
 
170
-	typename QValueList<T>::ConstIterator it = arg.begin();
171
-	typename QValueList<T>::ConstIterator end = arg.end();
170
+	typename TQValueList<T>::ConstIterator it = arg.begin();
171
+	typename TQValueList<T>::ConstIterator end = arg.end();
172 172
 	for ( ; it != end; ++it )
173
-		args << QVariant( *it );
173
+		args << TQVariant( *it );
174 174
 
175 175
 	call( method, args, object, slot );
176 176
 }
177 177
 
178
-inline QDataStream &operator<<( QDataStream &s, const KXMLRPC::Query::Result &r )
178
+inline TQDataStream &operator<<( TQDataStream &s, const KXMLRPC::Query::Result &r )
179 179
 {
180 180
 	return s << r.errorCode() << r.errorString() << r.data()
181 181
 	         << r.server() << r.method() << r.args();

+ 7
- 7
filesharing/advanced/kcm_sambaconf/common.cpp View File

@@ -26,21 +26,21 @@
26 26
  *                                                                            *
27 27
  ******************************************************************************/
28 28
 
29
-#include <qstring.h>
30
-#include <qcombobox.h>
31
-#include <qlistbox.h>
29
+#include <tqstring.h>
30
+#include <tqcombobox.h>
31
+#include <tqlistbox.h>
32 32
 
33 33
 #include "common.h"
34 34
 
35
-void setComboToString(QComboBox* combo,const QString & s)
35
+void setComboToString(TQComboBox* combo,const TQString & s)
36 36
 {
37 37
   int i = combo->listBox()->index(combo->listBox()->findItem(s,Qt::ExactMatch));
38 38
   combo->setCurrentItem(i);
39 39
 }
40 40
 
41
-bool boolFromText(const QString & value, bool testTrue)
41
+bool boolFromText(const TQString & value, bool testTrue)
42 42
 {
43
-  QString lower = value.lower();
43
+  TQString lower = value.lower();
44 44
   
45 45
   if (testTrue) {
46 46
     if (lower=="yes" ||
@@ -61,7 +61,7 @@ bool boolFromText(const QString & value, bool testTrue)
61 61
   }
62 62
 }
63 63
 
64
-QString textFromBool(bool value)
64
+TQString textFromBool(bool value)
65 65
 {
66 66
   if (value)
67 67
     return "yes";

+ 3
- 3
filesharing/advanced/kcm_sambaconf/common.h View File

@@ -33,8 +33,8 @@ class QString;
33 33
 class QComboBox;
34 34
 
35 35
 
36
-void setComboToString(QComboBox*,const QString &);
37
-bool boolFromText(const QString & value,bool testTrue=true);
38
-QString textFromBool(bool value);
36
+void setComboToString(TQComboBox*,const TQString &);
37
+bool boolFromText(const TQString & value,bool testTrue=true);
38
+TQString textFromBool(bool value);
39 39
 
40 40
 #endif

+ 33
- 33
filesharing/advanced/kcm_sambaconf/dictmanager.cpp View File

@@ -27,12 +27,12 @@
27 27
  ******************************************************************************/
28 28
  
29 29
  
30
-#include <qlineedit.h>
31
-#include <qcheckbox.h>
32
-#include <qspinbox.h>
33
-#include <qcombobox.h>
34
-#include <qtooltip.h>
35
-#include <qstringlist.h>
30
+#include <tqlineedit.h>
31
+#include <tqcheckbox.h>
32
+#include <tqspinbox.h>
33
+#include <tqcombobox.h>
34
+#include <tqtooltip.h>
35
+#include <tqstringlist.h>
36 36
 
37 37
 #include <kurlrequester.h> 
38 38
 #include <klocale.h>
@@ -56,73 +56,73 @@ DictManager::DictManager(SambaShare* share):
56 56
 DictManager::~DictManager() {
57 57
 }
58 58
 
59
-void DictManager::handleUnsupportedWidget(const QString & s, QWidget* w) {
59
+void DictManager::handleUnsupportedWidget(const TQString & s, TQWidget* w) {
60 60
   w->setEnabled(false);
61
-  QToolTip::add(w,i18n("The option <em>%1</em> is not supported by your Samba version").arg(s));
61
+  TQToolTip::add(w,i18n("The option <em>%1</em> is not supported by your Samba version").arg(s));
62 62
 }
63 63
 
64
-void DictManager::add(const QString & key, QLineEdit* lineEdit) {
64
+void DictManager::add(const TQString & key, TQLineEdit* lineEdit) {
65 65
   if (_share->optionSupported(key)) {
66 66
     lineEditDict.insert(key,lineEdit);
67
-    connect(lineEdit, SIGNAL(textChanged(const QString &)), this, SLOT(changedSlot()));
67
+    connect(lineEdit, TQT_SIGNAL(textChanged(const TQString &)), this, TQT_SLOT(changedSlot()));
68 68
   } else
69 69
     handleUnsupportedWidget(key,lineEdit);
70 70
 }
71 71
 
72
-void DictManager::add(const QString & key, QCheckBox* checkBox){
72
+void DictManager::add(const TQString & key, TQCheckBox* checkBox){
73 73
   if (_share->optionSupported(key)) {
74 74
     checkBoxDict.insert(key,checkBox);
75
-    connect(checkBox, SIGNAL(clicked()), this, SLOT(changedSlot()));
75
+    connect(checkBox, TQT_SIGNAL(clicked()), this, TQT_SLOT(changedSlot()));
76 76
   } else
77 77
     handleUnsupportedWidget(key,checkBox);
78 78
 }
79 79
 
80
-void DictManager::add(const QString & key, KURLRequester* urlRq){
80
+void DictManager::add(const TQString & key, KURLRequester* urlRq){
81 81
   if (_share->optionSupported(key)) {
82 82
     urlRequesterDict.insert(key,urlRq);
83
-    connect(urlRq, SIGNAL(textChanged(const QString &)), this, SLOT(changedSlot()));
83
+    connect(urlRq, TQT_SIGNAL(textChanged(const TQString &)), this, TQT_SLOT(changedSlot()));
84 84
   } else
85 85
     handleUnsupportedWidget(key,urlRq);
86 86
 }
87 87
 
88
-void DictManager::add(const QString & key, QSpinBox* spinBox){
88
+void DictManager::add(const TQString & key, TQSpinBox* spinBox){
89 89
   if (_share->optionSupported(key)) {
90 90
     spinBoxDict.insert(key,spinBox);
91
-    connect(spinBox, SIGNAL(valueChanged(int)), this, SLOT(changedSlot()));
91
+    connect(spinBox, TQT_SIGNAL(valueChanged(int)), this, TQT_SLOT(changedSlot()));
92 92
   } else
93 93
     handleUnsupportedWidget(key,spinBox);
94 94
 }
95 95
               
96
-void DictManager::add(const QString & key, QComboBox* comboBox, QStringList* values){
96
+void DictManager::add(const TQString & key, TQComboBox* comboBox, TQStringList* values){
97 97
   if (_share->optionSupported(key)) {
98 98
     comboBoxDict.insert(key,comboBox);
99 99
     comboBoxValuesDict.insert(key,values);
100
-    connect(comboBox, SIGNAL(activated(int)), this, SLOT(changedSlot()));
100
+    connect(comboBox, TQT_SIGNAL(activated(int)), this, TQT_SLOT(changedSlot()));
101 101
   } else
102 102
     handleUnsupportedWidget(key,comboBox);
103 103
 }
104 104
 
105 105
 
106 106
 void DictManager::load(SambaShare* share, bool globalValue, bool defaultValue){
107
-  QDictIterator<QCheckBox> checkBoxIt( checkBoxDict ); 
107
+  TQDictIterator<TQCheckBox> checkBoxIt( checkBoxDict ); 
108 108
    
109 109
   for( ; checkBoxIt.current(); ++checkBoxIt )	{
110 110
     checkBoxIt.current()->setChecked(share->getBoolValue(checkBoxIt.currentKey(),globalValue,defaultValue));
111 111
   }
112 112
 
113
-  QDictIterator<QLineEdit> lineEditIt( lineEditDict ); 
113
+  TQDictIterator<TQLineEdit> lineEditIt( lineEditDict ); 
114 114
  
115 115
   for( ; lineEditIt.current(); ++lineEditIt )	{
116 116
     lineEditIt.current()->setText(share->getValue(lineEditIt.currentKey(),globalValue,defaultValue));
117 117
   }
118 118
 
119
-  QDictIterator<KURLRequester> urlRequesterIt( urlRequesterDict ); 
119
+  TQDictIterator<KURLRequester> urlRequesterIt( urlRequesterDict ); 
120 120
  
121 121
   for( ; urlRequesterIt.current(); ++urlRequesterIt )	{
122 122
     urlRequesterIt.current()->setURL(share->getValue(urlRequesterIt.currentKey(),globalValue,defaultValue));
123 123
   }
124 124
 
125
-  QDictIterator<QSpinBox> spinBoxIt( spinBoxDict ); 
125
+  TQDictIterator<TQSpinBox> spinBoxIt( spinBoxDict ); 
126 126
    
127 127
   for( ; spinBoxIt.current(); ++spinBoxIt )	{
128 128
     spinBoxIt.current()->setValue(share->getValue(spinBoxIt.currentKey(),globalValue,defaultValue).toInt());
@@ -133,11 +133,11 @@ void DictManager::load(SambaShare* share, bool globalValue, bool defaultValue){
133 133
 }
134 134
 
135 135
 void DictManager::loadComboBoxes(SambaShare* share, bool globalValue, bool defaultValue) {
136
-  QDictIterator<QComboBox> comboBoxIt( comboBoxDict ); 
136
+  TQDictIterator<TQComboBox> comboBoxIt( comboBoxDict ); 
137 137
    
138 138
   for( ; comboBoxIt.current(); ++comboBoxIt )	{
139
-    QStringList *v = comboBoxValuesDict[comboBoxIt.currentKey()];
140
-    QString value = share->getValue(comboBoxIt.currentKey(),globalValue,defaultValue);
139
+    TQStringList *v = comboBoxValuesDict[comboBoxIt.currentKey()];
140
+    TQString value = share->getValue(comboBoxIt.currentKey(),globalValue,defaultValue);
141 141
 
142 142
     if (value.isNull())
143 143
         continue;
@@ -147,9 +147,9 @@ void DictManager::loadComboBoxes(SambaShare* share, bool globalValue, bool defau
147 147
     
148 148
     int comboIndex = 0;
149 149
                                 
150
-    QStringList::iterator it;
150
+    TQStringList::iterator it;
151 151
     for ( it = v->begin(); it != v->end(); ++it ) {
152
-      QString lower = (*it).lower();      
152
+      TQString lower = (*it).lower();      
153 153
       if ( lower == "yes" &&
154 154
            boolFromText(value))
155 155
            break;
@@ -170,34 +170,34 @@ void DictManager::loadComboBoxes(SambaShare* share, bool globalValue, bool defau
170 170
 
171 171
 
172 172
 void DictManager::save(SambaShare* share, bool globalValue, bool defaultValue){
173
-  QDictIterator<QCheckBox> checkBoxIt( checkBoxDict ); 
173
+  TQDictIterator<TQCheckBox> checkBoxIt( checkBoxDict ); 
174 174
  
175 175
   for( ; checkBoxIt.current(); ++checkBoxIt )	{
176 176
     share->setValue(checkBoxIt.currentKey(),checkBoxIt.current()->isChecked(), globalValue, defaultValue );
177 177
   }
178 178
 
179
-  QDictIterator<QLineEdit> lineEditIt( lineEditDict ); 
179
+  TQDictIterator<TQLineEdit> lineEditIt( lineEditDict ); 
180 180
    
181 181
   for( ; lineEditIt.current(); ++lineEditIt )	{
182 182
     share->setValue(lineEditIt.currentKey(),lineEditIt.current()->text(), globalValue, defaultValue );
183 183
   }
184 184
 
185
-  QDictIterator<KURLRequester> urlRequesterIt( urlRequesterDict ); 
185
+  TQDictIterator<KURLRequester> urlRequesterIt( urlRequesterDict ); 
186 186
  
187 187
   for( ; urlRequesterIt.current(); ++urlRequesterIt )	{
188 188
     share->setValue(urlRequesterIt.currentKey(),urlRequesterIt.current()->url(), globalValue, defaultValue );
189 189
   }
190 190
 
191
-  QDictIterator<QSpinBox> spinBoxIt( spinBoxDict ); 
191
+  TQDictIterator<TQSpinBox> spinBoxIt( spinBoxDict ); 
192 192
  
193 193
   for( ; spinBoxIt.current(); ++spinBoxIt )	{
194 194
     share->setValue(spinBoxIt.currentKey(),spinBoxIt.current()->value(), globalValue, defaultValue );
195 195
   }
196 196