Browse Source

Initial TQt conversion


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/bibletime@1173696 283d02a7-25f6-0310-bc7c-ecb5cbfe19
tags/v3.5.13
tpearson 8 years ago
parent
commit
62f474f240
100 changed files with 2132 additions and 2132 deletions
  1. 17
    17
      bibletime/backend/bt_gbfhtml.cpp
  2. 10
    10
      bibletime/backend/bt_osishtml.cpp
  3. 2
    2
      bibletime/backend/bt_plainhtml.cpp
  4. 34
    34
      bibletime/backend/bt_thmlhtml.cpp
  5. 1
    1
      bibletime/backend/btstringmgr.cpp
  6. 2
    2
      bibletime/backend/btstringmgr.h
  7. 8
    8
      bibletime/backend/cbookdisplay.cpp
  8. 2
    2
      bibletime/backend/cbookdisplay.h
  9. 3
    3
      bibletime/backend/cchapterdisplay.cpp
  10. 1
    1
      bibletime/backend/cchapterdisplay.h
  11. 21
    21
      bibletime/backend/cdisplayrendering.cpp
  12. 3
    3
      bibletime/backend/cdisplayrendering.h
  13. 26
    26
      bibletime/backend/cdisplaytemplatemgr.cpp
  14. 17
    17
      bibletime/backend/cdisplaytemplatemgr.h
  15. 4
    4
      bibletime/backend/centrydisplay.cpp
  16. 2
    2
      bibletime/backend/centrydisplay.h
  17. 16
    16
      bibletime/backend/chtmlexportrendering.cpp
  18. 3
    3
      bibletime/backend/chtmlexportrendering.h
  19. 13
    13
      bibletime/backend/clanguagemgr.cpp
  20. 26
    26
      bibletime/backend/clanguagemgr.h
  21. 5
    5
      bibletime/backend/cplaintextexportrendering.cpp
  22. 2
    2
      bibletime/backend/cplaintextexportrendering.h
  23. 31
    31
      bibletime/backend/creferencemanager.cpp
  24. 12
    12
      bibletime/backend/creferencemanager.h
  25. 56
    56
      bibletime/backend/cswordbackend.cpp
  26. 15
    15
      bibletime/backend/cswordbackend.h
  27. 9
    9
      bibletime/backend/cswordbiblemoduleinfo.cpp
  28. 8
    8
      bibletime/backend/cswordbiblemoduleinfo.h
  29. 25
    25
      bibletime/backend/cswordkey.cpp
  30. 9
    9
      bibletime/backend/cswordkey.h
  31. 8
    8
      bibletime/backend/cswordldkey.cpp
  32. 6
    6
      bibletime/backend/cswordldkey.h
  33. 22
    22
      bibletime/backend/cswordlexiconmoduleinfo.cpp
  34. 3
    3
      bibletime/backend/cswordlexiconmoduleinfo.h
  35. 91
    91
      bibletime/backend/cswordmoduleinfo.cpp
  36. 24
    24
      bibletime/backend/cswordmoduleinfo.h
  37. 3
    3
      bibletime/backend/cswordmodulesearch.cpp
  38. 7
    7
      bibletime/backend/cswordmodulesearch.h
  39. 11
    11
      bibletime/backend/cswordtreekey.cpp
  40. 6
    6
      bibletime/backend/cswordtreekey.h
  41. 11
    11
      bibletime/backend/cswordversekey.cpp
  42. 7
    7
      bibletime/backend/cswordversekey.h
  43. 26
    26
      bibletime/backend/ctextrendering.cpp
  44. 16
    16
      bibletime/backend/ctextrendering.h
  45. 9
    9
      bibletime/bibletime.cpp
  46. 27
    27
      bibletime/bibletime.h
  47. 23
    23
      bibletime/bibletime_dcop.cpp
  48. 57
    57
      bibletime/bibletime_init.cpp
  49. 36
    36
      bibletime/bibletime_slots.cpp
  50. 1
    1
      bibletime/bibletimeapp.cpp
  51. 14
    14
      bibletime/bibletimeinterface.h
  52. 54
    54
      bibletime/bibletimeinterface_skel.cpp
  53. 25
    25
      bibletime/frontend/btinstallmgr.cpp
  54. 14
    14
      bibletime/frontend/btinstallmgr.h
  55. 72
    72
      bibletime/frontend/cbtconfig.cpp
  56. 30
    30
      bibletime/frontend/cbtconfig.h
  57. 42
    42
      bibletime/frontend/cdragdropmgr.cpp
  58. 28
    28
      bibletime/frontend/cdragdropmgr.h
  59. 56
    56
      bibletime/frontend/cexportmanager.cpp
  60. 16
    16
      bibletime/frontend/cexportmanager.h
  61. 63
    63
      bibletime/frontend/cinfodisplay.cpp
  62. 15
    15
      bibletime/frontend/cinfodisplay.h
  63. 20
    20
      bibletime/frontend/cinputdialog.cpp
  64. 6
    6
      bibletime/frontend/cinputdialog.h
  65. 32
    32
      bibletime/frontend/cmanageindiceswidget.cpp
  66. 5
    5
      bibletime/frontend/cmanageindiceswidget.h
  67. 42
    42
      bibletime/frontend/cmdiarea.cpp
  68. 21
    21
      bibletime/frontend/cmdiarea.h
  69. 4
    4
      bibletime/frontend/cmoduleindexdialog.cpp
  70. 2
    2
      bibletime/frontend/cmoduleindexdialog.h
  71. 124
    124
      bibletime/frontend/coptionsdialog.cpp
  72. 46
    46
      bibletime/frontend/coptionsdialog.h
  73. 10
    10
      bibletime/frontend/cprinter.cpp
  74. 6
    6
      bibletime/frontend/cprinter.h
  75. 58
    58
      bibletime/frontend/cprofile.cpp
  76. 14
    14
      bibletime/frontend/cprofile.h
  77. 16
    16
      bibletime/frontend/cprofilemgr.cpp
  78. 7
    7
      bibletime/frontend/cprofilemgr.h
  79. 7
    7
      bibletime/frontend/cprofilewindow.cpp
  80. 13
    13
      bibletime/frontend/cprofilewindow.h
  81. 8
    8
      bibletime/frontend/crossrefrendering.cpp
  82. 2
    2
      bibletime/frontend/crossrefrendering.h
  83. 123
    123
      bibletime/frontend/cswordsetupdialog.cpp
  84. 39
    39
      bibletime/frontend/cswordsetupdialog.h
  85. 38
    38
      bibletime/frontend/cswordsetupinstallsourcesdialog.cpp
  86. 8
    8
      bibletime/frontend/cswordsetupinstallsourcesdialog.h
  87. 52
    52
      bibletime/frontend/cswordsetupmodulelistview.cpp
  88. 14
    14
      bibletime/frontend/cswordsetupmodulelistview.h
  89. 22
    22
      bibletime/frontend/display/cdisplay.cpp
  90. 23
    23
      bibletime/frontend/display/cdisplay.h
  91. 52
    52
      bibletime/frontend/display/chtmlreaddisplay.cpp
  92. 25
    25
      bibletime/frontend/display/chtmlreaddisplay.h
  93. 27
    27
      bibletime/frontend/display/chtmlwritedisplay.cpp
  94. 10
    10
      bibletime/frontend/display/chtmlwritedisplay.h
  95. 23
    23
      bibletime/frontend/display/cplainwritedisplay.cpp
  96. 15
    15
      bibletime/frontend/display/cplainwritedisplay.h
  97. 5
    5
      bibletime/frontend/display/creaddisplay.cpp
  98. 6
    6
      bibletime/frontend/display/creaddisplay.h
  99. 1
    1
      bibletime/frontend/display/cwritedisplay.cpp
  100. 0
    0
      bibletime/frontend/display/cwritedisplay.h

+ 17
- 17
bibletime/backend/bt_gbfhtml.cpp View File

@@ -24,8 +24,8 @@
24 24
 #include <utilxml.h>
25 25
 
26 26
 //Qt includes
27
-#include <qregexp.h>
28
-#include <qstring.h>
27
+#include <tqregexp.h>
28
+#include <tqstring.h>
29 29
 
30 30
 using namespace Filters;
31 31
 
@@ -97,13 +97,13 @@ char BT_GBFHTML::processText(sword::SWBuf& buf, const sword::SWKey * key, const
97 97
 
98 98
 	//Am Anfang<WH07225> schuf<WH01254><WTH8804> Gott<WH0430> Himmel<WH08064> und<WT> Erde<WH0776>.
99 99
 	//A simple word<WT> means: No entry for this word "word"
100
-	QString result;
100
+	TQString result;
101 101
 
102
-	QString t = QString::fromUtf8(buf.c_str());
102
+	TQString t = TQString::fromUtf8(buf.c_str());
103 103
 
104
-	QRegExp tag("([.,;:]?<W[HGT][^>]*>\\s*)+");
104
+	TQRegExp tag("([.,;:]?<W[HGT][^>]*>\\s*)+");
105 105
 
106
-	QStringList list;
106
+	TQStringList list;
107 107
 
108 108
 	int lastMatchEnd = 0;
109 109
 
@@ -129,11 +129,11 @@ char BT_GBFHTML::processText(sword::SWBuf& buf, const sword::SWKey * key, const
129 129
 	//list is now a list of words with 1-n Strongs at the end, which belong to this word.
130 130
 	
131 131
 	//now create the necessary HTML in list entries and concat them to the result
132
-	tag = QRegExp("<W([HGT])([^>]*)>");
132
+	tag = TQRegExp("<W([HGT])([^>]*)>");
133 133
 	tag.setMinimal(true);
134 134
 
135
-	for (QStringList::iterator it = list.begin(); it != list.end(); ++it) {
136
-		QString e = (*it); //current entry to process
135
+	for (TQStringList::iterator it = list.begin(); it != list.end(); ++it) {
136
+		TQString e = (*it); //current entry to process
137 137
  		//qWarning(e.latin1());
138 138
 		
139 139
 		//check if there is a word to which the strongs info belongs to.
@@ -141,7 +141,7 @@ char BT_GBFHTML::processText(sword::SWBuf& buf, const sword::SWKey * key, const
141 141
 		//If not, leave out the strongs info, because it can't be tight to a text
142 142
 		//Comparing the first char with < is not enough, because the tokenReplace is done already
143 143
 		//so there might be html tags already.
144
-		const bool textPresent = (e.stripWhiteSpace().remove(QRegExp("[.,;:]")).left(2) != "<W");
144
+		const bool textPresent = (e.stripWhiteSpace().remove(TQRegExp("[.,;:]")).left(2) != "<W");
145 145
 
146 146
 		if (!textPresent) {
147 147
 			result += (*it);
@@ -153,7 +153,7 @@ char BT_GBFHTML::processText(sword::SWBuf& buf, const sword::SWKey * key, const
153 153
 		bool hasLemmaAttr = false;
154 154
 		bool hasMorphAttr = false;
155 155
 
156
-		QString value = QString::null;
156
+		TQString value = TQString::null;
157 157
 		int tagAttributeStart = -1;
158 158
 
159 159
 		while (pos != -1) { //work on all strong/lemma tags in this section, should be between 1-3 loops
@@ -170,14 +170,14 @@ char BT_GBFHTML::processText(sword::SWBuf& buf, const sword::SWKey * key, const
170 170
 				pos += 7;
171 171
 
172 172
 				//skip blanks, commas, dots and stuff at the beginning, it doesn't belong to the morph code
173
-				QString rep("<span ");
173
+				TQString rep("<span ");
174 174
 				rep.append(isMorph ? "morph" : "lemma").append("=\"").append(value).append("\">");
175 175
 
176 176
 				hasMorphAttr = isMorph;
177 177
 				hasLemmaAttr = !isMorph;
178 178
 
179 179
 				int startPos = 0;
180
-				QChar c = e[startPos];
180
+				TQChar c = e[startPos];
181 181
 
182 182
 				while ((startPos < pos) && (c.isSpace() || c.isPunct())) {
183 183
 					++startPos;
@@ -198,12 +198,12 @@ char BT_GBFHTML::processText(sword::SWBuf& buf, const sword::SWKey * key, const
198 198
 
199 199
 				if ((!isMorph && hasLemmaAttr) || (isMorph && hasMorphAttr)) { //we append another attribute value, e.g. 3000 gets 3000|5000
200 200
 					//search the existing attribute start
201
-					QRegExp attrRegExp( isMorph ? "morph=\".+(?=\")" : "lemma=\".+(?=\")" );
201
+					TQRegExp attrRegExp( isMorph ? "morph=\".+(?=\")" : "lemma=\".+(?=\")" );
202 202
 					attrRegExp.setMinimal(true);
203 203
 					const int foundPos = e.find(attrRegExp, tagAttributeStart);
204 204
 
205 205
 					if (foundPos != -1) {
206
-						e.insert(foundPos + attrRegExp.matchedLength(), QString("|").append(value));
206
+						e.insert(foundPos + attrRegExp.matchedLength(), TQString("|").append(value));
207 207
 						pos += value.length() + 1;
208 208
 
209 209
 						hasLemmaAttr = !isMorph;
@@ -211,7 +211,7 @@ char BT_GBFHTML::processText(sword::SWBuf& buf, const sword::SWKey * key, const
211 211
 					}
212 212
 				}
213 213
 				else { //attribute was not yet inserted
214
-					QString attr;
214
+					TQString attr;
215 215
 					attr.setLatin1(isMorph ? "morph" : "lemma").append("=\"").append(value).append("\" ");
216 216
 
217 217
 					e.insert(tagAttributeStart, attr);
@@ -272,7 +272,7 @@ bool BT_GBFHTML::handleToken(sword::SWBuf &buf, const char *token, sword::BasicF
272 272
 			buf.append('/');
273 273
 			buf.append(myUserData->key->getShortText());
274 274
 			buf.append('/');
275
-			buf.append( QString::number(myUserData->swordFootnote++).latin1() );
275
+			buf.append( TQString::number(myUserData->swordFootnote++).latin1() );
276 276
 			buf.append("\">*</span> ");
277 277
 
278 278
 			userData->suspendTextPassThru = true;

+ 10
- 10
bibletime/backend/bt_osishtml.cpp View File

@@ -31,7 +31,7 @@
31 31
 #include <klocale.h>
32 32
 
33 33
 //Qt includes
34
-#include <qstring.h>
34
+#include <tqstring.h>
35 35
 
36 36
 using sword::SWBuf;
37 37
 using sword::XMLTag;
@@ -298,7 +298,7 @@ bool BT_OSISHTML::handleToken(sword::SWBuf &buf, const char *token, sword::Basic
298 298
 					buf.append('/');
299 299
 					buf.append(myUserData->key->getShortText());
300 300
 					buf.append('/');
301
-					buf.append( QString::number(myUserData->swordFootnote++).latin1() ); //inefficient
301
+					buf.append( TQString::number(myUserData->swordFootnote++).latin1() ); //inefficient
302 302
 
303 303
 					const SWBuf n = tag.getAttribute("n");
304 304
 					
@@ -334,8 +334,8 @@ bool BT_OSISHTML::handleToken(sword::SWBuf &buf, const char *token, sword::Basic
334 334
 		else if (!strcmp(tag.getName(), "reference")) { // <reference> tag
335 335
 
336 336
 			if (!tag.isEndTag() && !tag.isEmpty()) {
337
-				QString ref( tag.getAttribute("osisRef") );
338
-				QString hrefRef( ref );
337
+				TQString ref( tag.getAttribute("osisRef") );
338
+				TQString hrefRef( ref );
339 339
 				Q_ASSERT(!ref.isEmpty());
340 340
 
341 341
 				if (!ref.isEmpty()) {
@@ -357,7 +357,7 @@ bool BT_OSISHTML::handleToken(sword::SWBuf &buf, const char *token, sword::Basic
357 357
 					int pos = ref.find(":");
358 358
 
359 359
 					if ((pos >= 0) && ref.at(pos-1).isLetter() && ref.at(pos+1).isLetter()) {
360
-						QString newModuleName = ref.left(pos);
360
+						TQString newModuleName = ref.left(pos);
361 361
 						hrefRef = ref.mid(pos+1);
362 362
 
363 363
 						if (CPointers::backend()->findModuleByName(newModuleName)) {
@@ -366,10 +366,10 @@ bool BT_OSISHTML::handleToken(sword::SWBuf &buf, const char *token, sword::Basic
366 366
 					}
367 367
 
368 368
 					CReferenceManager::ParseOptions options;
369
-					options.refBase = QString::fromUtf8(myUserData->key->getText());
370
-					options.refDestinationModule = QString(mod->name());
371
-					options.sourceLanguage = QString(myModule->Lang());
372
-					options.destinationLanguage = QString("en");
369
+					options.refBase = TQString::fromUtf8(myUserData->key->getText());
370
+					options.refDestinationModule = TQString(mod->name());
371
+					options.sourceLanguage = TQString(myModule->Lang());
372
+					options.destinationLanguage = TQString("en");
373 373
 
374 374
 					buf.append("<a href=\"");
375 375
 					buf.append( //create the hyperlink with key and mod
@@ -599,7 +599,7 @@ bool BT_OSISHTML::handleToken(sword::SWBuf &buf, const char *token, sword::Basic
599 599
 			else { // seg end tag
600 600
 				buf.append("</span>");
601 601
 			}
602
-			//qWarning(QString("handled <seg> token. result: %1").arg(buf.c_str()).latin1());
602
+			//qWarning(TQString("handled <seg> token. result: %1").arg(buf.c_str()).latin1());
603 603
 		}
604 604
 		
605 605
 		//divine name, don't use simple tag replacing because it may have attributes

+ 2
- 2
bibletime/backend/bt_plainhtml.cpp View File

@@ -24,8 +24,8 @@
24 24
 #include <utilxml.h>
25 25
 
26 26
 //Qt includes
27
-#include <qregexp.h>
28
-#include <qstring.h>
27
+#include <tqregexp.h>
28
+#include <tqstring.h>
29 29
 
30 30
 using namespace Filters;
31 31
 

+ 34
- 34
bibletime/backend/bt_thmlhtml.cpp View File

@@ -29,8 +29,8 @@
29 29
 #include "versekey.h"
30 30
 
31 31
 //Qt includes
32
-#include <qstring.h>
33
-#include <qregexp.h>
32
+#include <tqstring.h>
33
+#include <tqregexp.h>
34 34
 
35 35
 //System includes
36 36
 #include <stdlib.h>
@@ -60,12 +60,12 @@ char BT_ThMLHTML::processText(sword::SWBuf& buf, const sword::SWKey* key, const
60 60
 		return 1;
61 61
 	}
62 62
 
63
-	QString result;
63
+	TQString result;
64 64
 
65
-	QString t = QString::fromUtf8(buf.c_str());
66
-	QRegExp tag("([.,;]?<sync[^>]+(type|value)=\"([^\"]+)\"[^>]+(type|value)=\"([^\"]+)\"([^<]*)>)+");
65
+	TQString t = TQString::fromUtf8(buf.c_str());
66
+	TQRegExp tag("([.,;]?<sync[^>]+(type|value)=\"([^\"]+)\"[^>]+(type|value)=\"([^\"]+)\"([^<]*)>)+");
67 67
 
68
-	QStringList list;
68
+	TQStringList list;
69 69
 	int lastMatchEnd = 0;
70 70
 	int pos = tag.search(t,0);
71 71
 
@@ -84,12 +84,12 @@ char BT_ThMLHTML::processText(sword::SWBuf& buf, const sword::SWKey* key, const
84 84
 		list.append(t.right(t.length() - lastMatchEnd));
85 85
 	}
86 86
 
87
-	tag = QRegExp("<sync[^>]+(type|value|class)=\"([^\"]+)\"[^>]+(type|value|class)=\"([^\"]+)\"[^>]+((type|value|class)=\"([^\"]+)\")*([^<]*)>");
87
+	tag = TQRegExp("<sync[^>]+(type|value|class)=\"([^\"]+)\"[^>]+(type|value|class)=\"([^\"]+)\"[^>]+((type|value|class)=\"([^\"]+)\")*([^<]*)>");
88 88
 
89
-	for (QStringList::iterator it = list.begin(); it != list.end(); ++it) {
90
-		QString e( *it );
89
+	for (TQStringList::iterator it = list.begin(); it != list.end(); ++it) {
90
+		TQString e( *it );
91 91
 
92
-		const bool textPresent = (e.stripWhiteSpace().remove(QRegExp("[.,;:]")).left(1) != "<");
92
+		const bool textPresent = (e.stripWhiteSpace().remove(TQRegExp("[.,;:]")).left(1) != "<");
93 93
 
94 94
 		if (!textPresent) {
95 95
 			continue;
@@ -101,14 +101,14 @@ char BT_ThMLHTML::processText(sword::SWBuf& buf, const sword::SWKey* key, const
101 101
 
102 102
 		int pos = tag.search(e, 0);
103 103
 		bool insertedTag = false;
104
-		QString value;
105
-		QString valueClass;
104
+		TQString value;
105
+		TQString valueClass;
106 106
 
107 107
 		while (pos != -1) {
108 108
 			bool isMorph = false;
109 109
 			bool isStrongs = false;
110
-			value = QString::null;
111
-			valueClass = QString::null;
110
+			value = TQString::null;
111
+			valueClass = TQString::null;
112 112
 
113 113
 			// check 3 attribute/value pairs
114 114
 
@@ -143,10 +143,10 @@ char BT_ThMLHTML::processText(sword::SWBuf& buf, const sword::SWKey* key, const
143 143
 				e.replace(pos, tag.matchedLength(), "</span>");
144 144
 				pos += 7;
145 145
 
146
-				QString rep;
146
+				TQString rep;
147 147
 				rep.setLatin1("<span lemma=\"").append(value).append("\">");
148 148
 				int startPos = 0;
149
-				QChar c = e[startPos];
149
+				TQChar c = e[startPos];
150 150
 
151 151
 				while ((startPos < pos) && (c.isSpace() || c.isPunct())) {
152 152
 					++startPos;
@@ -164,12 +164,12 @@ char BT_ThMLHTML::processText(sword::SWBuf& buf, const sword::SWKey* key, const
164 164
 
165 165
 				if ((!isMorph && hasLemmaAttr) || (isMorph && hasMorphAttr)) { //we append another attribute value, e.g. 3000 gets 3000|5000
166 166
 					//search the existing attribute start
167
-					QRegExp attrRegExp( isMorph ? "morph=\".+(?=\")" : "lemma=\".+(?=\")" );
167
+					TQRegExp attrRegExp( isMorph ? "morph=\".+(?=\")" : "lemma=\".+(?=\")" );
168 168
 					attrRegExp.setMinimal(true);
169 169
 					const int foundAttrPos = e.find(attrRegExp, pos);
170 170
 
171 171
 					if (foundAttrPos != -1) {
172
-						e.insert(foundAttrPos + attrRegExp.matchedLength(), QString("|").append(value));
172
+						e.insert(foundAttrPos + attrRegExp.matchedLength(), TQString("|").append(value));
173 173
 						pos += value.length() + 1;
174 174
 
175 175
 						hasLemmaAttr = !isMorph;
@@ -177,10 +177,10 @@ char BT_ThMLHTML::processText(sword::SWBuf& buf, const sword::SWKey* key, const
177 177
 					}
178 178
 				}
179 179
 				else { //attribute was not yet inserted
180
-					const int attrPos = e.find(QRegExp("morph=|lemma="), 0);
180
+					const int attrPos = e.find(TQRegExp("morph=|lemma="), 0);
181 181
 
182 182
 					if (attrPos >= 0) {
183
-						QString attr;
183
+						TQString attr;
184 184
 						attr.append(isMorph ? "morph" : "lemma").append("=\"").append(value).append("\" ");
185 185
 						e.insert(attrPos, attr);
186 186
 
@@ -217,7 +217,7 @@ bool BT_ThMLHTML::handleToken(sword::SWBuf &buf, const char *token, sword::Basic
217 217
 
218 218
 			if (tag.getAttribute("lang")) {
219 219
 				const char* abbrev = tag.getAttribute("lang");
220
-				//const CLanguageMgr::Language* const language = CPointers::languageMgr()->languageForAbbrev( QString::fromLatin1(abbrev) );
220
+				//const CLanguageMgr::Language* const language = CPointers::languageMgr()->languageForAbbrev( TQString::fromLatin1(abbrev) );
221 221
 
222 222
 				buf.append("<span class=\"foreign\" lang=\"");
223 223
 				buf.append(abbrev);
@@ -241,7 +241,7 @@ bool BT_ThMLHTML::handleToken(sword::SWBuf &buf, const char *token, sword::Basic
241 241
 				buf.append('/');
242 242
 				buf.append(myUserData->key->getShortText());
243 243
 				buf.append('/');
244
-				buf.append( QString::number(myUserData->swordFootnote++).latin1() );
244
+				buf.append( TQString::number(myUserData->swordFootnote++).latin1() );
245 245
 				buf.append("\">*</span> ");
246 246
 
247 247
 				myUserData->suspendTextPassThru = true;
@@ -270,22 +270,22 @@ bool BT_ThMLHTML::handleToken(sword::SWBuf &buf, const char *token, sword::Basic
270 270
 						Q_ASSERT(mod);
271 271
 						if (mod) {
272 272
 							CReferenceManager::ParseOptions options;
273
-							options.refBase = QString::fromUtf8(myUserData->key->getText()); //current module key
274
-							options.refDestinationModule = QString(mod->name());
275
-							options.sourceLanguage = QString(myModule->Lang());
276
- 							options.destinationLanguage = QString("en");
273
+							options.refBase = TQString::fromUtf8(myUserData->key->getText()); //current module key
274
+							options.refDestinationModule = TQString(mod->name());
275
+							options.sourceLanguage = TQString(myModule->Lang());
276
+ 							options.destinationLanguage = TQString("en");
277 277
 
278 278
 							//it's ok to split the reference, because to descriptive text is given
279 279
 							bool insertSemicolon = false;
280 280
 							buf.append("<span class=\"crossreference\">");
281
-							QStringList refs = QStringList::split(";", QString::fromUtf8(myUserData->lastTextNode.c_str()));
282
-							QString oldRef; //the previous reference to use as a base for the next refs
283
-							for (QStringList::iterator it(refs.begin()); it != refs.end(); ++it) {
281
+							TQStringList refs = TQStringList::split(";", TQString::fromUtf8(myUserData->lastTextNode.c_str()));
282
+							TQString oldRef; //the previous reference to use as a base for the next refs
283
+							for (TQStringList::iterator it(refs.begin()); it != refs.end(); ++it) {
284 284
 
285 285
 								if (! oldRef.isEmpty() ){
286 286
 									options.refBase = oldRef; //use the last ref as a base, e.g. Rom 1,2-3, when the next ref is only 3:3-10
287 287
 								}
288
-								const QString completeRef( CReferenceManager::parseVerseReference((*it), options) );
288
+								const TQString completeRef( CReferenceManager::parseVerseReference((*it), options) );
289 289
 
290 290
 								oldRef = completeRef; //use the parsed result as the base for the next ref.
291 291
 
@@ -329,12 +329,12 @@ bool BT_ThMLHTML::handleToken(sword::SWBuf &buf, const char *token, sword::Basic
329 329
 					Q_ASSERT(mod);
330 330
 
331 331
 					CReferenceManager::ParseOptions options;
332
-					options.refBase = QString::fromUtf8(myUserData->key->getText());
333
-					options.refDestinationModule = QString(mod->name());
332
+					options.refBase = TQString::fromUtf8(myUserData->key->getText());
333
+					options.refDestinationModule = TQString(mod->name());
334 334
 					options.sourceLanguage = myModule->Lang();
335
-					options.destinationLanguage = QString("en");
335
+					options.destinationLanguage = TQString("en");
336 336
 
337
-					const QString completeRef = CReferenceManager::parseVerseReference(QString::fromUtf8(ref), options);
337
+					const TQString completeRef = CReferenceManager::parseVerseReference(TQString::fromUtf8(ref), options);
338 338
 
339 339
 					if (mod) {
340 340
 						buf.append("<span class=\"crossreference\">");

+ 1
- 1
bibletime/backend/btstringmgr.cpp View File

@@ -19,7 +19,7 @@ char* BTStringMgr::upperUTF8(char* text, unsigned int maxlen) const {
19 19
 	const int max = (maxlen>0) ? maxlen : strlen(text);
20 20
 
21 21
 	if (isUtf8(text)) {
22
-		strncpy(text, (const char*)QString::fromUtf8(text).upper().utf8(), max);
22
+		strncpy(text, (const char*)TQString::fromUtf8(text).upper().utf8(), max);
23 23
 
24 24
 		return text;
25 25
 	}

+ 2
- 2
bibletime/backend/btstringmgr.h View File

@@ -16,12 +16,12 @@
16 16
 #include <stringmgr.h>
17 17
 
18 18
 //Qt includes
19
-#include <qstring.h>
19
+#include <tqstring.h>
20 20
 
21 21
 using namespace sword;
22 22
 
23 23
 /** Unicode string manager implementation.
24
- * This is the StringManager implementation which works with QString.
24
+ * This is the StringManager implementation which works with TQString.
25 25
  * @author The BibleTime developers
26 26
  */
27 27
 

+ 8
- 8
bibletime/backend/cbookdisplay.cpp View File

@@ -23,7 +23,7 @@ namespace Rendering {
23 23
 
24 24
 
25 25
 	/** Returns the rendered text using the modules in the list and using the key parameter. The displayoptions and filter options are used, too. */
26
-	const QString CBookDisplay::text( const ListCSwordModuleInfo& modules, const QString& keyName, const CSwordBackend::DisplayOptions displayOptions, const CSwordBackend::FilterOptions filterOptions ) {
26
+	const TQString CBookDisplay::text( const ListCSwordModuleInfo& modules, const TQString& keyName, const CSwordBackend::DisplayOptions displayOptions, const CSwordBackend::FilterOptions filterOptions ) {
27 27
 		CSwordBookModuleInfo* book = dynamic_cast<CSwordBookModuleInfo*>(modules.first());
28 28
 		Q_ASSERT(book);
29 29
 
@@ -50,7 +50,7 @@ namespace Rendering {
50 50
 		if ((displayLevel <= 1) || (key->key().isEmpty() || (key->key() == "/") )) {
51 51
 			tree.append( new CDisplayRendering::KeyTreeItem( key->key(), modules, itemSettings ) );
52 52
 
53
-			const QString renderedText = render.renderKeyTree(tree);
53
+			const TQString renderedText = render.renderKeyTree(tree);
54 54
 			key->setOffset( offset );
55 55
 			return renderedText;
56 56
 		};
@@ -79,7 +79,7 @@ namespace Rendering {
79 79
 			//display current level, we could also decide to display the available levels together
80 80
 			tree.append( new CDisplayRendering::KeyTreeItem( key->key(), modules, itemSettings ) );
81 81
 
82
-			const QString renderedText = render.renderKeyTree(tree);
82
+			const TQString renderedText = render.renderKeyTree(tree);
83 83
 			key->setOffset( offset );
84 84
 			return renderedText;
85 85
 		};
@@ -95,7 +95,7 @@ namespace Rendering {
95 95
 			if ( !key->parent() ) { //something went wrong although we checked before! Be safe and return entry's text
96 96
 				tree.append( new CDisplayRendering::KeyTreeItem( key->key(), modules, itemSettings ) );
97 97
 
98
-				const QString renderedText = render.renderKeyTree(tree);
98
+				const TQString renderedText = render.renderKeyTree(tree);
99 99
 				key->setOffset( offset );
100 100
 				return renderedText;
101 101
 			};
@@ -111,16 +111,16 @@ namespace Rendering {
111 111
 
112 112
 		setupRenderTree(key.get(), &tree, keyName);
113 113
 
114
-		const QString renderedText = render.renderKeyTree(tree);
114
+		const TQString renderedText = render.renderKeyTree(tree);
115 115
 
116 116
 		key->setOffset( offset ); //restore key
117 117
 
118 118
 		return renderedText;
119 119
 	}
120 120
 
121
-	void CBookDisplay::setupRenderTree(CSwordTreeKey * swordTree, CTextRendering::KeyTree * renderTree, const QString& highlightKey) {
122
-//		const QString key = swordTree->getFullName();
123
-		const QString key = swordTree->key();
121
+	void CBookDisplay::setupRenderTree(CSwordTreeKey * swordTree, CTextRendering::KeyTree * renderTree, const TQString& highlightKey) {
122
+//		const TQString key = swordTree->getFullName();
123
+		const TQString key = swordTree->key();
124 124
 		const unsigned long offset = swordTree->getOffset();
125 125
 
126 126
 		CTextRendering::KeyTreeItem::Settings settings;

+ 2
- 2
bibletime/backend/cbookdisplay.h View File

@@ -35,10 +35,10 @@ public: // Public methods
35 35
 		* Returns the rendered text using the modules in the list and using the key parameter.
36 36
 		* The displayoptions and filter options are used, too.
37 37
 		*/
38
-		virtual const QString text( const ListCSwordModuleInfo& modules, const QString& key, const CSwordBackend::DisplayOptions displayOptions, const CSwordBackend::FilterOptions filterOptions);
38
+		virtual const TQString text( const ListCSwordModuleInfo& modules, const TQString& key, const CSwordBackend::DisplayOptions displayOptions, const CSwordBackend::FilterOptions filterOptions);
39 39
 
40 40
 protected:
41
-		void setupRenderTree(CSwordTreeKey* swordTree, CTextRendering::KeyTree* renderTree, const QString& highlightKey);
41
+		void setupRenderTree(CSwordTreeKey* swordTree, CTextRendering::KeyTree* renderTree, const TQString& highlightKey);
42 42
 	};
43 43
 };
44 44
 

+ 3
- 3
bibletime/backend/cchapterdisplay.cpp View File

@@ -19,7 +19,7 @@
19 19
 
20 20
 namespace Rendering {
21 21
 
22
-	const QString CChapterDisplay::text( const ListCSwordModuleInfo& modules, const QString& keyName, const CSwordBackend::DisplayOptions displayOptions, const CSwordBackend::FilterOptions filterOptions ) {
22
+	const TQString CChapterDisplay::text( const ListCSwordModuleInfo& modules, const TQString& keyName, const CSwordBackend::DisplayOptions displayOptions, const CSwordBackend::FilterOptions filterOptions ) {
23 23
 		Q_ASSERT( modules.count() >= 1 );
24 24
 		Q_ASSERT( !keyName.isEmpty() );
25 25
 
@@ -33,8 +33,8 @@ namespace Rendering {
33 33
 			? CTextRendering::KeyTreeItem::Settings::SimpleKey
34 34
 			: CTextRendering::KeyTreeItem::Settings::NoKey;
35 35
 
36
-		QString startKey = keyName;
37
-		QString endKey = startKey;
36
+		TQString startKey = keyName;
37
+		TQString endKey = startKey;
38 38
 
39 39
 		//check whether there's an intro we have to include
40 40
 		Q_ASSERT((module->type() == CSwordModuleInfo::Bible));

+ 1
- 1
bibletime/backend/cchapterdisplay.h View File

@@ -31,7 +31,7 @@ public: // Public methods
31 31
 	* Returns the rendered text using the modules in the list and using the key parameter.
32 32
 	* The displayoptions and filter options are used, too.
33 33
 	*/
34
-	virtual const QString text( const ListCSwordModuleInfo& modules, const QString& key, const CSwordBackend::DisplayOptions displayOptions, const CSwordBackend::FilterOptions filterOptions);
34
+	virtual const TQString text( const ListCSwordModuleInfo& modules, const TQString& key, const CSwordBackend::DisplayOptions displayOptions, const CSwordBackend::FilterOptions filterOptions);
35 35
 };
36 36
 
37 37
 };

+ 21
- 21
bibletime/backend/cdisplayrendering.cpp View File

@@ -19,16 +19,16 @@
19 19
 #include "cswordversekey.h"
20 20
 
21 21
 //Qt includes
22
-#include <qstring.h>
23
-#include <qregexp.h>
22
+#include <tqstring.h>
23
+#include <tqregexp.h>
24 24
 
25 25
 namespace Rendering {
26 26
 
27 27
 	CDisplayRendering::CDisplayRendering(CSwordBackend::DisplayOptions displayOptions, CSwordBackend::FilterOptions filterOptions)
28 28
 : CHTMLExportRendering(CHTMLExportRendering::Settings(true), displayOptions, filterOptions) {}
29 29
 
30
-	const QString CDisplayRendering::entryLink( const KeyTreeItem& item, CSwordModuleInfo*  module ) {
31
-		QString linkText;
30
+	const TQString CDisplayRendering::entryLink( const KeyTreeItem& item, CSwordModuleInfo*  module ) {
31
+		TQString linkText;
32 32
 
33 33
 		const bool isBible = module && (module->type() == CSwordModuleInfo::Bible);
34 34
 		CSwordVerseKey vk(module); //only valid for bible modules, i.e. isBible == true
@@ -39,19 +39,19 @@ namespace Rendering {
39 39
 		}
40 40
 
41 41
 		if (isBible && (vk.Verse() == 0)) {
42
-			return QString::null; //Warning: return already here
42
+			return TQString::null; //Warning: return already here
43 43
 		}
44 44
 
45 45
 		switch (item.settings().keyRenderingFace) {
46 46
 
47 47
 			case KeyTreeItem::Settings::NoKey: {
48
-				linkText = QString::null;
48
+				linkText = TQString::null;
49 49
 				break; //no key is valid for all modules
50 50
 			}
51 51
 
52 52
 			case KeyTreeItem::Settings::CompleteShort: {
53 53
 				if (isBible) {
54
-					linkText = QString::fromUtf8(vk.getShortText());
54
+					linkText = TQString::fromUtf8(vk.getShortText());
55 55
 					break;
56 56
 				}
57 57
 
@@ -69,7 +69,7 @@ namespace Rendering {
69 69
 
70 70
 			case KeyTreeItem::Settings::SimpleKey: {
71 71
 				if (isBible) {
72
-					linkText = QString::number(vk.Verse());
72
+					linkText = TQString::number(vk.Verse());
73 73
 					break;
74 74
 				}
75 75
 
@@ -83,10 +83,10 @@ namespace Rendering {
83 83
 		}
84 84
 
85 85
 		if (linkText.isEmpty()) {
86
-			return QString("<a name=\"").append(keyToHTMLAnchor(item.key())).append("\" />");
86
+			return TQString("<a name=\"").append(keyToHTMLAnchor(item.key())).append("\" />");
87 87
 		}
88 88
 		else {
89
-			return QString("<a name=\"").append(keyToHTMLAnchor(item.key())).append("\" ")
89
+			return TQString("<a name=\"").append(keyToHTMLAnchor(item.key())).append("\" ")
90 90
 				   .append("href=\"")
91 91
 				   .append(CReferenceManager::encodeHyperlink(
92 92
 							   module->name(), item.key(), CReferenceManager::typeFromModule(module->type()))
@@ -94,18 +94,18 @@ namespace Rendering {
94 94
 				   .append("\">").append(linkText).append("</a>\n");
95 95
 		}
96 96
 
97
-		return QString::null;
97
+		return TQString::null;
98 98
 	}
99 99
 
100
-	const QString CDisplayRendering::keyToHTMLAnchor(const QString& key) {
101
-		QString ret = key;
102
-		ret = ret.stripWhiteSpace().remove(QRegExp("[^A-Za-z0-9]+"));
103
-		ret = ret.remove(QRegExp("^\\d+|"));
100
+	const TQString CDisplayRendering::keyToHTMLAnchor(const TQString& key) {
101
+		TQString ret = key;
102
+		ret = ret.stripWhiteSpace().remove(TQRegExp("[^A-Za-z0-9]+"));
103
+		ret = ret.remove(TQRegExp("^\\d+|"));
104 104
 
105 105
 		return ret;
106 106
 	}
107 107
 
108
-	const QString CDisplayRendering::finishText( const QString& oldText, KeyTree& tree ) {
108
+	const TQString CDisplayRendering::finishText( const TQString& oldText, KeyTree& tree ) {
109 109
 		ListCSwordModuleInfo modules = tree.collectModules();
110 110
 
111 111
 
@@ -114,9 +114,9 @@ namespace Rendering {
114 114
 		/*
115 115
 		 //mark all words by spans
116 116
 
117
-		 QString text = oldText;
117
+		 TQString text = oldText;
118 118
 
119
-		 QRegExp re("(\\b)(?=\\w)"); //word begin marker
119
+		 TQRegExp re("(\\b)(?=\\w)"); //word begin marker
120 120
 		 int pos = text.find(re, 0);
121 121
 
122 122
 		 while (pos != -1) { //word begin found
@@ -126,7 +126,7 @@ namespace Rendering {
126 126
 		   //qWarning("matched %s", text.mid(pos+1, 4).latin1());
127 127
 
128 128
 		   //find end of word and put a marker around it
129
-		   endPos = text.find(QRegExp("\\b|[,.:]"), pos+1);
129
+		   endPos = text.find(TQRegExp("\\b|[,.:]"), pos+1);
130 130
 		   if ((endPos != -1) && !CToolClass::inHTMLTag(endPos, text) && (endPos - pos >= 3)) { //reuire wordslonger than 3 chars
131 131
 		    text.insert(endPos, "</span>");
132 132
 		    text.insert(pos, "<span class=\"word\">");
@@ -150,10 +150,10 @@ namespace Rendering {
150 150
 		settings.modules = modules;
151 151
 		settings.langAbbrev = ((modules.count() == 1) && lang->isValid())
152 152
 							  ? lang->abbrev()
153
-							  : QString::null;
153
+							  : TQString::null;
154 154
 		settings.pageDirection = (modules.count() == 1)
155 155
 								 ? ((modules.first()->textDirection() == CSwordModuleInfo::LeftToRight) ? "ltr"  : "rtl")
156
-						 : QString::null;
156
+						 : TQString::null;
157 157
 
158 158
 		return tMgr->fillTemplate(CBTConfig::get
159 159
 									  (CBTConfig::displayStyle), oldText, settings);

+ 3
- 3
bibletime/backend/cdisplayrendering.h View File

@@ -23,7 +23,7 @@ namespace Rendering {
23 23
 
24 24
 class CDisplayRendering : public CHTMLExportRendering {
25 25
 public:
26
-	static const QString keyToHTMLAnchor(const QString& key);
26
+	static const TQString keyToHTMLAnchor(const TQString& key);
27 27
 
28 28
 	CDisplayRendering(
29 29
 		CSwordBackend::DisplayOptions displayOptions = CBTConfig::getDisplayOptionDefaults(),
@@ -31,8 +31,8 @@ public:
31 31
 	);
32 32
 
33 33
 protected:
34
-	virtual const QString entryLink( const KeyTreeItem& item, CSwordModuleInfo* const module );
35
-	virtual const QString finishText( const QString&, KeyTree& tree );
34
+	virtual const TQString entryLink( const KeyTreeItem& item, CSwordModuleInfo* const module );
35
+	virtual const TQString finishText( const TQString&, KeyTree& tree );
36 36
 };
37 37
 
38 38
 }

+ 26
- 26
bibletime/backend/cdisplaytemplatemgr.cpp View File

@@ -22,9 +22,9 @@
22 22
 #include "config.h"
23 23
 
24 24
 //Qt includes
25
-#include <qstringlist.h>
26
-#include <qfile.h>
27
-#include <qfileinfo.h>
25
+#include <tqstringlist.h>
26
+#include <tqfile.h>
27
+#include <tqfileinfo.h>
28 28
 
29 29
 //KDE includes
30 30
 #include <klocale.h>
@@ -41,12 +41,12 @@ CDisplayTemplateMgr::~CDisplayTemplateMgr() {}
41 41
 
42 42
 
43 43
 /*!
44
-    \fn CDisplayTemplateMgr::fillTemplate( const QString& name, const QString& title, const QString& content )
44
+    \fn CDisplayTemplateMgr::fillTemplate( const TQString& name, const TQString& title, const TQString& content )
45 45
  */
46
-const QString CDisplayTemplateMgr::fillTemplate( const QString& name, const QString& content, Settings& settings ) {
47
-	const QString templateName = m_templateMap.contains(name) ? name : defaultTemplate();
46
+const TQString CDisplayTemplateMgr::fillTemplate( const TQString& name, const TQString& content, Settings& settings ) {
47
+	const TQString templateName = m_templateMap.contains(name) ? name : defaultTemplate();
48 48
 
49
-	QString displayTypeString;
49
+	TQString displayTypeString;
50 50
 
51 51
 	if (!settings.pageCSS_ID.isEmpty()) {
52 52
 		displayTypeString = settings.pageCSS_ID;
@@ -77,18 +77,18 @@ const QString CDisplayTemplateMgr::fillTemplate( const QString& name, const QStr
77 77
 		};
78 78
 	}
79 79
 
80
-	QString newContent = content;
80
+	TQString newContent = content;
81 81
 	const int moduleCount = settings.modules.count();
82 82
 
83 83
 	if (moduleCount >= 2) {
84 84
 		//create header for the modules
85
-		QString header;
85
+		TQString header;
86 86
 
87 87
 		ListCSwordModuleInfo::iterator end_it = settings.modules.end();
88 88
 
89 89
 		for (ListCSwordModuleInfo::iterator it(settings.modules.begin()); it != end_it; ++it) {
90 90
 			header.append("<th style=\"width:")
91
-			.append(QString::number(int( 100.0 / (float)moduleCount )))
91
+			.append(TQString::number(int( 100.0 / (float)moduleCount )))
92 92
 			.append("%;\">")
93 93
 			.append((*it)->name())
94 94
 			.append("</th>");
@@ -101,7 +101,7 @@ const QString CDisplayTemplateMgr::fillTemplate( const QString& name, const QStr
101 101
 		.append("</table>");
102 102
 	}
103 103
 
104
-	QString langCSS;
104
+	TQString langCSS;
105 105
 	CLanguageMgr::LangMap langMap = CPointers::languageMgr()->availableLanguages();
106 106
 
107 107
 	for ( CLanguageMgr::LangMapIterator it( langMap ); it.current(); ++it ) {
@@ -110,18 +110,18 @@ const QString CDisplayTemplateMgr::fillTemplate( const QString& name, const QStr
110 110
 
111 111
 		//if (lang->isValid() && CBTConfig::get(lang).first) {
112 112
 		if (!lang->abbrev().isEmpty() && CBTConfig::get(lang).first) {
113
-			const QFont f = CBTConfig::get(lang).second;
113
+			const TQFont f = CBTConfig::get(lang).second;
114 114
 
115 115
 			//don't use important, because it would reset the title formatting, etc. to the setup font
116
-			QString css("{ ");
116
+			TQString css("{ ");
117 117
 			css.append("font-family:").append(f.family())/*.append(" !important")*/;
118
-			css.append("; font-size:").append(QString::number(f.pointSize())).append("pt /*!important*/");
118
+			css.append("; font-size:").append(TQString::number(f.pointSize())).append("pt /*!important*/");
119 119
 			css.append("; font-weight:").append(f.bold() ? "bold" : "normal /*!important*/");
120 120
 			css.append("; font-style:").append(f.italic() ? "italic" : "normal /*!important*/");
121 121
 			css.append("; }\n");
122 122
 
123 123
 			langCSS +=
124
-				QString("\n*[lang=%1] %2")
124
+				TQString("\n*[lang=%1] %2")
125 125
 				.arg(lang->abbrev())
126 126
 				.arg(css);
127 127
 		}
@@ -133,9 +133,9 @@ const QString CDisplayTemplateMgr::fillTemplate( const QString& name, const QStr
133 133
 	const CLanguageMgr::Language* lang = it.current();
134 134
 
135 135
 	if (lang && !lang->abbrev().isEmpty()/*&& lang->isValid()*/) {
136
-		const QFont standardFont = CBTConfig::getDefault(lang); //we just need a dummy lang param
136
+		const TQFont standardFont = CBTConfig::getDefault(lang); //we just need a dummy lang param
137 137
 		langCSS.prepend(
138
-			QString("\n#content {font-family:%1; font-size:%2pt; font-weight:%3; font-style: %4;}\n")
138
+			TQString("\n#content {font-family:%1; font-size:%2pt; font-weight:%3; font-style: %4;}\n")
139 139
 			.arg(standardFont.family())
140 140
 			.arg(standardFont.pointSize())
141 141
 			.arg(standardFont.bold() ? "bold" : "normal")
@@ -144,9 +144,9 @@ const QString CDisplayTemplateMgr::fillTemplate( const QString& name, const QStr
144 144
 	}
145 145
 
146 146
 // 	qWarning("Outputing unformated text");
147
-	const QString t = QString(m_templateMap[ templateName ]) //don't change the map's content directly, use  a copy
147
+	const TQString t = TQString(m_templateMap[ templateName ]) //don't change the map's content directly, use  a copy
148 148
 	 		.replace("#TITLE#", settings.title)
149
-	 		.replace("#LANG_ABBREV#", settings.langAbbrev.isEmpty() ? QString("en") : settings.langAbbrev)
149
+	 		.replace("#LANG_ABBREV#", settings.langAbbrev.isEmpty() ? TQString("en") : settings.langAbbrev)
150 150
 	 		.replace("#DISPLAYTYPE#", displayTypeString)
151 151
 	 		.replace("#LANG_CSS#", langCSS)
152 152
 	 		.replace("#PAGE_DIRECTION#", settings.pageDirection)
@@ -154,9 +154,9 @@ const QString CDisplayTemplateMgr::fillTemplate( const QString& name, const QStr
154 154
  	 //printf("%s\n\n", t.latin1());
155 155
 
156 156
 	return t;
157
-/*			QString(m_templateMap[ templateName ]) //don't change the map's content directly, use  a copy
157
+/*			TQString(m_templateMap[ templateName ]) //don't change the map's content directly, use  a copy
158 158
 		   .replace("#TITLE#", settings.title)
159
-		   .replace("#LANG_ABBREV#", settings.langAbbrev.isEmpty() ? QString("en") : settings.langAbbrev)
159
+		   .replace("#LANG_ABBREV#", settings.langAbbrev.isEmpty() ? TQString("en") : settings.langAbbrev)
160 160
 		   .replace("#DISPLAYTYPE#", displayTypeString)
161 161
 		   .replace("#LANG_CSS#", langCSS)
162 162
 		   .replace("#PAGE_DIRECTION#", settings.pageDirection)
@@ -169,19 +169,19 @@ const QString CDisplayTemplateMgr::fillTemplate( const QString& name, const QStr
169 169
  */
170 170
 void CDisplayTemplateMgr::loadUserTemplates() {
171 171
 	qDebug("Loading user templates");
172
-	QStringList files = KGlobal::dirs()->findAllResources("BT_DisplayTemplates");
172
+	TQStringList files = KGlobal::dirs()->findAllResources("BT_DisplayTemplates");
173 173
 
174
-	for ( QStringList::iterator it( files.begin() ); it != files.end(); ++it) {
174
+	for ( TQStringList::iterator it( files.begin() ); it != files.end(); ++it) {
175 175
 		qDebug("Found user template %s", (*it).latin1());
176 176
 
177
-		QFile f( *it );
177
+		TQFile f( *it );
178 178
 		Q_ASSERT( f.exists() );
179 179
 
180 180
 		if (f.open( IO_ReadOnly )) {
181
-			QString fileContent = QTextStream( &f ).read();
181
+			TQString fileContent = TQTextStream( &f ).read();
182 182
 
183 183
 			if (!fileContent.isEmpty()) {
184
-				m_templateMap[ QFileInfo(*it).fileName() + QString(" ") + i18n("(user template)")] = fileContent;
184
+				m_templateMap[ TQFileInfo(*it).fileName() + TQString(" ") + i18n("(user template)")] = fileContent;
185 185
 			}
186 186
 		}
187 187
 	}

+ 17
- 17
bibletime/backend/cdisplaytemplatemgr.h View File

@@ -16,9 +16,9 @@
16 16
 #include "cswordmoduleinfo.h"
17 17
 
18 18
 //Qt includes
19
-#include <qmap.h>
20
-#include <qstring.h>
21
-#include <qstringlist.h>
19
+#include <tqmap.h>
20
+#include <tqstring.h>
21
+#include <tqstringlist.h>
22 22
 
23 23
 //KDE includes
24 24
 #include <klocale.h>
@@ -38,34 +38,34 @@ public:
38 38
         /** Constructor. Constructs the new settings object. The default values are empty.
39 39
          */
40 40
         Settings() {
41
-            title = QString::null;
42
-            langAbbrev = QString::null;
43
-            pageCSS_ID = QString::null;
44
-            pageDirection = QString("ltr");
41
+            title = TQString::null;
42
+            langAbbrev = TQString::null;
43
+            pageCSS_ID = TQString::null;
44
+            pageDirection = TQString("ltr");
45 45
         };
46 46
 
47 47
         ListCSwordModuleInfo modules; /**< the list of modules */
48
-        QString title; /**< the title which is used for the new processed HTML page */
49
-        QString langAbbrev; /**< the language for the HTML page. */
50
-        QString pageDirection; /**< the language for the HTML page. */
51
-        QString pageCSS_ID; /**< the CSS ID which is used in the content part of the page */
48
+        TQString title; /**< the title which is used for the new processed HTML page */
49
+        TQString langAbbrev; /**< the language for the HTML page. */
50
+        TQString pageDirection; /**< the language for the HTML page. */
51
+        TQString pageCSS_ID; /**< the CSS ID which is used in the content part of the page */
52 52
     };
53 53
 
54 54
     /** Available templates.
55 55
     * @return The list of templates, which are available.
56 56
     */
57
-    inline const QStringList availableTemplates();
57
+    inline const TQStringList availableTemplates();
58 58
     /** Fill template. Fill rendered content into the template given by the name.
59 59
     * @param name The name of the template
60 60
     * @param content The content which should be filled into the template
61 61
     * @param settings The settings which are used to process the templating process
62 62
     * @return The full HTML template HTML code including the CSS data.
63 63
     */
64
-    const QString fillTemplate( const QString& name, const QString& content, Settings& settings);
64
+    const TQString fillTemplate( const TQString& name, const TQString& content, Settings& settings);
65 65
     /** Default template.
66 66
     * @return The i18n'ed name of the default template
67 67
     */
68
-    inline static const QString defaultTemplate();
68
+    inline static const TQString defaultTemplate();
69 69
 
70 70
 protected:
71 71
 
@@ -81,17 +81,17 @@ protected:
81 81
 
82 82
 private:
83 83
     void init();
84
-    QMap<QString, QString> m_templateMap;
84
+    TQMap<TQString, TQString> m_templateMap;
85 85
 };
86 86
 
87
-inline const QString CDisplayTemplateMgr::defaultTemplate() {
87
+inline const TQString CDisplayTemplateMgr::defaultTemplate() {
88 88
     return i18n("Default");
89 89
 }
90 90
 
91 91
 /**
92 92
  * CDisplayTemplateMgr::availableTemplates()
93 93
  */
94
-inline const QStringList CDisplayTemplateMgr::availableTemplates() {
94
+inline const TQStringList CDisplayTemplateMgr::availableTemplates() {
95 95
     return m_templateMap.keys();
96 96
 }
97 97
 

+ 4
- 4
bibletime/backend/centrydisplay.cpp View File

@@ -24,21 +24,21 @@
24 24
 #include "util/scoped_resource.h"
25 25
 
26 26
 //Qt includes
27
-#include <qapplication.h>
28
-#include <qregexp.h>
27
+#include <tqapplication.h>
28
+#include <tqregexp.h>
29 29
 
30 30
 using namespace Rendering;
31 31
 
32 32
 /** Returns the rendered text using the modules in the list and using the key parameter.
33 33
  * The displayoptions and filter options are used, too. 
34 34
  */
35
-const QString CEntryDisplay::text( const ListCSwordModuleInfo& modules, const QString& keyName, const CSwordBackend::DisplayOptions displayOptions, const CSwordBackend::FilterOptions filterOptions ) {
35
+const TQString CEntryDisplay::text( const ListCSwordModuleInfo& modules, const TQString& keyName, const CSwordBackend::DisplayOptions displayOptions, const CSwordBackend::FilterOptions filterOptions ) {
36 36
 	CDisplayRendering render(displayOptions, filterOptions);
37 37
 
38 38
 	//no highlighted key and no extra key link in the text
39 39
 	CTextRendering::KeyTreeItem::Settings normal_settings(false, CTextRendering::KeyTreeItem::Settings::CompleteShort);
40 40
 	CSwordModuleInfo* module = modules.first();
41
-	QString result;
41
+	TQString result;
42 42
 
43 43
 	//in Bibles and Commentaries we need to check if 0:0 and X:0 contain something
44 44
 	if (module->type() == CSwordModuleInfo::Bible || module->type() == CSwordModuleInfo::Commentary) {

+ 2
- 2
bibletime/backend/centrydisplay.h View File

@@ -23,7 +23,7 @@
23 23
 #include <swdisp.h>
24 24
 
25 25
 //Qt includes
26
-#include <qstring.h>
26
+#include <tqstring.h>
27 27
 
28 28
 class CSwordModuleInfo;
29 29
 
@@ -44,7 +44,7 @@ public:
44 44
 	* Returns the rendered text using the modules in the list and using the key parameter.
45 45
 	* The displayoptions and filter options are used, too.
46 46
 	*/
47
-	virtual const QString text( const ListCSwordModuleInfo& modules, const QString& key, const CSwordBackend::DisplayOptions displayOptions, const CSwordBackend::FilterOptions filterOptions);
47
+	virtual const TQString text( const ListCSwordModuleInfo& modules, const TQString& key, const CSwordBackend::DisplayOptions displayOptions, const CSwordBackend::FilterOptions filterOptions);
48 48
 };
49 49
 
50 50
 

+ 16
- 16
bibletime/backend/chtmlexportrendering.cpp View File

@@ -35,11 +35,11 @@ namespace Rendering {
35 35
 
36 36
 	CHTMLExportRendering::~CHTMLExportRendering() {}
37 37
 
38
-	const QString CHTMLExportRendering::renderEntry( const KeyTreeItem& i, CSwordKey* k) {
38
+	const TQString CHTMLExportRendering::renderEntry( const KeyTreeItem& i, CSwordKey* k) {
39 39
 		//  qDebug("CHTMLExportRendering::renderEntry");
40 40
 
41 41
 		if (i.hasAlternativeContent()) {
42
-			QString ret;
42
+			TQString ret;
43 43
 			ret.setLatin1(i.settings().highlight ? "<div class=\"currententry\">" : "<div class=\"entry\">");
44 44
 			ret.append(i.getAlternativeContent());
45 45
 
@@ -51,7 +51,7 @@ namespace Rendering {
51 51
 				const ListCSwordModuleInfo& modules( tree->collectModules() );
52 52
 
53 53
 				if (modules.count() == 1) { //insert the direction into the sorrounding div
54
-					ret.insert( 5, QString("dir=\"%1\" ").arg((modules.first()->textDirection() == CSwordModuleInfo::LeftToRight) ? "ltr" : "rtl" ));
54
+					ret.insert( 5, TQString("dir=\"%1\" ").arg((modules.first()->textDirection() == CSwordModuleInfo::LeftToRight) ? "ltr" : "rtl" ));
55 55
 				}
56 56
 
57 57
 				for ( KeyTreeItem* c = tree->first(); c; c = tree->next() ) {
@@ -80,26 +80,26 @@ namespace Rendering {
80 80
 			myVK->Headings(1);
81 81
 		}
82 82
 
83
-		QString renderedText( (modules.count() > 1) ? "<tr>" : "" );
83
+		TQString renderedText( (modules.count() > 1) ? "<tr>" : "" );
84 84
 
85 85
 		if (modules.count() == 0) {
86
-			return QString(""); //no module present for rendering
86
+			return TQString(""); //no module present for rendering
87 87
 		}
88 88
 
89 89
 		// Only insert the table stuff if we are displaying parallel.
90 90
 		// Otherwise, strip out he table stuff -> the whole chapter will be rendered in one cell!
91 91
 
92 92
 		//declarations out of the loop for optimization
93
-		QString entry;
93
+		TQString entry;
94 94
 
95
-		QString keyText;
95
+		TQString keyText;
96 96
 
97 97
 		bool isRTL;
98 98
 
99 99
 		//taken out of the loop for optimization
100
-		QString preverseHeading;
100
+		TQString preverseHeading;
101 101
 
102
-		QString langAttr;
102
+		TQString langAttr;
103 103
 
104 104
 		ListCSwordModuleInfo::const_iterator end_modItr = modules.end();
105 105
 
@@ -109,7 +109,7 @@ namespace Rendering {
109 109
 
110 110
 			keyText = key->key();
111 111
 			isRTL = ((*mod_Itr)->textDirection() == CSwordModuleInfo::RightToLeft);
112
-			entry = QString::null;
112
+			entry = TQString::null;
113 113
 
114 114
 			if ((*mod_Itr)->language()->isValid()) {
115 115
 				langAttr.setLatin1("xml:lang=\"")
@@ -126,7 +126,7 @@ namespace Rendering {
126 126
 				.append("\"");
127 127
 			}
128 128
 
129
-			const QString key_renderedText = key->renderedText();
129
+			const TQString key_renderedText = key->renderedText();
130 130
 
131 131
 			//   qWarning(key_renderedText.latin1());
132 132
 
@@ -137,7 +137,7 @@ namespace Rendering {
137 137
 					(*mod_Itr)->module()->getEntryAttributes()["Heading"]["Preverse"].end();
138 138
 
139 139
 				for (; it != end; ++it) {
140
-					preverseHeading = QString::fromUtf8(it->second.c_str());
140
+					preverseHeading = TQString::fromUtf8(it->second.c_str());
141 141
 
142 142
 					//TODO: Take care of the heading type!
143 143
 
@@ -163,7 +163,7 @@ namespace Rendering {
163 163
 			entry.append("<span class=\"entryname\" dir=\"ltr\">").append(entryLink(i, *mod_Itr)).append("</span>");
164 164
 
165 165
 			if (m_settings.addText) {
166
-				//entry.append( QString::fromLatin1("<span %1>%2</span>").arg(langAttr).arg(key_renderedText) );
166
+				//entry.append( TQString::fromLatin1("<span %1>%2</span>").arg(langAttr).arg(key_renderedText) );
167 167
 				entry.append( key_renderedText );
168 168
 			}
169 169
 
@@ -206,7 +206,7 @@ namespace Rendering {
206 206
 		CPointers::backend()->setFilterOptions( m_filterOptions );
207 207
 	}
208 208
 
209
-	const QString CHTMLExportRendering::finishText( const QString& text, KeyTree& tree ) {
209
+	const TQString CHTMLExportRendering::finishText( const TQString& text, KeyTree& tree ) {
210 210
 		ListCSwordModuleInfo modules = tree.collectModules();
211 211
 
212 212
 		const CLanguageMgr::Language* const lang = modules.first()->language();
@@ -219,7 +219,7 @@ namespace Rendering {
219 219
 							  : "unknown";
220 220
 		settings.pageDirection = (modules.count() == 1)
221 221
 								 ? ((modules.first()->textDirection() == CSwordModuleInfo::LeftToRight) ? "ltr"  : "rtl")
222
-						 : QString::null;
222
+						 : TQString::null;
223 223
 
224 224
 		return tMgr->fillTemplate(i18n("Export"), text, settings);
225 225
 	}
@@ -227,7 +227,7 @@ namespace Rendering {
227 227
 	/*!
228 228
 	    \fn CHTMLExportRendering::entryLink( KeyTreeItem& item )
229 229
 	 */
230
-	const QString CHTMLExportRendering::entryLink( const KeyTreeItem& item, CSwordModuleInfo* ) {
230
+	const TQString CHTMLExportRendering::entryLink( const KeyTreeItem& item, CSwordModuleInfo* ) {
231 231
 		return item.key();
232 232
 	}
233 233
 

+ 3
- 3
bibletime/backend/chtmlexportrendering.h View File

@@ -45,9 +45,9 @@ public:
45 45
 	virtual ~CHTMLExportRendering();
46 46
 
47 47
 protected:
48
-	virtual const QString renderEntry( const KeyTreeItem&, CSwordKey* = 0 );
49
-	virtual const QString finishText( const QString&, KeyTree& tree );
50
-	virtual const QString entryLink( const KeyTreeItem& item, CSwordModuleInfo* module );
48
+	virtual const TQString renderEntry( const KeyTreeItem&, CSwordKey* = 0 );
49
+	virtual const TQString finishText( const TQString&, KeyTree& tree );
50
+	virtual const TQString entryLink( const KeyTreeItem& item, CSwordModuleInfo* module );
51 51
 	virtual void initRendering();
52 52
 
53 53
 	CSwordBackend::DisplayOptions m_displayOptions;

+ 13
- 13
bibletime/backend/clanguagemgr.cpp View File

@@ -18,7 +18,7 @@
18 18
 
19 19
 
20 20
 //Qt includes
21
-#include <qptrlist.h>
21
+#include <tqptrlist.h>
22 22
 
23 23
 //KDE includes
24 24
 #include <klocale.h>
@@ -28,9 +28,9 @@ CLanguageMgr::LanguageList CLanguageMgr::m_langList;
28 28
 CLanguageMgr::LanguageList CLanguageMgr::m_cleanupLangPtrs;
29 29
 
30 30
 CLanguageMgr::Language::Language() : m_altAbbrevs(0) {
31
-	m_abbrev = QString::null;
32
-	m_englishName = QString::null;
33
-	m_translatedName = QString::null;
31
+	m_abbrev = TQString::null;
32
+	m_englishName = TQString::null;
33
+	m_translatedName = TQString::null;
34 34
 };
35 35
 
36 36
 CLanguageMgr::Language::Language(const Language& l) {
@@ -39,7 +39,7 @@ CLanguageMgr::Language::Language(const Language& l) {
39 39
 	m_translatedName = l.m_translatedName;
40 40
 
41 41
 	if (l.m_altAbbrevs) { //copy alternative abbrevs in a new list
42
-		m_altAbbrevs = new QStringList(*l.m_altAbbrevs);
42
+		m_altAbbrevs = new TQStringList(*l.m_altAbbrevs);
43 43
 		//*m_altAbbrevs = *l.m_altAbbrevs;
44 44
 	}
45 45
 	else {
@@ -47,13 +47,13 @@ CLanguageMgr::Language::Language(const Language& l) {
47 47
 	}
48 48
 }
49 49
 
50
-CLanguageMgr::Language::Language( const QString& abbrev, const QString& name, const QString& translatedName, const QStringList& altAbbrevs ) : m_altAbbrevs(0) {
50
+CLanguageMgr::Language::Language( const TQString& abbrev, const TQString& name, const TQString& translatedName, const TQStringList& altAbbrevs ) : m_altAbbrevs(0) {
51 51
 	m_abbrev = abbrev;
52 52
 	m_englishName = name;
53 53
 	m_translatedName = translatedName;
54 54
 
55 55
 	if (altAbbrevs.count() > 0) {
56
-		m_altAbbrevs = new QStringList();
56
+		m_altAbbrevs = new TQStringList();
57 57
 		*m_altAbbrevs = altAbbrevs;
58 58
 	}
59 59
 };
@@ -88,7 +88,7 @@ const CLanguageMgr::LangMap& CLanguageMgr::availableLanguages() {
88 88
 		m_availableModulesCache.moduleCount = mods.count();
89 89
 
90 90
 		//collect the languages abbrevs of all modules
91
-		QStrList abbrevs;
91
+		TQStrList abbrevs;
92 92
 		char *abbrev;
93 93
 
94 94
 		ListCSwordModuleInfo::iterator end_it = mods.end();
@@ -121,7 +121,7 @@ const CLanguageMgr::LangMap& CLanguageMgr::availableLanguages() {
121 121
 	return m_availableModulesCache.availableLanguages;
122 122
 };
123 123
 
124
-const CLanguageMgr::Language* const CLanguageMgr::languageForAbbrev( const QString& abbrev ) const {
124
+const CLanguageMgr::Language* const CLanguageMgr::languageForAbbrev( const TQString& abbrev ) const {
125 125
 	Language* lang = m_langMap.find(abbrev);
126 126
 
127 127
 	if (lang) {
@@ -143,7 +143,7 @@ const CLanguageMgr::Language* const CLanguageMgr::languageForAbbrev( const QStri
143 143
 	return newLang;
144 144
 };
145 145
 
146
-const CLanguageMgr::Language* const CLanguageMgr::languageForName( const QString& name ) const {
146
+const CLanguageMgr::Language* const CLanguageMgr::languageForName( const TQString& name ) const {
147 147
 	for ( LangMapIterator it( m_langMap ); it.current(); ++it ) {
148 148
 		if (it.current()->name() == name) {
149 149
 			return it.current();
@@ -153,7 +153,7 @@ const CLanguageMgr::Language* const CLanguageMgr::languageForName( const QString
153 153
 	return &m_defaultLanguage;//invalid language
154 154
 };
155 155
 
156
-const CLanguageMgr::Language* const CLanguageMgr::languageForTranslatedName( const QString& name ) const {
156
+const CLanguageMgr::Language* const CLanguageMgr::languageForTranslatedName( const TQString& name ) const {
157 157
 	for ( LangMapIterator it( m_langMap ); it.current(); ++it ) {
158 158
 	if (it.current()->translatedName() == name) {
159 159
 			return it.current();
@@ -464,11 +464,11 @@ void CLanguageMgr::init() {
464 464
 
465 465
 	m_langList.append( new Language("x-E-HAT"  , "Haitian Creole French" , i18n("Haitian Creole French")) );
466 466
 
467
-	m_langList.append( new Language("x-E-ITZ"  , QString::fromUtf8("Itzá")         , i18n("Itzá")) );
467
+	m_langList.append( new Language("x-E-ITZ"  , TQString::fromUtf8("Itzá")         , i18n("Itzá")) );
468 468
 
469 469
 	m_langList.append( new Language("x-E-JIV"  , "Shuar"        , i18n("Shuar")) );
470 470
 
471
-	m_langList.append( new Language("x-E-KEK"  , QString::fromUtf8("Kekchí")       , i18n("Kekchí")) );
471
+	m_langList.append( new Language("x-E-KEK"  , TQString::fromUtf8("Kekchí")       , i18n("Kekchí")) );
472 472
 
473 473
 	m_langList.append( new Language("x-E-KAB"  , "Kabyle"      , i18n("Kabyle")) );
474 474
 

+ 26
- 26
bibletime/backend/clanguagemgr.h View File

@@ -13,11 +13,11 @@
13 13
 #define CLANGUAGEMGR_H
14 14
 
15 15
 //Qt includes
16
-#include <qstring.h>
17
-#include <qstringlist.h>
18
-#include <qvaluelist.h>
19
-#include <qmap.h>
20
-#include <qdict.h>
16
+#include <tqstring.h>
17
+#include <tqstringlist.h>
18
+#include <tqvaluelist.h>
19
+#include <tqmap.h>
20
+#include <tqdict.h>
21 21
 
22 22
 /** Manages the anguages of BibleTime and provides functions to work with them.
23 23
   * @author The BibleTime team
@@ -42,30 +42,30 @@ public:
42 42
 		Language(const Language&);
43 43
 		/** Constructor which takes all necessary data.
44 44
 		*/
45
-		Language(const QString& abbrev, const QString& englishName, const QString& translatedName, const QStringList& altAbbrevs = QStringList());
45
+		Language(const TQString& abbrev, const TQString& englishName, const TQString& translatedName, const TQStringList& altAbbrevs = TQStringList());
46 46
 		/** Destructor.
47 47
 		 */
48 48
 		~Language();
49 49
 		/** Returns the abbreviation.
50 50
 		 * @return The abbreviation of the chosen language.
51 51
 		 */
52
-		inline const QString& abbrev() const;
52
+		inline const TQString& abbrev() const;
53 53
 		/** Returns the translated name.
54 54
 		 * @return The translated name of the language.
55 55
 		 */
56
-		inline const QString& translatedName() const;
56
+		inline const TQString& translatedName() const;
57 57
 		//always define inlines in the header file, or make them not inline.
58 58
 		/** The english name of the language.
59 59
 		 * @return The english name of the chosen language.
60 60
 		 */
61
-		inline const QString& name() const {
61
+		inline const TQString& name() const {
62 62
 			return m_englishName;
63 63
 		}
64 64
 
65 65
 		/** The alternative abbreviations which are avalable for this language.
66 66
 		 * @return A pointer to the list of alternate abbreviations
67 67
 		 */
68
-		inline const QStringList* const alternativeAbbrevs() const {
68
+		inline const TQStringList* const alternativeAbbrevs() const {
69 69
 			return m_altAbbrevs;
70 70
 		};
71 71
 
@@ -76,16 +76,16 @@ public:
76 76
 		inline const bool isValid() const;
77 77
 
78 78
 	private:
79
-		QString m_abbrev;
80
-		QString m_englishName;
81
-		QString m_translatedName;
82
-		QStringList* m_altAbbrevs;
79
+		TQString m_abbrev;
80
+		TQString m_englishName;
81
+		TQString m_translatedName;
82
+		TQStringList* m_altAbbrevs;
83 83
 	};
84 84
 
85
-	typedef QPtrList<CLanguageMgr::Language> LanguageList;
85
+	typedef TQPtrList<CLanguageMgr::Language> LanguageList;
86 86
 
87
-	typedef QDict<Language> LangMap;
88
-	typedef QDictIterator<Language> LangMapIterator;
87
+	typedef TQDict<Language> LangMap;
88
+	typedef TQDictIterator<Language> LangMapIterator;
89 89
 
90 90
 	/** Constructor.
91 91
 	*/
@@ -95,7 +95,7 @@ public:
95 95
 	virtual ~CLanguageMgr();
96 96
 	/**
97 97
 	* Returns the standard languages available as standard. Does nothing for Sword.
98
-	* @return A QDict<Language> map which contains all known languages
98
+	* @return A TQDict<Language> map which contains all known languages
99 99
 	*/
100 100
 	inline const CLanguageMgr::LangMap* const languages() const;
101 101
 	/**
@@ -107,17 +107,17 @@ public:
107 107
 	* @param abbrev The language abbreviation
108 108
 	* @return Pointer to a language for the given string abbreviation.
109 109
 	*/
110
-	const CLanguageMgr::Language* const languageForAbbrev( const QString& abbrev ) const;
110
+	const CLanguageMgr::Language* const languageForAbbrev( const TQString& abbrev ) const;
111 111
 	/** Language for english name.
112 112
 	* @param abbrev The english language name.
113 113
 	* @return Pointer to a language for the given name
114 114
 	*/
115
-	const CLanguageMgr::Language* const languageForName( const QString& language ) const;
115
+	const CLanguageMgr::Language* const languageForName( const TQString& language ) const;
116 116
 	/** Language for translated language name.
117 117
 	* @param abbrev The translated language name
118 118
 	* @return Pointer to a language for the given translated language name
119 119
 	*/
120
-	const CLanguageMgr::Language* const languageForTranslatedName( const QString& language ) const;
120
+	const CLanguageMgr::Language* const languageForTranslatedName( const TQString& language ) const;
121 121
 	/** Default language so we don't return NULL pointers.
122 122
 	* @return Pointer to the default language
123 123
 	*/
@@ -125,14 +125,14 @@ public:
125 125
 
126 126
 private:
127 127
 	void init();
128
-	inline const QStringList makeStringList(const QString& abbrevs) {
129
-		return QStringList::split( ";", abbrevs, false );
128
+	inline const TQStringList makeStringList(const TQString& abbrevs) {
129
+		return TQStringList::split( ";", abbrevs, false );
130 130
 	}
131 131
 
132 132
 	mutable LangMap m_langMap;
133 133
 	Language m_defaultLanguage;
134 134
 
135
-	//typedef QPtrList<CLanguageMgr::Language> LanguageList;
135
+	//typedef TQPtrList<CLanguageMgr::Language> LanguageList;
136 136
 	static LanguageList m_langList;
137 137
 	static LanguageList m_cleanupLangPtrs;
138 138
 
@@ -149,7 +149,7 @@ inline const bool CLanguageMgr::Language::isValid() const {
149 149
 	return (!abbrev().isEmpty() && !name().isEmpty());
150 150
 }
151 151
 
152
-inline const QString& CLanguageMgr::Language::abbrev() const {
152
+inline const TQString& CLanguageMgr::Language::abbrev() const {
153 153
 	if (m_altAbbrevs && m_abbrev.isEmpty() && m_altAbbrevs->count()) { //no standard abbrev but alternative ones
154 154
 		return m_altAbbrevs->first();
155 155
 	}
@@ -157,7 +157,7 @@ inline const QString& CLanguageMgr::Language::abbrev() const {
157 157
 	return m_abbrev;
158 158
 }
159 159
 
160
-inline const QString& CLanguageMgr::Language::translatedName() const {
160
+inline const TQString& CLanguageMgr::Language::translatedName() const {
161 161
 	return m_translatedName;
162 162
 }
163 163
 

+ 5
- 5
bibletime/backend/cplaintextexportrendering.cpp View File

@@ -26,16 +26,16 @@ namespace Rendering {
26 26
 
27 27
 	CPlainTextExportRendering::~CPlainTextExportRendering() {}
28 28
 
29
-	const QString CPlainTextExportRendering::renderEntry( const KeyTreeItem& i, CSwordKey*  ) {
29
+	const TQString CPlainTextExportRendering::renderEntry( const KeyTreeItem& i, CSwordKey*  ) {
30 30
 		if (!m_settings.addText) {
31
-			return QString(i.key()).append("\n");
31
+			return TQString(i.key()).append("\n");
32 32
 		}
33 33
 
34 34
 		ListCSwordModuleInfo modules = i.modules();
35 35
 		util::scoped_ptr<CSwordKey> key( CSwordKey::createInstance(modules.first()) );
36
-		QString renderedText = QString(i.key()).append(":\n");
36
+		TQString renderedText = TQString(i.key()).append(":\n");
37 37
 
38
-		QString entry;
38
+		TQString entry;
39 39
 		//   for (CSwordModuleInfo* m = modules.first(); m; m = modules.next()) {
40 40
 		ListCSwordModuleInfo::iterator end_it = modules.end();
41 41
 
@@ -51,7 +51,7 @@ namespace Rendering {
51 51
 		return renderedText;
52 52
 	}
53 53
 
54
-	const QString CPlainTextExportRendering::finishText( const QString& oldText, KeyTree& ) {
54
+	const TQString CPlainTextExportRendering::finishText( const TQString& oldText, KeyTree& ) {
55 55
 		return oldText;
56 56
 	}
57 57
 

+ 2
- 2
bibletime/backend/cplaintextexportrendering.h View File

@@ -33,8 +33,8 @@ public:
33 33
 		virtual ~CPlainTextExportRendering();
34 34
 
35 35
 protected:
36
-		virtual const QString renderEntry( const KeyTreeItem&, CSwordKey* = 0 );
37
-		virtual const QString finishText( const QString&, KeyTree& tree );
36
+		virtual const TQString renderEntry( const KeyTreeItem&, CSwordKey* = 0 );
37
+		virtual const TQString finishText( const TQString&, KeyTree& tree );
38 38
 	};
39 39
 
40 40
 };

+ 31
- 31
bibletime/backend/creferencemanager.cpp View File

@@ -15,14 +15,14 @@
15 15
 #include "../frontend/cbtconfig.h"
16 16
 
17 17
 //QT includes
18
-#include <qregexp.h>
18
+#include <tqregexp.h>
19 19
 
20 20
 //stl includes
21 21
 #include <algorithm>       // STL algorithms class library
22 22
 
23 23
 /** Returns a hyperlink used to be imbedded in the display windows. At the moment the format is sword://module/key */
24
-const QString CReferenceManager::encodeHyperlink( const QString moduleName, const QString key, const CReferenceManager::Type type) {
25
-	QString ret = QString::null;
24
+const TQString CReferenceManager::encodeHyperlink( const TQString moduleName, const TQString key, const CReferenceManager::Type type) {
25
+	TQString ret = TQString::null;
26 26
 
27 27
 	switch (type) {
28 28
 
@@ -70,12 +70,12 @@ const QString CReferenceManager::encodeHyperlink( const QString moduleName, cons
70 70
 	}
71 71
 
72 72
 	if (type == GenericBook) {
73
-		const QString s = (!key.isEmpty() ? key : QString::null);
74
-		QString newKey = QString::null;
73
+		const TQString s = (!key.isEmpty() ? key : TQString::null);
74
+		TQString newKey = TQString::null;
75 75
 		//replace all / of the key (e.g. of a CSwordTreeKey) with
76 76
 		// the escape sequence \/ so we know it's a link internal divider (e.g. of CSwordTreeKey)!
77 77
 
78
-		QChar c;
78
+		TQChar c;
79 79
 
80 80
 		for(unsigned int i = 0; i < s.length(); ++i) {
81 81
 			c = s.at(i);
@@ -120,15 +120,15 @@ const QString CReferenceManager::encodeHyperlink( const QString moduleName, cons
120 120
 }
121 121
 
122 122
 /** Decodes the given hyperlink to module and key. */
123
-const bool CReferenceManager::decodeHyperlink( const QString& hyperlink, QString& module, QString& key, CReferenceManager::Type& type ) {
123
+const bool CReferenceManager::decodeHyperlink( const TQString& hyperlink, TQString& module, TQString& key, CReferenceManager::Type& type ) {
124 124
 	/**
125 125
 	* We have to decide between three types of URLS: sword://Type/Module/Key, morph://Testament/key and strongs://Testament/Key
126 126
 	*/
127
-	module = QString::null;
128
-	key = QString::null;
127
+	module = TQString::null;
128
+	key = TQString::null;
129 129
 
130 130
 	type = Unknown; //not yet known
131
-	QString ref = hyperlink;
131
+	TQString ref = hyperlink;
132 132
 	//remove the trailing slash
133 133
 
134 134
 	if (ref.right(1)=="/" && ref.right(2) != "\\/") //trailing slash, but not escaped
@@ -188,7 +188,7 @@ const bool CReferenceManager::decodeHyperlink( const QString& hyperlink, QString
188 188
 		//   }
189 189
 
190 190
 		//replace \/ escapes with /
191
-		key.replace(QRegExp("\\\\/"), "/");
191
+		key.replace(TQRegExp("\\\\/"), "/");
192 192
 	}
193 193
 	else if (ref.left(8).lower() == "morph://" || ref.left(10).lower() == "strongs://") { //strongs or morph URL have the same format
194 194
 		enum PreType {IsMorph, IsStrongs};
@@ -207,7 +207,7 @@ const bool CReferenceManager::decodeHyperlink( const QString& hyperlink, QString
207 207
 		const int pos = ref.find("/");
208 208
 
209 209
 		if (pos>0) { //found
210
-			const QString language = ref.mid(0,pos);
210
+			const TQString language = ref.mid(0,pos);
211 211
 
212 212
 			if (language.lower() == "hebrew") {
213 213
 				switch (preType) {
@@ -247,14 +247,14 @@ const bool CReferenceManager::decodeHyperlink( const QString& hyperlink, QString
247 247
 	return true;
248 248
 }
249 249
 
250
-const QString CReferenceManager::encodeReference(const QString &module, const QString &reference) {
251
-	//return QString("(%1)%2").arg(module).arg(reference);
252
-	return QString("(").append(module).append(")").append(reference);
250
+const TQString CReferenceManager::encodeReference(const TQString &module, const TQString &reference) {
251
+	//return TQString("(%1)%2").arg(module).arg(reference);
252
+	return TQString("(").append(module).append(")").append(reference);
253 253
 }
254 254
 
255
-void CReferenceManager::decodeReference(QString &dragreference, QString &module, QString &reference) {
255
+void CReferenceManager::decodeReference(TQString &dragreference, TQString &module, TQString &reference) {
256 256
 	const int pos = dragreference.find(")");
257
-	const QString fallbackModule = dragreference.mid( 1, pos - 1);
257
+	const TQString fallbackModule = dragreference.mid( 1, pos - 1);
258 258
 	dragreference = dragreference.mid(pos+1);
259 259
 
260 260
 	module = fallbackModule;
@@ -262,15 +262,15 @@ void CReferenceManager::decodeReference(QString &dragreference, QString &module,
262 262
 }
263 263
 
264 264
 /** Returns true if the parameter is a hyperlink. */
265
-const bool CReferenceManager::isHyperlink( const QString& hyperlink ) {
265
+const bool CReferenceManager::isHyperlink( const TQString& hyperlink ) {
266 266
 	return (    hyperlink.left(8)  == "sword://")
267 267
 		   || (hyperlink.left(10) == "strongs://")
268 268
 		   || (hyperlink.left(8)  == "morph://");
269 269
 }
270 270
 
271 271
 /** Returns the preferred module name for the given type. */
272
-const QString CReferenceManager::preferredModule( const CReferenceManager::Type type ) {
273
-	QString moduleName = QString::null;
272
+const TQString CReferenceManager::preferredModule( const CReferenceManager::Type type ) {
273
+	TQString moduleName = TQString::null;
274 274
 	CSwordModuleInfo* module = 0;
275 275
 
276 276
 	switch (type) {
@@ -324,7 +324,7 @@ const QString CReferenceManager::preferredModule( const CReferenceManager::Type
324 324
 		break;
325 325
 	}
326 326
 
327
-	return module ? module->name() : QString::null;
327
+	return module ? module->name() : TQString::null;
328 328
 }
329 329
 
330 330
 /** No descriptions */
@@ -349,7 +349,7 @@ CReferenceManager::Type CReferenceManager::typeFromModule( const CSwordModuleInf
349 349
 }
350 350
 
351 351
 /** Parses the given verse references using the given language and the module.*/
352
-const QString CReferenceManager::parseVerseReference( const QString& ref, const CReferenceManager::ParseOptions& options) {
352
+const TQString CReferenceManager::parseVerseReference( const TQString& ref, const CReferenceManager::ParseOptions& options) {
353 353
 
354 354
 	CSwordModuleInfo* const mod = CPointers::backend()->findModuleByName(options.refDestinationModule);
355 355
 	Q_ASSERT(mod);
@@ -361,11 +361,11 @@ const QString CReferenceManager::parseVerseReference( const QString& ref, const
361 361
 
362 362
 	if ((mod->type() != CSwordModuleInfo::Bible) && (mod->type() != CSwordModuleInfo::Commentary)) {
363 363
 		qDebug("CReferenceManager: Only verse based modules are supported as ref destination module");
364
-		return QString::null;
364
+		return TQString::null;
365 365
 	}
366 366
 
367
-	QString sourceLanguage = options.sourceLanguage;
368
-	QString destinationLanguage = options.destinationLanguage;
367
+	TQString sourceLanguage = options.sourceLanguage;
368
+	TQString destinationLanguage = options.destinationLanguage;
369 369
 
370 370
  	StringList locales = sword::LocaleMgr::getSystemLocaleMgr()->getAvailableLocales();
371 371
  	if (/*options.sourceLanguage == "en" ||*/ std::find(locales.begin(), locales.end(), sourceLanguage) == locales.end()) { //sourceLanguage not available
@@ -377,8 +377,8 @@ const QString CReferenceManager::parseVerseReference( const QString& ref, const
377 377
  	}
378 378
 
379 379
 
380
-	QString ret;
381
-	QStringList refList = QStringList::split(";", ref);
380
+	TQString ret;
381
+	TQStringList refList = TQStringList::split(";", ref);
382 382
 
383 383
 	CSwordVerseKey baseKey(0);
384 384
 	baseKey.setLocale( sourceLanguage.latin1() );
@@ -387,7 +387,7 @@ const QString CReferenceManager::parseVerseReference( const QString& ref, const
387 387
 
388 388
 // 	CSwordVerseKey dummy(0);
389 389
 	//HACK: We have to workaround a Sword bug, we have to set the default locale to the same as the sourceLanguage !
390
-	const QString oldLocaleName = CPointers::backend()->booknameLanguage();
390
+	const TQString oldLocaleName = CPointers::backend()->booknameLanguage();
391 391
 	CPointers::backend()->booknameLanguage(sourceLanguage);
392 392
 
393 393
 	VerseKey dummy;
@@ -396,7 +396,7 @@ const QString CReferenceManager::parseVerseReference( const QString& ref, const
396 396
 
397 397
 // 	qDebug("Parsing '%s' in '%s' using '%s' as base, source lang '%s', dest lang '%s'", ref.latin1(), options.refDestinationModule.latin1(), baseKey.key().latin1(), sourceLanguage.latin1(), destinationLanguage.latin1());
398 398
 
399
-	for (QStringList::iterator it = refList.begin(); it != refList.end(); it++) {
399
+	for (TQStringList::iterator it = refList.begin(); it != refList.end(); it++) {
400 400
 		//The listkey may contain more than one item, because a ref lik "Gen 1:3,5" is parsed into two single refs
401 401
 		ListKey lk = dummy.ParseVerseList((const char*)(*it).utf8(), (const char*)baseKey.key().utf8(), true);
402 402
 		Q_ASSERT(!dummy.Error());
@@ -413,7 +413,7 @@ const QString CReferenceManager::parseVerseReference( const QString& ref, const
413 413
 				Q_ASSERT(k);
414 414
  				k->setLocale( destinationLanguage.latin1() );
415 415
 
416
-				ret.append( QString::fromUtf8(k->getRangeText()) ).append("; ");
416
+				ret.append( TQString::fromUtf8(k->getRangeText()) ).append("; ");
417 417
 			}
418 418
 			else { // a single ref
419 419
 				VerseKey vk;
@@ -421,7 +421,7 @@ const QString CReferenceManager::parseVerseReference( const QString& ref, const
421 421
 				vk = lk.getElement(i)->getText();
422 422
 				vk.setLocale( destinationLanguage.latin1() );
423 423
 
424
-				ret.append( QString::fromUtf8(vk.getText()) ).append("; ");
424
+				ret.append( TQString::fromUtf8(vk.getText()) ).append("; ");
425 425
 			}
426 426
 		}
427 427
 

+ 12
- 12
bibletime/backend/creferencemanager.h View File

@@ -13,7 +13,7 @@
13 13
 #define CREFERENCEMANAGER_H
14 14
 
15 15
 //Qt includes
16
-#include <qstring.h>
16
+#include <tqstring.h>
17 17
 
18 18
 #include "cswordmoduleinfo.h"
19 19
 
@@ -44,7 +44,7 @@ public:
44 44
 	* @param key The string which will contain the key after decoding
45 45
 	* @param type The type param will contain the reference type after decoding
46 46
 	*/
47
-	static const bool decodeHyperlink( const QString& hyperlink, QString& module, QString& key, Type& type);
47
+	static const bool decodeHyperlink( const TQString& hyperlink, TQString& module, TQString& key, Type& type);
48 48
 	/**
49 49
 	* Returns a hyperlink used to be imbedded in the display windows.
50 50
 	* At the moment the format is sword://module/key
@@ -53,7 +53,7 @@ public:
53 53
 	* @param type The type which is used to encode the hyperlink
54 54
 	* @return The encoded hyperlink
55 55
 	*/
56
-	static const QString encodeHyperlink( const QString module, const QString key, const Type type);
56
+	static const TQString encodeHyperlink( const TQString module, const TQString key, const Type type);
57 57
 	/**
58 58
 	* Puts a module Name and a Reference together in the 'draggable' form
59 59
 	* (module)reference
@@ -62,24 +62,24 @@ public:
62 62
 	* @return The encoded reference using module and reference
63 63
 	* @author Martin Gruner
64 64
 	*/
65
-	static const QString encodeReference(const QString &module, const QString &reference);
65
+	static const TQString encodeReference(const TQString &module, const TQString &reference);
66 66
 	/**
67 67
 	* decodes a 'draggable' reference into a modulename and a reference
68 68
 	* @author Martin Gruner
69 69
 	*/
70
-	static void decodeReference(QString &dragreference, QString &module, QString &reference);
70
+	static void decodeReference(TQString &dragreference, TQString &module, TQString &reference);
71 71
 	/**
72 72
 	* Returns true if the parameter is a hyperlink.
73 73
 	* @param hyperlink The string which is tested
74 74
 	* @return True if the passed string is a hyperlink
75 75
 	*/
76
-	static const bool isHyperlink( const QString& hyperlink );
76
+	static const bool isHyperlink( const TQString& hyperlink );
77 77
 	/**
78 78
 	* Returns the preferred module name for the given type.
79 79
 	* @param type The type which is used to find the module
80 80
 	* @return The default module name for the passed type
81 81
 	*/
82
-	static const QString preferredModule( const Type type );
82
+	static const TQString preferredModule( const Type type );
83 83
 	/**
84 84
 	* Returns the type of the passed module type
85 85
 	* @param type The CSwordModuleInfo module typpe
@@ -89,10 +89,10 @@ public:
89 89
 
90 90
 
91 91
 	struct ParseOptions {
92
-		QString refDestinationModule;
93
-		QString refBase; /* only valid for verse based destination modules*/
94
-		QString sourceLanguage; /* only valid for verse based destination modules*/
95
-		QString destinationLanguage; /* only valid for verse based destination modules*/
92
+		TQString refDestinationModule;
93
+		TQString refBase; /* only valid for verse based destination modules*/
94
+		TQString sourceLanguage; /* only valid for verse based destination modules*/
95
+		TQString destinationLanguage; /* only valid for verse based destination modules*/
96 96
 
97 97
 		ParseOptions() {
98 98
 			destinationLanguage = "en";
@@ -105,7 +105,7 @@ public:
105 105
 	* @param lang The language of the verse reference
106 106
 	* @param newLang The language of the reference, which will be returned. For example: If BibleTime using an english environment parses a spanish ref (lang=es) the returned ref should be in english (newLang=en), because his english standard module only understands en.
107 107
 	*/
108
-	static const QString parseVerseReference( const QString& ref, const ParseOptions& options);
108
+	static const TQString parseVerseReference( const TQString& ref, const ParseOptions& options);
109 109
 };
110 110
 
111 111
 #endif

+ 56
- 56
bibletime/backend/cswordbackend.cpp View File

@@ -33,8 +33,8 @@
33 33
 #include <ctype.h>
34 34
 
35 35
 //Qt includes
36
-#include <qdir.h>
37
-#include <qfileinfo.h>
36
+#include <tqdir.h>
37
+#include <tqfileinfo.h>
38 38
 
39 39
 //KDE includes
40 40
 #include <klocale.h>
@@ -69,7 +69,7 @@ CSwordBackend::CSwordBackend()
69 69
 	filterInit();
70 70
 }
71 71
 
72
-CSwordBackend::CSwordBackend(const QString& path, const bool augmentHome)
72
+CSwordBackend::CSwordBackend(const TQString& path, const bool augmentHome)
73 73
 : sword::SWMgr(!path.isEmpty() ? (const char*)path.local8Bit() : 0, false, new sword::EncodingFilterMgr( sword::ENC_UTF8 ), false, augmentHome) // don't allow module renaming, because we load from a path
74 74
 {
75 75
 	qDebug("CSwordBackend::CSwordBackend for %s, using %s", path.latin1(), configPath);
@@ -168,7 +168,7 @@ const CSwordBackend::LoadError CSwordBackend::initModules() {
168 168
 		//  for (m_moduleList.first(); m_moduleList.current(); m_moduleList.next()) {
169 169
 
170 170
 		if ( (*it)->isEncrypted() ) {
171
-			const QString unlockKey = CBTConfig::getModuleEncryptionKey( (*it)->name() ).latin1();
171
+			const TQString unlockKey = CBTConfig::getModuleEncryptionKey( (*it)->name() ).latin1();
172 172
 
173 173
 			if (!unlockKey.isNull()) {
174 174
 				setCipherKey( (*it)->name().latin1(), unlockKey.latin1() );
@@ -313,7 +313,7 @@ void CSwordBackend::setDisplayOptions( const CSwordBackend::DisplayOptions ) {
313 313
 }
314 314
 
315 315
 /** This function searches for a module with the specified description */
316
-CSwordModuleInfo* const CSwordBackend::findModuleByDescription(const QString& description) {
316
+CSwordModuleInfo* const CSwordBackend::findModuleByDescription(const TQString& description) {
317 317
 	CSwordModuleInfo* ret = 0;
318 318
 	ListCSwordModuleInfo::iterator end_it = m_moduleList.end();
319 319
 
@@ -328,16 +328,16 @@ CSwordModuleInfo* const CSwordBackend::findModuleByDescription(const QString& de
328 328
 }
329 329
 
330 330
 /** This function searches for a module with the specified description */
331
-const QString CSwordBackend::findModuleNameByDescription(const QString& description) {
331
+const TQString CSwordBackend::findModuleNameByDescription(const TQString& description) {
332 332
 	if (m_moduleDescriptionMap.contains(description)) {
333 333
 		return m_moduleDescriptionMap[description];
334 334
 	}
335 335
 
336
-	return QString::null;
336
+	return TQString::null;
337 337
 }
338 338
 
339 339
 /** This function searches for a module with the specified name */
340
-CSwordModuleInfo* const CSwordBackend::findModuleByName(const QString& name) {
340
+CSwordModuleInfo* const CSwordBackend::findModuleByName(const TQString& name) {
341 341
 	CSwordModuleInfo* ret = 0;
342 342
 
343 343
 	ListCSwordModuleInfo::iterator end_it = m_moduleList.end();
@@ -382,14 +382,14 @@ CSwordModuleInfo* const CSwordBackend::findModuleByPointer(const CSwordModuleInf
382 382
 }
383 383
 
384 384
 /** Returns our local config object to store the cipher keys etc. locally for each user. The values of the config are merged with the global config. */
385
-const bool CSwordBackend::moduleConfig(const QString& module, sword::SWConfig& moduleConfig) {
385
+const bool CSwordBackend::moduleConfig(const TQString& module, sword::SWConfig& moduleConfig) {
386 386
 	sword::SectionMap::iterator section;
387 387
 	DIR *dir = opendir(configPath);
388 388
 
389 389
 	struct dirent *ent;
390 390
 
391 391
 	bool foundConfig = false;
392
-	QString modFile;
392
+	TQString modFile;
393 393
 
394 394
 	if (dir) {    // find and update .conf file
395 395
 		rewinddir(dir);
@@ -398,7 +398,7 @@ const bool CSwordBackend::moduleConfig(const QString& module, sword::SWConfig& m
398 398
 			if ((strcmp(ent->d_name, ".")) && (strcmp(ent->d_name, ".."))) {
399 399
 				modFile.setLatin1(configPath);
400 400
 				modFile.append("/");
401
-				modFile.append( QString::fromLocal8Bit(ent->d_name) );
401
+				modFile.append( TQString::fromLocal8Bit(ent->d_name) );
402 402
 
403 403
 				moduleConfig = sword::SWConfig( (const char*)modFile.local8Bit() );
404 404
 				section = moduleConfig.Sections.find( (const char*)module.local8Bit() );
@@ -424,7 +424,7 @@ const bool CSwordBackend::moduleConfig(const QString& module, sword::SWConfig& m
424 424
 	}
425 425
 
426 426
 	if (!foundConfig && configType != 2) { //search in $HOME/.sword/
427
-		QString myPath(getenv("HOME"));
427
+		TQString myPath(getenv("HOME"));
428 428
 		myPath.append("/.sword/mods.d");
429 429
 		dir = opendir(myPath.latin1());
430 430
 
@@ -450,53 +450,53 @@ const bool CSwordBackend::moduleConfig(const QString& module, sword::SWConfig& m
450 450
 }
451 451
 
452 452
 /** Returns the text used for the option given as parameter. */
453
-const QString CSwordBackend::optionName( const CSwordModuleInfo::FilterTypes option ) {
453
+const TQString CSwordBackend::optionName( const CSwordModuleInfo::FilterTypes option ) {
454 454
 	switch (option) {
455 455
 
456 456
 		case CSwordModuleInfo::footnotes:
457
-		return QString("Footnotes");
457
+		return TQString("Footnotes");
458 458
 
459 459
 		case CSwordModuleInfo::strongNumbers:
460
-		return QString("Strong's Numbers");
460
+		return TQString("Strong's Numbers");
461 461
 
462 462
 		case CSwordModuleInfo::headings:
463
-		return QString("Headings");
463
+		return TQString("Headings");
464 464
 
465 465
 		case CSwordModuleInfo::morphTags:
466
-		return QString("Morphological Tags");
466
+		return TQString("Morphological Tags");
467 467
 
468 468
 		case CSwordModuleInfo::lemmas:
469
-		return QString("Lemmas");
469
+		return TQString("Lemmas");
470 470
 
471 471
 		case CSwordModuleInfo::hebrewPoints:
472
-		return QString("Hebrew Vowel Points");
472
+		return TQString("Hebrew Vowel Points");
473 473
 
474 474
 		case CSwordModuleInfo::hebrewCantillation:
475
-		return QString("Hebrew Cantillation");
475
+		return TQString("Hebrew Cantillation");
476 476
 
477 477
 		case CSwordModuleInfo::greekAccents:
478
-		return QString("Greek Accents");
478
+		return TQString("Greek Accents");
479 479
 
480 480
 		case CSwordModuleInfo::redLetterWords:
481
-		return QString("Words of Christ in Red");
481
+		return TQString("Words of Christ in Red");
482 482
 
483 483
 		case CSwordModuleInfo::textualVariants:
484
-		return QString("Textual Variants");
484
+		return TQString("Textual Variants");
485 485
 
486 486
 		case CSwordModuleInfo::scriptureReferences:
487
-		return QString("Cross-references");
487
+		return TQString("Cross-references");
488 488
 
489 489
 		case CSwordModuleInfo::morphSegmentation:
490
-		return QString("Morph Segmentation");
490
+		return TQString("Morph Segmentation");
491 491
 		//   case CSwordModuleInfo::transliteration:
492
-		//    return QString("Transliteration");
492
+		//    return TQString("Transliteration");
493 493
 	}
494 494
 
495
-	return QString::null;
495
+	return TQString::null;
496 496
 }
497 497
 
498 498
 /** Returns the translated name of the option given as parameter. */
499
-const QString CSwordBackend::translatedOptionName(const CSwordModuleInfo::FilterTypes option) {
499
+const TQString CSwordBackend::translatedOptionName(const CSwordModuleInfo::FilterTypes option) {
500 500
 	switch (option) {
501 501
 
502 502
 		case CSwordModuleInfo::footnotes:
@@ -538,57 +538,57 @@ const QString CSwordBackend::translatedOptionName(const CSwordModuleInfo::Filter
538 538
 		//    return i18n("Transliteration between scripts");
539 539
 	}
540 540
 
541
-	return QString::null;
541
+	return TQString::null;
542 542
 }
543 543
 
544 544
 
545
-const QString CSwordBackend::configOptionName( const CSwordModuleInfo::FilterTypes option ) {
545
+const TQString CSwordBackend::configOptionName( const CSwordModuleInfo::FilterTypes option ) {
546 546
 	switch (option) {
547 547
 
548 548
 		case CSwordModuleInfo::footnotes:
549
-		return QString("Footnotes");
549
+		return TQString("Footnotes");
550 550
 
551 551
 		case CSwordModuleInfo::strongNumbers:
552
-		return QString("Strongs");
552
+		return TQString("Strongs");
553 553
 
554 554
 		case CSwordModuleInfo::headings:
555
-		return QString("Headings");
555
+		return TQString("Headings");
556 556
 
557 557
 		case CSwordModuleInfo::morphTags:
558
-		return QString("Morph");
558
+		return TQString("Morph");
559 559
 
560 560
 		case CSwordModuleInfo::lemmas:
561
-		return QString("Lemma");
561
+		return TQString("Lemma");
562 562
 
563 563
 		case CSwordModuleInfo::hebrewPoints:
564
-		return QString("HebrewPoints");
564
+		return TQString("HebrewPoints");
565 565
 
566 566
 		case CSwordModuleInfo::hebrewCantillation:
567
-		return QString("Cantillation");
567
+		return TQString("Cantillation");
568 568
 
569 569
 		case CSwordModuleInfo::greekAccents:
570
-		return QString("GreekAccents");
570
+		return TQString("GreekAccents");
571 571
 
572 572
 		case CSwordModuleInfo::redLetterWords:
573
-		return QString("RedLetterWords");
573
+		return TQString("RedLetterWords");
574 574
 
575 575
 		case CSwordModuleInfo::textualVariants:
576
-		return QString("Variants");
576
+		return TQString("Variants");
577 577
 
578 578
 		case CSwordModuleInfo::scriptureReferences:
579
-		return QString("Scripref");
579
+		return TQString("Scripref");
580 580
 
581 581
 		case CSwordModuleInfo::morphSegmentation:
582
-		return QString("MorphSegmentation");
582
+		return TQString("MorphSegmentation");
583 583
 
584 584
 		default:
585
-		return QString::null;
585
+		return TQString::null;
586 586
 	}
587 587
 
588
-	return QString::null;
588
+	return TQString::null;
589 589
 }
590 590
 
591
-const QString CSwordBackend::booknameLanguage( const QString& language ) {
591
+const TQString CSwordBackend::booknameLanguage( const TQString& language ) {
592 592
 	if (!language.isEmpty()) {
593 593
 		sword::LocaleMgr::getSystemLocaleMgr()->setDefaultLocaleName( language.latin1() );
594 594
 
@@ -596,7 +596,7 @@ const QString CSwordBackend::booknameLanguage( const QString& language ) {
596 596
 		const ListCSwordModuleInfo::iterator end_it = m_moduleList.end();
597 597
 
598 598
 		//use what sword returns, language may be different
599
-		QString newLocaleName( sword::LocaleMgr::getSystemLocaleMgr()->getDefaultLocaleName()  );
599
+		TQString newLocaleName( sword::LocaleMgr::getSystemLocaleMgr()->getDefaultLocaleName()  );
600 600
 
601 601
 		for (ListCSwordModuleInfo::iterator it = m_moduleList.begin(); it != end_it; ++it) {
602 602
 			if ( ((*it)->type() == CSwordModuleInfo::Bible) || ((*it)->type() == CSwordModuleInfo::Commentary) ) {
@@ -607,7 +607,7 @@ const QString CSwordBackend::booknameLanguage( const QString& language ) {
607 607
 
608 608
 	}
609 609
 
610
-	return QString( sword::LocaleMgr::getSystemLocaleMgr()->getDefaultLocaleName() );
610
+	return TQString( sword::LocaleMgr::getSystemLocaleMgr()->getDefaultLocaleName() );
611 611
 }
612 612
 
613 613
 
@@ -629,27 +629,27 @@ void CSwordBackend::reloadModules() {
629 629
 	initModules();
630 630
 }
631 631
 
632
-const QStringList CSwordBackend::swordDirList() {
633
-	QStringList ret;
634
-	const QString home = QString(getenv("HOME"));
632
+const TQStringList CSwordBackend::swordDirList() {
633
+	TQStringList ret;
634
+	const TQString home = TQString(getenv("HOME"));
635 635
 
636 636
 	//return a list of used Sword dirs. Useful for the installer
637
-	QString configPath = QString("%1/.sword/sword.conf").arg(home);
637
+	TQString configPath = TQString("%1/.sword/sword.conf").arg(home);
638 638
 
639
-	if (!QFile(configPath).exists()) {
639
+	if (!TQFile(configPath).exists()) {
640 640
 		configPath = globalConfPath; //e.g. /etc/sword.conf, /usr/local/etc/sword.conf
641 641
 
642 642
 
643 643
 	}
644 644
 
645 645
 
646
-	QStringList configs = QStringList::split(":", configPath);
646
+	TQStringList configs = TQStringList::split(":", configPath);
647 647
 
648 648
 	/*ToDo: Use the const iterator as soon as we switch to Qt > 3.1
649
-	  for (QStringList::const_iterator it = configs.constBegin(); it != configs.constEnd(); ++it) {*/
649
+	  for (TQStringList::const_iterator it = configs.constBegin(); it != configs.constEnd(); ++it) {*/
650 650
 
651
-	for (QStringList::const_iterator it = configs.begin(); it != configs.end(); ++it) {
652
-		if (!QFileInfo(*it).exists()) {
651
+	for (TQStringList::const_iterator it = configs.begin(); it != configs.end(); ++it) {
652
+		if (!TQFileInfo(*it).exists()) {
653 653
 			continue;
654 654
 		}
655 655
 

+ 15
- 15
bibletime/backend/cswordbackend.h View File

@@ -17,10 +17,10 @@
17 17
 //#include "centrydisplay.h"
18 18
 
19 19
 //Qt includes
20
-#include <qptrlist.h>
21
-#include <qmap.h>
22
-#include <qstring.h>
23
-#include <qstringlist.h>
20
+#include <tqptrlist.h>
21
+#include <tqmap.h>
22
+#include <tqstring.h>
23
+#include <tqstringlist.h>
24 24
 
25 25
 //Sword includes
26 26
 #include <swmgr.h>
@@ -99,7 +99,7 @@ public:
99 99
 	* @param path The path which is used to load modules
100 100
 	* @param augmentHome True if the $HOME/.sword/ modules should be augmented with the other modules
101 101
 	*/
102
-	CSwordBackend( const QString& path, const bool augmentHome = true );
102
+	CSwordBackend( const TQString& path, const bool augmentHome = true );
103 103
 
104 104
 	/**
105 105
 	* The destrctor of this backend. This function shuts the modules down using @ref shutdownModules.
@@ -144,25 +144,25 @@ public:
144 144
 	* Sets the language for the international booknames of Sword.
145 145
 	* @param langName The abbreviation string which should be used for the Sword backend
146 146
 	*/
147
-	const QString booknameLanguage( const QString& langName = QString::null );
147
+	const TQString booknameLanguage( const TQString& langName = TQString::null );
148 148
 	/**
149 149
 	* This function searches for a module with the specified description
150 150
 	* @param description The description of the desired module
151 151
 	* @return pointer to the desired module; null if no module has the specified description
152 152
 	*/
153
-	virtual CSwordModuleInfo* const findModuleByDescription(const QString& description);
153
+	virtual CSwordModuleInfo* const findModuleByDescription(const TQString& description);
154 154
 	/**
155 155
 	* This function searches for a module with the specified description
156 156
 	* @param description The description of the desired module
157 157
 	* @return pointer to the desired module; null if no module has the specified description
158 158
 	*/
159
-	const QString findModuleNameByDescription(const QString& description);
159
+	const TQString findModuleNameByDescription(const TQString& description);
160 160
 	/**
161 161
 	* This function searches for a module with the specified name
162 162
 	* @param name The name of the desired module
163 163
 	* @return Pointer to the desired module; null if no module has the specified name
164 164
 	*/
165
-	CSwordModuleInfo* const findModuleByName(const QString& name);
165
+	CSwordModuleInfo* const findModuleByName(const TQString& name);
166 166
 	/**
167 167
 	* This function searches for a module with the specified sword module as module() object!
168 168
 	* @param swmodule to a Sword module
@@ -183,22 +183,22 @@ public:
183 183
 	* Tries to find the config object for the module. The second paramter will be the found config.
184 184
 	* @return True if the config was found, false if not. If false is returned the moduleConfig object is in undefined/unknwon state.
185 185
 	*/
186
-	const bool moduleConfig(const QString& module, sword::SWConfig& moduleConfig );
186
+	const bool moduleConfig(const TQString& module, sword::SWConfig& moduleConfig );
187 187
 	/**
188 188
 	* Returns the text used for the option given as parameter.
189 189
 	* @param The paramter enum
190 190
 	* @return The name of the option given by the parameter
191 191
 	*/
192
-	static const QString optionName( const CSwordModuleInfo::FilterTypes option );
192
+	static const TQString optionName( const CSwordModuleInfo::FilterTypes option );
193 193
 	/**
194 194
 	* Returns the text used for the option given as parameter.
195 195
 	*/
196
-	static const QString configOptionName( const CSwordModuleInfo::FilterTypes option );
196
+	static const TQString configOptionName( const CSwordModuleInfo::FilterTypes option );
197 197
 	/**
198 198
 	* Returns the translated name of the option given as parameter.
199 199
 	* @param The translated option name
200 200
 	*/
201
-	static const QString translatedOptionName(const CSwordModuleInfo::FilterTypes option );
201
+	static const TQString translatedOptionName(const CSwordModuleInfo::FilterTypes option );
202 202
 	/**
203 203
 	* Returns the version of the Sword library.
204 204
 	* @return The version used by this backend
@@ -211,7 +211,7 @@ public:
211 211
 	/** Sword prefix list.
212 212
 	* @return A list of all known Sword prefix dirs
213 213
 	*/
214
-	const QStringList swordDirList();
214
+	const TQStringList swordDirList();
215 215
 
216 216
 protected:
217 217
 	/**
@@ -245,7 +245,7 @@ private:
245 245
 	m_displays;
246 246
 
247 247
 	ListCSwordModuleInfo m_moduleList;
248
-	QMap<QString, QString> m_moduleDescriptionMap;
248
+	TQMap<TQString, TQString> m_moduleDescriptionMap;
249 249
 };
250 250
 
251 251
 /**Returns The list of modules managed by this backend*/

+ 9
- 9
bibletime/backend/cswordbiblemoduleinfo.cpp View File

@@ -17,7 +17,7 @@
17 17
 // #include "util/cpointers.h"
18 18
 
19 19
 //Qt includes
20
-#include <qfile.h>
20
+#include <tqfile.h>
21 21
 
22 22
 //Sword includes
23 23
 #include <versekey.h>
@@ -43,7 +43,7 @@ m_lowerBound(0),
43 43
 m_upperBound(0),
44 44
 m_bookList(0) {
45 45
 	if (m.m_bookList) {
46
-		m_bookList = new QStringList();
46
+		m_bookList = new TQStringList();
47 47
 		*m_bookList = *m.m_bookList;
48 48
 	}
49 49
 
@@ -86,14 +86,14 @@ void CSwordBibleModuleInfo::initBounds() {
86 86
 
87 87
 
88 88
 /** Returns the books available in this module */
89
-QStringList* const CSwordBibleModuleInfo::books() {
89
+TQStringList* const CSwordBibleModuleInfo::books() {
90 90
 	if (m_cachedLocale != backend()->booknameLanguage()) { //if the locale has changed
91 91
 		delete m_bookList;
92 92
 		m_bookList = 0;
93 93
 	}
94 94
 
95 95
 	if (!m_bookList) {
96
-		m_bookList = new QStringList();
96
+		m_bookList = new TQStringList();
97 97
 
98 98
 		initBounds();
99 99
 		int min = 0;
@@ -123,7 +123,7 @@ QStringList* const CSwordBibleModuleInfo::books() {
123 123
 		(*key) = sword::TOP;
124 124
 
125 125
 		for (key->Testament(min+1); !key->Error() && (key->Testament()-1) <= max; key->Book(key->Book()+1)) {
126
-			m_bookList->append( QString::fromUtf8(key->getBookName()) );
126
+			m_bookList->append( TQString::fromUtf8(key->getBookName()) );
127 127
 		}
128 128
 
129 129
 		m_cachedLocale = backend()->booknameLanguage();
@@ -147,7 +147,7 @@ const unsigned int CSwordBibleModuleInfo::chapterCount(const unsigned int book)
147 147
 	return result;
148 148
 }
149 149
 
150
-const unsigned int CSwordBibleModuleInfo::chapterCount(const QString& book) {
150
+const unsigned int CSwordBibleModuleInfo::chapterCount(const TQString& book) {
151 151
 	return chapterCount( bookNumber(book) );
152 152
 }
153 153
 
@@ -168,11 +168,11 @@ const unsigned int CSwordBibleModuleInfo::verseCount( const unsigned int book, c
168 168
 	return result;
169 169
 }
170 170
 
171
-const unsigned int CSwordBibleModuleInfo::verseCount( const QString& book, const unsigned int chapter ) {
171
+const unsigned int CSwordBibleModuleInfo::verseCount( const TQString& book, const unsigned int chapter ) {
172 172
 	return verseCount( bookNumber(book), chapter );
173 173
 }
174 174
 
175
-const unsigned int CSwordBibleModuleInfo::bookNumber(const QString &book) {
175
+const unsigned int CSwordBibleModuleInfo::bookNumber(const TQString &book) {
176 176
 	unsigned int bookNumber = 0;
177 177
 
178 178
 	//find out if we have ot and nt, only ot or only nt
@@ -215,7 +215,7 @@ const unsigned int CSwordBibleModuleInfo::bookNumber(const QString &book) {
215 215
 		for ( int j = 0; j < key->BMAX[i] && !found; ++j) {
216 216
 			++bookNumber;
217 217
 
218
-			if (book == QString::fromUtf8( key->books[i][j].name) )
218
+			if (book == TQString::fromUtf8( key->books[i][j].name) )
219 219
 				found = true;
220 220
 		}
221 221
 	}

+ 8
- 8
bibletime/backend/cswordbiblemoduleinfo.h View File

@@ -17,7 +17,7 @@
17 17
 #include "cswordversekey.h"
18 18
 
19 19
 //Qt includes
20
-#include <qstringlist.h>
20
+#include <tqstringlist.h>
21 21
 
22 22
 //Sword includes
23 23
 
@@ -64,7 +64,7 @@ public:
64 64
 	* @param chapter The number of the chapter we use
65 65
 	* @return The number of verses for the given book and chapter
66 66
 	*/
67
-	virtual const unsigned int verseCount( const QString& book, const unsigned int chapter );
67
+	virtual const unsigned int verseCount( const TQString& book, const unsigned int chapter );
68 68
 	/** Information about the chapters in a book.
69 69
 	* @return The number of available chapters of the given book.
70 70
 	* @return The number of chapters for the given book
@@ -73,11 +73,11 @@ public:
73 73
 	/** Information about the chapters in a book.
74 74
 	* @return The number of available chapters of the given book.
75 75
 	*/
76
-	virtual const unsigned int chapterCount( const QString& book );
76
+	virtual const unsigned int chapterCount( const TQString& book );
77 77
 	/** Return all book of this module.
78
-	* @return A QStringList containing the books which are available in this module.
78
+	* @return A TQStringList containing the books which are available in this module.
79 79
 	*/
80
-	virtual QStringList* const books();
80
+	virtual TQStringList* const books();
81 81
 	/**
82 82
 	* Reimplementation, Returns the type
83 83
 	*/
@@ -85,7 +85,7 @@ public:
85 85
 	/**
86 86
 	* @return the book number, values starting with 1; 0 if not found
87 87
 	*/
88
-	const unsigned int bookNumber(const QString &book);
88
+	const unsigned int bookNumber(const TQString &book);
89 89
 	/**
90 90
 	* Returns true if his module has the text of desired type of testament
91 91
 	*/
@@ -107,8 +107,8 @@ private:
107 107
 	CSwordVerseKey m_lowerBound;
108 108
 	CSwordVerseKey m_upperBound;
109 109
 
110
-	QStringList* m_bookList; //This booklist is cached
111
-	QString m_cachedLocale;
110
+	TQStringList* m_bookList; //This booklist is cached
111
+	TQString m_cachedLocale;
112 112
 	short int m_hasOT;
113 113
 	short int m_hasNT;
114 114
 };

+ 25
- 25
bibletime/backend/cswordkey.cpp View File

@@ -28,9 +28,9 @@
28 28
 #include <treekeyidx.h>
29 29
 
30 30
 //Qt includes
31
-#include <qregexp.h>
32
-#include <qstring.h>
33
-#include <qtextcodec.h>
31
+#include <tqregexp.h>
32
+#include <tqstring.h>
33
+#include <tqtextcodec.h>
34 34
 
35 35
 CSwordKey::CSwordKey(CSwordModuleInfo* const module) : m_module(module) {}
36 36
 
@@ -38,9 +38,9 @@ CSwordKey::CSwordKey(const CSwordKey& k) {
38 38
 	m_module = k.m_module;
39 39
 }
40 40
 
41
-const QString CSwordKey::rawText() {
41
+const TQString CSwordKey::rawText() {
42 42
 	if (!m_module) {
43
-		return QString::null;
43
+		return TQString::null;
44 44
 	}
45 45
 
46 46
 	if (dynamic_cast<sword::SWKey*>(this)) {
@@ -51,17 +51,17 @@ const QString CSwordKey::rawText() {
51 51
 	}
52 52
 
53 53
 	if (key().isNull()) {
54
-		return QString::null;
54
+		return TQString::null;
55 55
 	}
56 56
 
57 57
 // 	qWarning("rawText: %s", m_module->module()->getRawEntry());
58
-	return QString::fromUtf8( m_module->module()->getRawEntry() );
58
+	return TQString::fromUtf8( m_module->module()->getRawEntry() );
59 59
 }
60 60
 
61
-const QString CSwordKey::renderedText( const CSwordKey::TextRenderType mode ) {
61
+const TQString CSwordKey::renderedText( const CSwordKey::TextRenderType mode ) {
62 62
 	Q_ASSERT(m_module);
63 63
 	if (!m_module) {
64
-		return QString::null;
64
+		return TQString::null;
65 65
 	}
66 66
 
67 67
 	using namespace sword;
@@ -87,7 +87,7 @@ const QString CSwordKey::renderedText( const CSwordKey::TextRenderType mode ) {
87 87
 					&& !strstr(m_module->module()->getKey()->getText(), buffer)
88 88
 			   ) {
89 89
 				qDebug("return an empty key for %s", m_module->module()->getKey()->getText());
90
-				return QString::null;
90
+				return TQString::null;
91 91
 			}
92 92
 		}
93 93
 		delete buffer;
@@ -95,24 +95,24 @@ const QString CSwordKey::renderedText( const CSwordKey::TextRenderType mode ) {
95 95
 
96 96
 	Q_ASSERT(!key().isNull());
97 97
 	if (!key().isNull()) { //we have valid text
98
-		QString text = QString::fromUtf8( m_module->module()->RenderText() );
98
+		TQString text = TQString::fromUtf8( m_module->module()->RenderText() );
99 99
 
100 100
 		// This is yucky, but if we want strong lexicon refs we have to do it here.
101 101
 		if (m_module->type() == CSwordModuleInfo::Lexicon) {
102
-			QString t(text);
103
-			QRegExp rx("(GREEK|HEBREW) for 0*([1-9]\\d*)");	// ignore 0's before number
102
+			TQString t(text);
103
+			TQRegExp rx("(GREEK|HEBREW) for 0*([1-9]\\d*)");	// ignore 0's before number
104 104
 			int pos = 0;
105 105
 			while( (pos = rx.search(t, pos)) != -1 ) {
106
-				QString language = rx.cap(1);
107
-				QString langcode = QString(language.at(0));	// "G" or "H"
108
-				QString number = rx.cap(2);
109
-				QString paddednumber = number.rightJustify(5, '0');	// Form 00123
106
+				TQString language = rx.cap(1);
107
+				TQString langcode = TQString(language.at(0));	// "G" or "H"
108
+				TQString number = rx.cap(2);
109
+				TQString paddednumber = number.rightJustify(5, '0');	// Form 00123
110 110
 
111 111
 				text.replace(
112
-						QRegExp( QString(
112
+						TQRegExp( TQString(
113 113
 							"(>[^<>]+)"			// Avoid replacing inside tags
114 114
 							"\\b(0*%1)\\b").arg(number) ),	// And span around 0's
115
-						QString("\\1<span lemma=\"%1%2\"><a href=\"strongs://%3/%4\">\\2</a></span>")
115
+						TQString("\\1<span lemma=\"%1%2\"><a href=\"strongs://%3/%4\">\\2</a></span>")
116 116
 							.arg(langcode, paddednumber, language, paddednumber)
117 117
 					);
118 118
 				pos += rx.matchedLength();
@@ -123,8 +123,8 @@ const QString CSwordKey::renderedText( const CSwordKey::TextRenderType mode ) {
123 123
 			//we have to encode all UTF-8 in HTML escapes
124 124
 			// go though every character and write down the escaped HTML unicode entity
125 125
 			// form is &#<decimal unicode value here>;
126
-			QString ret;
127
-			QChar c;
126
+			TQString ret;
127
+			TQChar c;
128 128
 			const unsigned int length = text.length();
129 129
 
130 130
 			for (unsigned int i = 0; i < length; ++i) {
@@ -147,12 +147,12 @@ const QString CSwordKey::renderedText( const CSwordKey::TextRenderType mode ) {
147 147
 		}
148 148
 	}
149 149
 
150
-	return QString::null;
150
+	return TQString::null;
151 151
 }
152 152
 
153
-const QString CSwordKey::strippedText() {
153
+const TQString CSwordKey::strippedText() {
154 154
 	if (!m_module) {
155
-		return QString::null;
155
+		return TQString::null;
156 156
 	}
157 157
 
158 158
 	if (/*sword::SWKey* k =*/ dynamic_cast<sword::SWKey*>(this)) {
@@ -164,7 +164,7 @@ const QString CSwordKey::strippedText() {
164 164
 		delete buffer;
165 165
 	}
166 166
 
167
-	return QString::fromUtf8( m_module->module()->StripText() );
167
+	return TQString::fromUtf8( m_module->module()->StripText() );
168 168
 }
169 169
 
170 170
 

+ 9
- 9
bibletime/backend/cswordkey.h View File

<
@@ -16,7 +16,7 @@
16 16
 
17 17
 
18 18
 //Qt includes
19
-#include <qstring.h>
19
+#include <tqstring.h>
20 20
 //forward declarations
21 21
 
22 22
 class CSwordModuleInfo;
@@ -54,11 +54,11 @@ public:
54 54
 	/** Returns the current key.
55 55
 	 * @return The current key which belongs to the current object.
56 56
 	 */
57
-	virtual const QString key() const = 0;
58
-	/** Sets the current key. Sets the key using a utf8 enabled QString.
57
+	virtual const TQString key() const = 0;
58
+	/** Sets the current key. Sets the key using a utf8 enabled TQString.
59 59
 	 * @param key The key which should be used to set the current one
60 60
 	 */
61
-	virtual const bool key(const QString& key) = 0;
61
+	virtual const bool key(const TQString& key) = 0;
62 62
 	/** Set the key using a utf8-decoded c-string
63 63
 	 * @param key The key which should be used to set the current one
64 64
 	 */
@@ -76,14 +76,14 @@ public: