21 ** If you have questions regarding the use of this file, please contact |
21 ** If you have questions regarding the use of this file, please contact |
22 ** Nokia at developer.feedback@nokia.com. |
22 ** Nokia at developer.feedback@nokia.com. |
23 ** |
23 ** |
24 ****************************************************************************/ |
24 ****************************************************************************/ |
25 |
25 |
26 #include <QTranslator> |
|
27 #if defined(Q_OS_SYMBIAN) |
26 #if defined(Q_OS_SYMBIAN) |
28 #include <e32base.h> |
27 #include <e32base.h> |
29 #endif // Q_OS_SYMBIAN |
28 #endif // Q_OS_SYMBIAN |
|
29 #include <hbtranslator.h> |
30 #include "hbdntxmlreader_p.h" |
30 #include "hbdntxmlreader_p.h" |
31 |
31 |
32 #define DirectoryLocalizerFile ":/i18n/hbdirectorylocalizer.xml" |
32 #define DirectoryLocalizerFile ":/i18n/hbdirectorylocalizer.xml" |
33 #define DirectoryLocalizerTranslationsFile "/resource/hbi18n/translations/directorylocalizer_" |
|
34 |
33 |
35 /*! |
34 /*! |
36 Constructor of class. |
35 Constructor of class. |
37 */ |
36 */ |
38 HbDNTXmlReader::HbDNTXmlReader() |
37 HbDNTXmlReader::HbDNTXmlReader() |
39 { |
38 { |
40 fullPaths = NULL; |
39 fullPaths = NULL; |
41 pathStrings = NULL; |
40 pathStrings = NULL; |
42 |
41 parseDirectoryPaths = false; |
43 |
42 parsePathStrings = false; |
44 parseDirectoryPaths = false; |
43 elementNumber = 0; |
45 parsePathStrings = false; |
44 validElement = false; |
46 elementNumber = 0; |
45 twoDone = false; |
47 validElement = false; |
46 validElement = false; |
48 twoDone = false; |
47 |
49 QLocale locale = QLocale::system(); |
48 HbTranslator* trans = new HbTranslator("directorynamelocalizer"); |
50 |
49 Q_UNUSED(trans); |
51 trans = new QTranslator(); |
50 |
52 QString languageStr; |
51 QFile xmlFile(DirectoryLocalizerFile); |
53 languageStr.append(DirectoryLocalizerTranslationsFile); |
52 pathStrings = new QMap<QString, QString>; |
54 |
53 fullPaths = new QMap<QString,QString>; |
55 languageStr.append(locale.name()); |
54 |
56 |
55 if ( xmlFile.exists() ) { |
57 // Support for checking both Z and C drives |
56 QXmlInputSource source( &xmlFile ); |
58 |
57 QXmlSimpleReader reader; |
59 #if defined(Q_OS_SYMBIAN) |
58 reader.setContentHandler( this ); |
60 bool succeed = false; |
59 reader.parse( source ); |
61 succeed = trans->load("z:" + languageStr); |
60 } |
62 if ( succeed == false ) { |
|
63 trans->load("c:" + languageStr); |
|
64 } |
|
65 #else // Q_OS_SYMBIAN |
|
66 trans->load(languageStr); |
|
67 #endif // Q_OS_SYMBIAN |
|
68 |
|
69 QCoreApplication::installTranslator(trans); |
|
70 validElement = false; |
|
71 |
|
72 QFile xmlFile(DirectoryLocalizerFile); |
|
73 |
|
74 pathStrings = new QMap<QString, QString>; |
|
75 fullPaths = new QMap<QString,QString>; |
|
76 |
|
77 if( xmlFile.exists() ) |
|
78 { |
|
79 QXmlInputSource source( &xmlFile ); |
|
80 QXmlSimpleReader reader; |
|
81 reader.setContentHandler( this ); |
|
82 reader.parse( source ) ; |
|
83 } |
|
84 |
|
85 } |
61 } |
86 |
62 |
87 /*! |
63 /*! |
88 Destructor of class. |
64 Destructor of class. |
89 */ |
65 */ |
90 HbDNTXmlReader::~HbDNTXmlReader() |
66 HbDNTXmlReader::~HbDNTXmlReader() |
91 { |
67 { |
92 delete fullPaths; |
68 delete fullPaths; |
93 delete pathStrings; |
69 delete pathStrings; |
94 QCoreApplication::removeTranslator(trans); |
|
95 delete trans; |
|
96 } |
70 } |
97 |
71 |
98 /*! |
72 /*! |
99 This function is needed by XML reader. |
73 This function is needed by XML reader. |
100 |
74 |
110 |
84 |
111 \param qName element which will be readed |
85 \param qName element which will be readed |
112 \return true |
86 \return true |
113 */ |
87 */ |
114 bool HbDNTXmlReader::startElement( const QString & , |
88 bool HbDNTXmlReader::startElement( const QString & , |
115 const QString & , |
89 const QString & , |
116 const QString & qName, |
90 const QString & qName, |
117 const QXmlAttributes & ) |
91 const QXmlAttributes & ) |
118 { |
92 { |
119 if( qName == DirectoryLocalizerPathStringsStr ) { |
93 if( qName == DirectoryLocalizerPathStringsStr ) { |
120 parsePathStrings = true; // set to parse Path |
94 parsePathStrings = true; // set to parse Path |
121 parseDirectoryPaths = false; |
95 parseDirectoryPaths = false; |
122 elements.clear(); |
96 elements.clear(); |
123 elementNumber = 0; // Set current path element number as undefined |
97 elementNumber = 0; // Set current path element number as undefined |
124 twoDone = false; |
98 twoDone = false; |
125 } else if( qName == DirectoryLocalizerFullDirectoryPathsStr ) { |
99 } else if( qName == DirectoryLocalizerFullDirectoryPathsStr ) { |
126 parsePathStrings = false; |
100 parsePathStrings = false; |
127 parseDirectoryPaths = true; // set to parse localized path |
101 parseDirectoryPaths = true; // set to parse localized path |
128 elements.clear(); |
102 elements.clear(); |
129 elementNumber = 0; // set current path element as undefined |
103 elementNumber = 0; // set current path element as undefined |
130 twoDone = false; |
104 twoDone = false; |
131 } else if( qName == DirectoryLocalizerNameStr ) { |
105 } else if( qName == DirectoryLocalizerNameStr ) { |
132 elementNumber = 1; // |
106 elementNumber = 1; // |
133 validElement = true; |
107 validElement = true; |
134 twoDone = false; |
108 twoDone = false; |
135 } else if( qName == DirectoryLocalizerPathStr ){ |
109 } else if( qName == DirectoryLocalizerPathStr ){ |
136 elementNumber = 2; |
110 elementNumber = 2; |
137 validElement = true; |
111 validElement = true; |
138 twoDone = false; |
112 twoDone = false; |
139 } else if( qName == DirectoryLocalizerTranslationStr){ |
113 } else if( qName == DirectoryLocalizerTranslationStr){ |
140 elementNumber = 3; |
114 elementNumber = 3; |
141 validElement = true; |
115 validElement = true; |
142 } else if( qName == DirectoryLocalizerRootPathStr ){ |
116 } else if( qName == DirectoryLocalizerRootPathStr ){ |
143 elementNumber = 1; |
117 elementNumber = 1; |
144 validElement = true; |
118 validElement = true; |
145 twoDone = false; |
119 twoDone = false; |
146 } else if( qName == DirectoryLocalizerLocalizedPathStr ){ |
120 } else if( qName == DirectoryLocalizerLocalizedPathStr ){ |
147 elementNumber = 2; |
121 elementNumber = 2; |
148 validElement = true; |
122 validElement = true; |
149 twoDone = false; |
123 twoDone = false; |
150 } else if( qName == DirectoryLocalizerLocalizedNameStr ){ |
124 } else if( qName == DirectoryLocalizerLocalizedNameStr ){ |
151 elementNumber = 3; |
125 elementNumber = 3; |
152 validElement = true; |
126 validElement = true; |
153 twoDone = false; |
127 twoDone = false; |
154 } else { |
128 } else { |
155 elementNumber++; |
129 elementNumber++; |
156 } |
130 } |
157 |
131 |
158 return true; |
132 return true; |
159 } |
133 } |
160 |
134 |
161 /*! |
135 /*! |
162 This function is needed by XML reader. |
136 This function is needed by XML reader. |
163 |
137 |
177 ba = new QByteArray(t.toAscii()); |
151 ba = new QByteArray(t.toAscii()); |
178 charPtr = ba->data(); |
152 charPtr = ba->data(); |
179 } |
153 } |
180 |
154 |
181 if( validElement ) { |
155 if( validElement ) { |
182 if(parsePathStrings) { |
156 if(parsePathStrings) { |
183 switch(elementNumber) { |
157 switch(elementNumber) { |
184 case 1: // DirectoryLocalizerNameStr |
158 case 1: // DirectoryLocalizerNameStr |
185 t=t.toLower(); |
159 t=t.toLower(); |
186 elements.insert(0,t); |
160 elements.insert(0,t); |
187 break; |
161 break; |
188 case 2: // DirectoryLocalizerPathStr |
162 case 2: // DirectoryLocalizerPathStr |
189 t= t.replace(DirectoryLocalizerDirectorySeparatorX2,DirectoryLocalizerDirectorySeparatorX1); |
163 t= t.replace(DirectoryLocalizerDirectorySeparatorX2,DirectoryLocalizerDirectorySeparatorX1); |
190 t=t.toLower(); |
164 t=t.toLower(); |
191 if ( elements.count() > 1 ) { |
165 if ( elements.count() > 1 ) { |
192 elements.insert(1,t); |
166 elements.insert(1,t); |
193 } else { |
167 } else { |
194 elements.append(t); |
168 elements.append(t); |
195 } |
169 } |
196 break; |
170 break; |
197 case 3: // DirectoryLocalizerTranslationStr |
171 case 3: // DirectoryLocalizerTranslationStr |
198 elements.insert(0,t); |
172 elements.insert(0,t); |
199 |
173 |
200 localizedStr = QCoreApplication::translate(0,charPtr); |
174 localizedStr = hbTrId(charPtr); |
201 delete ba; |
175 delete ba; |
202 ba = 0; |
176 ba = 0; |
203 |
177 |
204 if( localizedStr == t ){ |
178 if( localizedStr == t ){ |
205 localizedStr = ""; |
179 localizedStr = ""; |
206 } |
180 } |
207 elements.append(localizedStr); |
181 elements.append(localizedStr); |
208 break; |
182 break; |
209 default: |
183 default: |
210 elements.append(t); |
184 elements.append(t); |
211 break; |
185 break; |
212 } |
186 } |
213 validElement = false; |
187 validElement = false; |
214 } else if(parseDirectoryPaths) { |
188 } else if(parseDirectoryPaths) { |
215 switch(elementNumber) { |
189 switch(elementNumber) { |
216 case 1: // DirectoryLocalizerRootPathStr |
190 case 1: // DirectoryLocalizerRootPathStr |
217 temp = t; |
191 temp = t; |
218 break; |
192 break; |
219 case 2: // DirectoryLocalizerLocalizedPathStr |
193 case 2: // DirectoryLocalizerLocalizedPathStr |
220 x = pathStrings->value(temp); |
194 x = pathStrings->value(temp); |
221 y = pathStrings->value(t); |
195 y = pathStrings->value(t); |
222 |
196 |
223 path.append( x ); |
197 path.append( x ); |
224 path.append( y ); |
198 path.append( y ); |
250 */ |
224 */ |
251 bool HbDNTXmlReader::endElement( const QString &, |
225 bool HbDNTXmlReader::endElement( const QString &, |
252 const QString &, |
226 const QString &, |
253 const QString & qName ) |
227 const QString & qName ) |
254 { |
228 { |
255 if( qName == DirectoryLocalizerPathStringsStr ) { |
229 if( qName == DirectoryLocalizerPathStringsStr ) { |
256 parsePathStrings = false; |
230 parsePathStrings = false; |
257 parseDirectoryPaths = false; |
231 parseDirectoryPaths = false; |
258 elements.clear(); |
232 elements.clear(); |
259 elementNumber = 0; |
233 elementNumber = 0; |
260 } else if( qName == DirectoryLocalizerFullDirectoryPathsStr ) { |
234 } else if( qName == DirectoryLocalizerFullDirectoryPathsStr ) { |
261 parsePathStrings = false; |
235 parsePathStrings = false; |
262 |
236 |
263 parseDirectoryPaths = false; |
237 parseDirectoryPaths = false; |
264 elements.clear(); |
238 elements.clear(); |
265 elementNumber = 0; |
239 elementNumber = 0; |
266 } |
240 } |
267 |
241 |
268 if( parsePathStrings && elements.count() > 1 ) { |
242 if( parsePathStrings && elements.count() > 1 ) { |
269 pathStrings->insertMulti(elements.at(0), elements.at(1)); |
243 pathStrings->insertMulti(elements.at(0), elements.at(1)); |
270 elements.clear(); |
244 elements.clear(); |
271 } else if(parseDirectoryPaths && elements.count() > 1) { |
245 } else if(parseDirectoryPaths && elements.count() > 1) { |
272 QString element1, element2; |
246 QString element1, element2; |
273 switch(elements.count()) { |
247 switch(elements.count()) { |
274 case 2: |
248 case 2: |
275 if(!twoDone){ |
249 if(!twoDone){ |
276 fullPaths->insertMulti(elements.at(0),elements.at(1)); |
250 fullPaths->insertMulti(elements.at(0),elements.at(1)); |
277 twoDone = true; |
251 twoDone = true; |
278 elements.clear(); |
252 elements.clear(); |
279 } |
253 } |
280 break; |
254 break; |
281 default: |
255 default: |
282 break; |
256 break; |
283 } |
257 } |
284 } |
258 } |
285 return true; |
259 return true; |
286 } |
260 } |
287 |
261 |
288 /*! |
262 /*! |
289 This function is needed by XML reader. |
263 This function is needed by XML reader. |
290 |
264 |