]>
Commit | Line | Data |
---|---|---|
56d2f750 VS |
1 | ///////////////////////////////////////////////////////////////////////////// |
2 | // Name: wxrc.cpp | |
3 | // Purpose: XML resource compiler | |
1dce6f09 | 4 | // Author: Vaclav Slavik, Eduardo Marques <edrdo@netcabo.pt> |
56d2f750 VS |
5 | // Created: 2000/03/05 |
6 | // RCS-ID: $Id$ | |
7 | // Copyright: (c) 2000 Vaclav Slavik | |
8 | // Licence: wxWindows licence | |
9 | ///////////////////////////////////////////////////////////////////////////// | |
10 | ||
56d2f750 VS |
11 | // For compilers that support precompilation, includes "wx/wx.h". |
12 | #include "wx/wxprec.h" | |
13 | ||
14 | #ifdef __BORLANDC__ | |
15 | #pragma hdrstop | |
16 | #endif | |
17 | ||
07ee782b | 18 | // for all others, include the necessary headers |
56d2f750 | 19 | #ifndef WX_PRECOMP |
07ee782b MB |
20 | #include "wx/app.h" |
21 | #include "wx/log.h" | |
6b24b421 | 22 | #include "wx/wxcrtvararg.h" |
56d2f750 VS |
23 | #endif |
24 | ||
25 | #include "wx/cmdline.h" | |
cecc483e | 26 | #include "wx/xml/xml.h" |
56d2f750 | 27 | #include "wx/ffile.h" |
4249ec2c | 28 | #include "wx/filename.h" |
f6853b4a | 29 | #include "wx/wfstream.h" |
097d3ba2 | 30 | #include "wx/utils.h" |
aac18ec7 | 31 | #include "wx/hashset.h" |
c5d7b81e | 32 | #include "wx/mimetype.h" |
21b2dde5 | 33 | #include "wx/vector.h" |
f6853b4a | 34 | |
aac18ec7 | 35 | WX_DECLARE_HASH_SET(wxString, wxStringHash, wxStringEqual, StringSet); |
f6853b4a | 36 | |
1dce6f09 VS |
37 | class XRCWidgetData |
38 | { | |
39 | public: | |
f80ea77b | 40 | XRCWidgetData(const wxString& vname,const wxString& vclass) |
1dce6f09 VS |
41 | : m_class(vclass), m_name(vname) {} |
42 | const wxString& GetName() const { return m_name; } | |
43 | const wxString& GetClass() const { return m_class; } | |
44 | private: | |
45 | wxString m_class; | |
46 | wxString m_name; | |
47 | }; | |
2ad1ff54 | 48 | |
1dce6f09 VS |
49 | #include "wx/arrimpl.cpp" |
50 | WX_DECLARE_OBJARRAY(XRCWidgetData,ArrayOfXRCWidgetData); | |
17a1ebd1 | 51 | WX_DEFINE_OBJARRAY(ArrayOfXRCWidgetData) |
1dce6f09 VS |
52 | |
53 | class XRCWndClassData | |
54 | { | |
f80ea77b | 55 | private: |
1dce6f09 VS |
56 | wxString m_className; |
57 | wxString m_parentClassName; | |
aac18ec7 | 58 | StringSet m_ancestorClassNames; |
1dce6f09 | 59 | ArrayOfXRCWidgetData m_wdata; |
f80ea77b | 60 | |
1dce6f09 VS |
61 | void BrowseXmlNode(wxXmlNode* node) |
62 | { | |
63 | wxString classValue; | |
64 | wxString nameValue; | |
f80ea77b | 65 | wxXmlNode* children; |
1dce6f09 VS |
66 | while (node) |
67 | { | |
9a83f860 VZ |
68 | if (node->GetName() == wxT("object") |
69 | && node->GetAttribute(wxT("class"),&classValue) | |
70 | && node->GetAttribute(wxT("name"),&nameValue)) | |
1dce6f09 VS |
71 | { |
72 | m_wdata.Add(XRCWidgetData(nameValue,classValue)); | |
73 | } | |
74 | children = node->GetChildren(); | |
75 | if (children) | |
f80ea77b | 76 | BrowseXmlNode(children); |
1dce6f09 VS |
77 | node = node->GetNext(); |
78 | } | |
79 | } | |
f80ea77b | 80 | |
1dce6f09 | 81 | public: |
aac18ec7 VZ |
82 | XRCWndClassData(const wxString& className, |
83 | const wxString& parentClassName, | |
84 | const wxXmlNode* node) : | |
2ad1ff54 WS |
85 | m_className(className) , m_parentClassName(parentClassName) |
86 | { | |
9a83f860 | 87 | if ( className == wxT("wxMenu") ) |
aac18ec7 | 88 | { |
9a83f860 VZ |
89 | m_ancestorClassNames.insert(wxT("wxMenu")); |
90 | m_ancestorClassNames.insert(wxT("wxMenuBar")); | |
aac18ec7 | 91 | } |
9a83f860 | 92 | else if ( className == wxT("wxMDIChildFrame") ) |
aac18ec7 | 93 | { |
9a83f860 | 94 | m_ancestorClassNames.insert(wxT("wxMDIParentFrame")); |
aac18ec7 | 95 | } |
9a83f860 VZ |
96 | else if( className == wxT("wxMenuBar") || |
97 | className == wxT("wxStatusBar") || | |
98 | className == wxT("wxToolBar") ) | |
aac18ec7 | 99 | { |
9a83f860 | 100 | m_ancestorClassNames.insert(wxT("wxFrame")); |
aac18ec7 VZ |
101 | } |
102 | else | |
103 | { | |
9a83f860 | 104 | m_ancestorClassNames.insert(wxT("wxWindow")); |
aac18ec7 VZ |
105 | } |
106 | ||
aa063b24 | 107 | BrowseXmlNode(node->GetChildren()); |
aa063b24 | 108 | } |
f80ea77b | 109 | |
2ad1ff54 WS |
110 | const ArrayOfXRCWidgetData& GetWidgetData() |
111 | { | |
aa063b24 RD |
112 | return m_wdata; |
113 | } | |
76ee0497 | 114 | |
216d173f | 115 | bool CanBeUsedWithXRCCTRL(const wxString& name) |
76ee0497 | 116 | { |
9a83f860 VZ |
117 | if (name == wxT("tool") || |
118 | name == wxT("data") || | |
119 | name == wxT("unknown") || | |
120 | name == wxT("notebookpage") || | |
121 | name == wxT("separator") || | |
122 | name == wxT("sizeritem") || | |
123 | name == wxT("wxMenu") || | |
124 | name == wxT("wxMenuBar") || | |
125 | name == wxT("wxMenuItem") || | |
126 | name.EndsWith(wxT("Sizer")) ) | |
76ee0497 VS |
127 | { |
128 | return false; | |
129 | } | |
130 | return true; | |
131 | } | |
2ad1ff54 | 132 | |
76ee0497 VS |
133 | void GenerateHeaderCode(wxFFile& file) |
134 | { | |
aa063b24 | 135 | |
9a83f860 VZ |
136 | file.Write(wxT("class ") + m_className + wxT(" : public ") + m_parentClassName |
137 | + wxT(" {\nprotected:\n")); | |
aa063b24 | 138 | size_t i; |
b4a980f4 | 139 | for(i=0;i<m_wdata.GetCount();++i) |
76ee0497 | 140 | { |
aa063b24 | 141 | const XRCWidgetData& w = m_wdata.Item(i); |
216d173f | 142 | if( !CanBeUsedWithXRCCTRL(w.GetClass()) ) continue; |
2ad1ff54 | 143 | if( w.GetName().Length() == 0 ) continue; |
aa063b24 | 144 | file.Write( |
9a83f860 VZ |
145 | wxT(" ") + w.GetClass() + wxT("* ") + w.GetName() |
146 | + wxT(";\n")); | |
aa063b24 | 147 | } |
9a83f860 VZ |
148 | file.Write(wxT("\nprivate:\n void InitWidgetsFromXRC(wxWindow *parent){\n") |
149 | wxT(" wxXmlResource::Get()->LoadObject(this,parent,wxT(\"") | |
f80ea77b | 150 | + m_className |
9a83f860 | 151 | + wxT("\"), wxT(\"") |
f80ea77b | 152 | + m_parentClassName |
9a83f860 | 153 | + wxT("\"));\n")); |
b4a980f4 | 154 | for(i=0;i<m_wdata.GetCount();++i) |
76ee0497 | 155 | { |
aa063b24 | 156 | const XRCWidgetData& w = m_wdata.Item(i); |
216d173f | 157 | if( !CanBeUsedWithXRCCTRL(w.GetClass()) ) continue; |
2ad1ff54 | 158 | if( w.GetName().Length() == 0 ) continue; |
9a83f860 | 159 | file.Write( wxT(" ") |
f80ea77b | 160 | + w.GetName() |
9a83f860 | 161 | + wxT(" = XRCCTRL(*this,\"") |
f80ea77b | 162 | + w.GetName() |
9a83f860 | 163 | + wxT("\",") |
aa063b24 | 164 | + w.GetClass() |
9a83f860 | 165 | + wxT(");\n")); |
aa063b24 | 166 | } |
9a83f860 | 167 | file.Write(wxT(" }\n")); |
2ad1ff54 | 168 | |
9a83f860 | 169 | file.Write( wxT("public:\n")); |
aac18ec7 VZ |
170 | |
171 | if ( m_ancestorClassNames.size() == 1 ) | |
172 | { | |
173 | file.Write | |
174 | ( | |
175 | m_className + | |
9a83f860 | 176 | wxT("(") + |
aac18ec7 | 177 | *m_ancestorClassNames.begin() + |
9a83f860 VZ |
178 | wxT(" *parent=NULL){\n") + |
179 | wxT(" InitWidgetsFromXRC((wxWindow *)parent);\n") | |
180 | wxT(" }\n") | |
181 | wxT("};\n") | |
aac18ec7 VZ |
182 | ); |
183 | } | |
184 | else | |
185 | { | |
9a83f860 VZ |
186 | file.Write(m_className + wxT("(){\n") + |
187 | wxT(" InitWidgetsFromXRC(NULL);\n") | |
188 | wxT(" }\n") | |
189 | wxT("};\n")); | |
aac18ec7 VZ |
190 | |
191 | for ( StringSet::const_iterator it = m_ancestorClassNames.begin(); | |
192 | it != m_ancestorClassNames.end(); | |
193 | ++it ) | |
194 | { | |
9a83f860 VZ |
195 | file.Write(m_className + wxT("(") + *it + wxT(" *parent){\n") + |
196 | wxT(" InitWidgetsFromXRC((wxWindow *)parent);\n") | |
197 | wxT(" }\n") | |
198 | wxT("};\n")); | |
aac18ec7 VZ |
199 | } |
200 | } | |
201 | } | |
1dce6f09 VS |
202 | }; |
203 | WX_DECLARE_OBJARRAY(XRCWndClassData,ArrayOfXRCWndClassData); | |
17a1ebd1 | 204 | WX_DEFINE_OBJARRAY(ArrayOfXRCWndClassData) |
1dce6f09 | 205 | |
21b2dde5 VS |
206 | struct ExtractedString |
207 | { | |
208 | ExtractedString() : lineNo(-1) {} | |
209 | ExtractedString(const wxString& str_, | |
210 | const wxString& filename_, int lineNo_) | |
211 | : str(str_), filename(filename_), lineNo(lineNo_) | |
212 | {} | |
213 | ||
214 | wxString str; | |
215 | ||
216 | wxString filename; | |
217 | int lineNo; | |
218 | }; | |
219 | ||
220 | typedef wxVector<ExtractedString> ExtractedStrings; | |
221 | ||
1dce6f09 | 222 | |
cecc483e | 223 | class XmlResApp : public wxAppConsole |
56d2f750 VS |
224 | { |
225 | public: | |
6fcef5ed | 226 | // don't use builtin cmd line parsing: |
f80ea77b | 227 | virtual bool OnInit() { return true; } |
56d2f750 | 228 | virtual int OnRun(); |
f80ea77b WS |
229 | |
230 | private: | |
56d2f750 VS |
231 | void ParseParams(const wxCmdLineParser& cmdline); |
232 | void CompileRes(); | |
233 | wxArrayString PrepareTempFiles(); | |
f6853b4a VS |
234 | void FindFilesInXML(wxXmlNode *node, wxArrayString& flist, const wxString& inputPath); |
235 | ||
a7501aeb | 236 | wxString GetInternalFileName(const wxString& name, const wxArrayString& flist); |
56d2f750 VS |
237 | void DeleteTempFiles(const wxArrayString& flist); |
238 | void MakePackageZIP(const wxArrayString& flist); | |
239 | void MakePackageCPP(const wxArrayString& flist); | |
b8b8c49b | 240 | void MakePackagePython(const wxArrayString& flist); |
c8b7a961 VS |
241 | |
242 | void OutputGettext(); | |
21b2dde5 VS |
243 | ExtractedStrings FindStrings(); |
244 | ExtractedStrings FindStrings(const wxString& filename, wxXmlNode *node); | |
f80ea77b | 245 | |
b8b8c49b | 246 | bool flagVerbose, flagCPP, flagPython, flagGettext; |
56d2f750 VS |
247 | wxString parOutput, parFuncname, parOutputPath; |
248 | wxArrayString parFiles; | |
249 | int retCode; | |
1dce6f09 VS |
250 | |
251 | ArrayOfXRCWndClassData aXRCWndClassData; | |
aa063b24 RD |
252 | bool flagH; |
253 | void GenCPPHeader(); | |
56d2f750 VS |
254 | }; |
255 | ||
80b2db4e | 256 | IMPLEMENT_APP_CONSOLE(XmlResApp) |
56d2f750 VS |
257 | |
258 | int XmlResApp::OnRun() | |
259 | { | |
260 | static const wxCmdLineEntryDesc cmdLineDesc[] = | |
261 | { | |
db51a209 VZ |
262 | { wxCMD_LINE_SWITCH, "h", "help", "show help message", wxCMD_LINE_VAL_NONE, wxCMD_LINE_OPTION_HELP }, |
263 | { wxCMD_LINE_SWITCH, "v", "verbose", "be verbose" }, | |
264 | { wxCMD_LINE_SWITCH, "e", "extra-cpp-code", "output C++ header file with XRC derived classes" }, | |
265 | { wxCMD_LINE_SWITCH, "c", "cpp-code", "output C++ source rather than .rsc file" }, | |
266 | { wxCMD_LINE_SWITCH, "p", "python-code", "output wxPython source rather than .rsc file" }, | |
267 | { wxCMD_LINE_SWITCH, "g", "gettext", "output list of translatable strings (to stdout or file if -o used)" }, | |
268 | { wxCMD_LINE_OPTION, "n", "function", "C++/Python function name (with -c or -p) [InitXmlResource]" }, | |
269 | { wxCMD_LINE_OPTION, "o", "output", "output file [resource.xrs/cpp]" }, | |
99cd20be | 270 | #if 0 // not yet implemented |
db51a209 | 271 | { wxCMD_LINE_OPTION, "l", "list-of-handlers", "output list of necessary handlers to this file" }, |
99cd20be | 272 | #endif |
db51a209 | 273 | { wxCMD_LINE_PARAM, NULL, NULL, "input file(s)", |
f80ea77b | 274 | wxCMD_LINE_VAL_STRING, |
99cd20be | 275 | wxCMD_LINE_PARAM_MULTIPLE | wxCMD_LINE_OPTION_MANDATORY }, |
56d2f750 | 276 | |
bd365871 | 277 | wxCMD_LINE_DESC_END |
56d2f750 VS |
278 | }; |
279 | ||
280 | wxCmdLineParser parser(cmdLineDesc, argc, argv); | |
281 | ||
282 | switch (parser.Parse()) | |
283 | { | |
284 | case -1: | |
285 | return 0; | |
56d2f750 VS |
286 | |
287 | case 0: | |
288 | retCode = 0; | |
289 | ParseParams(parser); | |
c8b7a961 VS |
290 | if (flagGettext) |
291 | OutputGettext(); | |
292 | else | |
293 | CompileRes(); | |
56d2f750 | 294 | return retCode; |
56d2f750 | 295 | } |
0a0be6d5 | 296 | return 1; |
56d2f750 VS |
297 | } |
298 | ||
299 | ||
300 | ||
301 | ||
302 | void XmlResApp::ParseParams(const wxCmdLineParser& cmdline) | |
303 | { | |
db51a209 VZ |
304 | flagGettext = cmdline.Found("g"); |
305 | flagVerbose = cmdline.Found("v"); | |
306 | flagCPP = cmdline.Found("c"); | |
307 | flagPython = cmdline.Found("p"); | |
308 | flagH = flagCPP && cmdline.Found("e"); | |
1dce6f09 | 309 | |
56d2f750 | 310 | |
db51a209 | 311 | if (!cmdline.Found("o", &parOutput)) |
c8b7a961 VS |
312 | { |
313 | if (flagGettext) | |
314 | parOutput = wxEmptyString; | |
315 | else | |
b8b8c49b VS |
316 | { |
317 | if (flagCPP) | |
9a83f860 | 318 | parOutput = wxT("resource.cpp"); |
b8b8c49b | 319 | else if (flagPython) |
9a83f860 | 320 | parOutput = wxT("resource.py"); |
b8b8c49b | 321 | else |
9a83f860 | 322 | parOutput = wxT("resource.xrs"); |
b8b8c49b | 323 | } |
c8b7a961 | 324 | } |
1dce6f09 VS |
325 | if (!parOutput.empty()) |
326 | { | |
327 | wxFileName fn(parOutput); | |
328 | fn.Normalize(); | |
329 | parOutput = fn.GetFullPath(); | |
330 | parOutputPath = wxPathOnly(parOutput); | |
331 | } | |
9a83f860 | 332 | if (!parOutputPath) parOutputPath = wxT("."); |
56d2f750 | 333 | |
db51a209 | 334 | if (!cmdline.Found("n", &parFuncname)) |
9a83f860 | 335 | parFuncname = wxT("InitXmlResource"); |
56d2f750 VS |
336 | |
337 | for (size_t i = 0; i < cmdline.GetParamCount(); i++) | |
f65a69e9 VS |
338 | { |
339 | #ifdef __WINDOWS__ | |
340 | wxString fn=wxFindFirstFile(cmdline.GetParam(i), wxFILE); | |
2ad1ff54 | 341 | while (!fn.empty()) |
f65a69e9 VS |
342 | { |
343 | parFiles.Add(fn); | |
344 | fn=wxFindNextFile(); | |
345 | } | |
346 | #else | |
56d2f750 | 347 | parFiles.Add(cmdline.GetParam(i)); |
f65a69e9 VS |
348 | #endif |
349 | } | |
56d2f750 VS |
350 | } |
351 | ||
352 | ||
353 | ||
354 | ||
355 | void XmlResApp::CompileRes() | |
356 | { | |
357 | wxArrayString files = PrepareTempFiles(); | |
358 | ||
359 | wxRemoveFile(parOutput); | |
360 | ||
56d2f750 | 361 | if (!retCode) |
f80ea77b | 362 | { |
1dce6f09 | 363 | if (flagCPP){ |
56d2f750 | 364 | MakePackageCPP(files); |
1dce6f09 VS |
365 | if (flagH) |
366 | GenCPPHeader(); | |
367 | } | |
b8b8c49b VS |
368 | else if (flagPython) |
369 | MakePackagePython(files); | |
56d2f750 VS |
370 | else |
371 | MakePackageZIP(files); | |
372 | } | |
f80ea77b | 373 | |
56d2f750 VS |
374 | DeleteTempFiles(files); |
375 | } | |
376 | ||
377 | ||
a7501aeb VS |
378 | wxString XmlResApp::GetInternalFileName(const wxString& name, const wxArrayString& flist) |
379 | { | |
380 | wxString name2 = name; | |
9a83f860 VZ |
381 | name2.Replace(wxT(":"), wxT("_")); |
382 | name2.Replace(wxT("/"), wxT("_")); | |
383 | name2.Replace(wxT("\\"), wxT("_")); | |
384 | name2.Replace(wxT("*"), wxT("_")); | |
385 | name2.Replace(wxT("?"), wxT("_")); | |
f80ea77b | 386 | |
9a83f860 | 387 | wxString s = wxFileNameFromPath(parOutput) + wxT("$") + name2; |
a7501aeb VS |
388 | |
389 | if (wxFileExists(s) && flist.Index(s) == wxNOT_FOUND) | |
f80ea77b | 390 | { |
a7501aeb VS |
391 | for (int i = 0;; i++) |
392 | { | |
9a83f860 | 393 | s.Printf(wxFileNameFromPath(parOutput) + wxT("$%03i-") + name2, i); |
a7501aeb VS |
394 | if (!wxFileExists(s) || flist.Index(s) != wxNOT_FOUND) |
395 | break; | |
396 | } | |
397 | } | |
398 | return s; | |
399 | } | |
56d2f750 VS |
400 | |
401 | wxArrayString XmlResApp::PrepareTempFiles() | |
402 | { | |
403 | wxArrayString flist; | |
f80ea77b | 404 | |
b4a980f4 | 405 | for (size_t i = 0; i < parFiles.GetCount(); i++) |
56d2f750 | 406 | { |
f80ea77b | 407 | if (flagVerbose) |
9a83f860 | 408 | wxPrintf(wxT("processing ") + parFiles[i] + wxT("...\n")); |
56d2f750 VS |
409 | |
410 | wxXmlDocument doc; | |
f80ea77b | 411 | |
56d2f750 VS |
412 | if (!doc.Load(parFiles[i])) |
413 | { | |
9a83f860 | 414 | wxLogError(wxT("Error parsing file ") + parFiles[i]); |
56d2f750 VS |
415 | retCode = 1; |
416 | continue; | |
417 | } | |
f80ea77b | 418 | |
f6853b4a | 419 | wxString name, ext, path; |
bd365871 | 420 | wxFileName::SplitPath(parFiles[i], &path, &name, &ext); |
f6853b4a VS |
421 | |
422 | FindFilesInXML(doc.GetRoot(), flist, path); | |
1dce6f09 VS |
423 | if (flagH) |
424 | { | |
425 | wxXmlNode* node = (doc.GetRoot())->GetChildren(); | |
aa063b24 RD |
426 | wxString classValue,nameValue; |
427 | while(node){ | |
9a83f860 VZ |
428 | if(node->GetName() == wxT("object") |
429 | && node->GetAttribute(wxT("class"),&classValue) | |
430 | && node->GetAttribute(wxT("name"),&nameValue)){ | |
1dce6f09 VS |
431 | |
432 | aXRCWndClassData.Add( | |
aa063b24 | 433 | XRCWndClassData(nameValue,classValue,node) |
1dce6f09 VS |
434 | ); |
435 | } | |
aa063b24 | 436 | node = node -> GetNext(); |
1dce6f09 VS |
437 | } |
438 | } | |
a7501aeb | 439 | wxString internalName = GetInternalFileName(parFiles[i], flist); |
f80ea77b | 440 | |
4249ec2c | 441 | doc.Save(parOutputPath + wxFILE_SEP_PATH + internalName); |
a7501aeb | 442 | flist.Add(internalName); |
56d2f750 | 443 | } |
f80ea77b | 444 | |
56d2f750 VS |
445 | return flist; |
446 | } | |
447 | ||
448 | ||
4249ec2c VS |
449 | // Does 'node' contain filename information at all? |
450 | static bool NodeContainsFilename(wxXmlNode *node) | |
451 | { | |
bc151e84 VZ |
452 | const wxString name = node->GetName(); |
453 | ||
454 | // Any bitmaps (bitmap2 is used for disabled toolbar buttons): | |
9a83f860 | 455 | if ( name == wxT("bitmap") || name == wxT("bitmap2") ) |
f80ea77b | 456 | return true; |
2ad1ff54 | 457 | |
9a83f860 | 458 | if ( name == wxT("icon") ) |
8b34993d | 459 | return true; |
4249ec2c | 460 | |
4249ec2c VS |
461 | // wxBitmapButton: |
462 | wxXmlNode *parent = node->GetParent(); | |
f80ea77b | 463 | if (parent != NULL && |
9a83f860 VZ |
464 | parent->GetAttribute(wxT("class"), wxT("")) == wxT("wxBitmapButton") && |
465 | (name == wxT("focus") || | |
466 | name == wxT("disabled") || | |
467 | name == wxT("hover") || | |
468 | name == wxT("selected"))) | |
f80ea77b WS |
469 | return true; |
470 | ||
4249ec2c | 471 | // wxBitmap or wxIcon toplevel resources: |
9a83f860 | 472 | if ( name == wxT("object") ) |
4249ec2c | 473 | { |
9a83f860 VZ |
474 | wxString klass = node->GetAttribute(wxT("class"), wxEmptyString); |
475 | if (klass == wxT("wxBitmap") || | |
476 | klass == wxT("wxIcon") || | |
477 | klass == wxT("data") ) | |
f80ea77b | 478 | return true; |
4249ec2c | 479 | } |
f80ea77b | 480 | |
9ec6078f | 481 | // URLs in wxHtmlWindow: |
9a83f860 | 482 | if ( name == wxT("url") && |
9ec6078f | 483 | parent != NULL && |
9a83f860 | 484 | parent->GetAttribute(wxT("class"), wxT("")) == wxT("wxHtmlWindow") ) |
9ec6078f VS |
485 | { |
486 | // FIXME: this is wrong for e.g. http:// URLs | |
487 | return true; | |
488 | } | |
489 | ||
f80ea77b | 490 | return false; |
4249ec2c | 491 | } |
56d2f750 | 492 | |
f6853b4a VS |
493 | // find all files mentioned in structure, e.g. <bitmap>filename</bitmap> |
494 | void XmlResApp::FindFilesInXML(wxXmlNode *node, wxArrayString& flist, const wxString& inputPath) | |
495 | { | |
2b5f62a0 VZ |
496 | // Is 'node' XML node element? |
497 | if (node == NULL) return; | |
498 | if (node->GetType() != wxXML_ELEMENT_NODE) return; | |
499 | ||
4249ec2c | 500 | bool containsFilename = NodeContainsFilename(node); |
2b5f62a0 VZ |
501 | |
502 | wxXmlNode *n = node->GetChildren(); | |
f6853b4a VS |
503 | while (n) |
504 | { | |
2b5f62a0 | 505 | if (containsFilename && |
f80ea77b | 506 | (n->GetType() == wxXML_TEXT_NODE || |
2b5f62a0 | 507 | n->GetType() == wxXML_CDATA_SECTION_NODE)) |
f6853b4a VS |
508 | { |
509 | wxString fullname; | |
2b5f62a0 VZ |
510 | if (wxIsAbsolutePath(n->GetContent()) || inputPath.empty()) |
511 | fullname = n->GetContent(); | |
512 | else | |
4249ec2c | 513 | fullname = inputPath + wxFILE_SEP_PATH + n->GetContent(); |
a7501aeb | 514 | |
f80ea77b | 515 | if (flagVerbose) |
9a83f860 | 516 | wxPrintf(wxT("adding ") + fullname + wxT("...\n")); |
2b5f62a0 | 517 | |
a7501aeb | 518 | wxString filename = GetInternalFileName(n->GetContent(), flist); |
f6853b4a | 519 | n->SetContent(filename); |
f6853b4a | 520 | |
2b5f62a0 VZ |
521 | if (flist.Index(filename) == wxNOT_FOUND) |
522 | flist.Add(filename); | |
f6853b4a VS |
523 | |
524 | wxFileInputStream sin(fullname); | |
4249ec2c | 525 | wxFileOutputStream sout(parOutputPath + wxFILE_SEP_PATH + filename); |
f6853b4a VS |
526 | sin.Read(sout); // copy the stream |
527 | } | |
2b5f62a0 | 528 | |
f6853b4a VS |
529 | // subnodes: |
530 | if (n->GetType() == wxXML_ELEMENT_NODE) | |
531 | FindFilesInXML(n, flist, inputPath); | |
2b5f62a0 | 532 | |
f6853b4a VS |
533 | n = n->GetNext(); |
534 | } | |
535 | } | |
536 | ||
537 | ||
538 | ||
56d2f750 VS |
539 | void XmlResApp::DeleteTempFiles(const wxArrayString& flist) |
540 | { | |
b4a980f4 | 541 | for (size_t i = 0; i < flist.GetCount(); i++) |
4249ec2c | 542 | wxRemoveFile(parOutputPath + wxFILE_SEP_PATH + flist[i]); |
56d2f750 VS |
543 | } |
544 | ||
545 | ||
546 | ||
547 | void XmlResApp::MakePackageZIP(const wxArrayString& flist) | |
548 | { | |
549 | wxString files; | |
f80ea77b | 550 | |
b4a980f4 | 551 | for (size_t i = 0; i < flist.GetCount(); i++) |
9a83f860 | 552 | files += flist[i] + wxT(" "); |
56d2f750 | 553 | files.RemoveLast(); |
f80ea77b WS |
554 | |
555 | if (flagVerbose) | |
9a83f860 | 556 | wxPrintf(wxT("compressing ") + parOutput + wxT("...\n")); |
f80ea77b | 557 | |
4249ec2c VS |
558 | wxString cwd = wxGetCwd(); |
559 | wxSetWorkingDirectory(parOutputPath); | |
9a83f860 VZ |
560 | int execres = wxExecute(wxT("zip -9 -j ") + |
561 | wxString(flagVerbose ? wxT("\"") : wxT("-q \"")) + | |
562 | parOutput + wxT("\" ") + files, true); | |
4249ec2c VS |
563 | wxSetWorkingDirectory(cwd); |
564 | if (execres == -1) | |
56d2f750 | 565 | { |
9a83f860 VZ |
566 | wxLogError(wxT("Unable to execute zip program. Make sure it is in the path.")); |
567 | wxLogError(wxT("You can download it at http://www.cdrom.com/pub/infozip/")); | |
56d2f750 VS |
568 | retCode = 1; |
569 | return; | |
570 | } | |
571 | } | |
572 | ||
573 | ||
574 | ||
56d2f750 VS |
575 | static wxString FileToCppArray(wxString filename, int num) |
576 | { | |
577 | wxString output; | |
56d2f750 | 578 | wxString tmp; |
f6853b4a | 579 | wxString snum; |
5851504d | 580 | wxFFile file(filename, wxT("rb")); |
2ad1ff54 WS |
581 | wxFileOffset offset = file.Length(); |
582 | wxASSERT_MSG( offset >= 0 , wxT("Invalid file length") ); | |
17a1ebd1 VZ |
583 | |
584 | const size_t lng = wx_truncate_cast(size_t, offset); | |
81d3348a | 585 | wxASSERT_MSG( static_cast<wxFileOffset>(lng) == offset, |
563a24f0 | 586 | wxT("Huge file not supported") ); |
f80ea77b | 587 | |
9a83f860 | 588 | snum.Printf(wxT("%i"), num); |
e22fa4d7 VZ |
589 | output.Printf(wxT("static size_t xml_res_size_") + snum + wxT(" = %lu;\n"), |
590 | static_cast<unsigned long>(lng)); | |
9a83f860 | 591 | output += wxT("static unsigned char xml_res_file_") + snum + wxT("[] = {\n"); |
e066e256 VS |
592 | // we cannot use string literals because MSVC is dumb wannabe compiler |
593 | // with arbitrary limitation to 2048 strings :( | |
f80ea77b | 594 | |
56d2f750 VS |
595 | unsigned char *buffer = new unsigned char[lng]; |
596 | file.Read(buffer, lng); | |
f80ea77b | 597 | |
f6853b4a | 598 | for (size_t i = 0, linelng = 0; i < lng; i++) |
56d2f750 | 599 | { |
9a83f860 VZ |
600 | tmp.Printf(wxT("%i"), buffer[i]); |
601 | if (i != 0) output << wxT(','); | |
e066e256 | 602 | if (linelng > 70) |
f6853b4a VS |
603 | { |
604 | linelng = 0; | |
9a83f860 | 605 | output << wxT("\n"); |
f6853b4a | 606 | } |
e066e256 VS |
607 | output << tmp; |
608 | linelng += tmp.Length()+1; | |
56d2f750 | 609 | } |
f80ea77b | 610 | |
56d2f750 | 611 | delete[] buffer; |
f80ea77b | 612 | |
9a83f860 | 613 | output += wxT("};\n\n"); |
f80ea77b | 614 | |
56d2f750 VS |
615 | return output; |
616 | } | |
617 | ||
618 | ||
619 | void XmlResApp::MakePackageCPP(const wxArrayString& flist) | |
620 | { | |
5851504d | 621 | wxFFile file(parOutput, wxT("wt")); |
9b1aeed1 | 622 | unsigned i; |
56d2f750 | 623 | |
f80ea77b | 624 | if (flagVerbose) |
9a83f860 | 625 | wxPrintf(wxT("creating C++ source file ") + parOutput + wxT("...\n")); |
f80ea77b | 626 | |
5881d27b VS |
627 | file.Write("" |
628 | "//\n" | |
629 | "// This file was automatically generated by wxrc, do not edit by hand.\n" | |
630 | "//\n\n" | |
631 | "#include <wx/wxprec.h>\n" | |
632 | "\n" | |
633 | "#ifdef __BORLANDC__\n" | |
634 | " #pragma hdrstop\n" | |
635 | "#endif\n" | |
636 | "\n" | |
637 | "" | |
638 | "#include <wx/filesys.h>\n" | |
639 | "#include <wx/fs_mem.h>\n" | |
640 | "#include <wx/xrc/xmlres.h>\n" | |
641 | "#include <wx/xrc/xh_all.h>\n" | |
642 | "\n" | |
643 | "#if wxCHECK_VERSION(2,8,5) && wxABI_VERSION >= 20805\n" | |
644 | " #define XRC_ADD_FILE(name, data, size, mime) \\\n" | |
645 | " wxMemoryFSHandler::AddFileWithMimeType(name, data, size, mime)\n" | |
646 | "#else\n" | |
647 | " #define XRC_ADD_FILE(name, data, size, mime) \\\n" | |
648 | " wxMemoryFSHandler::AddFile(name, data, size)\n" | |
649 | "#endif\n" | |
650 | "\n"); | |
56d2f750 | 651 | |
b4a980f4 | 652 | for (i = 0; i < flist.GetCount(); i++) |
4249ec2c VS |
653 | file.Write( |
654 | FileToCppArray(parOutputPath + wxFILE_SEP_PATH + flist[i], i)); | |
f80ea77b | 655 | |
5881d27b | 656 | file.Write("" |
09f01082 | 657 | "void " + parFuncname + "()\n" |
5881d27b VS |
658 | "{\n" |
659 | "\n" | |
660 | " // Check for memory FS. If not present, load the handler:\n" | |
661 | " {\n" | |
662 | " wxMemoryFSHandler::AddFile(wxT(\"XRC_resource/dummy_file\"), wxT(\"dummy one\"));\n" | |
663 | " wxFileSystem fsys;\n" | |
664 | " wxFSFile *f = fsys.OpenFile(wxT(\"memory:XRC_resource/dummy_file\"));\n" | |
665 | " wxMemoryFSHandler::RemoveFile(wxT(\"XRC_resource/dummy_file\"));\n" | |
666 | " if (f) delete f;\n" | |
667 | " else wxFileSystem::AddHandler(new wxMemoryFSHandler);\n" | |
668 | " }\n" | |
669 | "\n"); | |
56d2f750 | 670 | |
b4a980f4 | 671 | for (i = 0; i < flist.GetCount(); i++) |
56d2f750 VS |
672 | { |
673 | wxString s; | |
c5d7b81e VS |
674 | |
675 | wxString mime; | |
676 | wxString ext = wxFileName(flist[i]).GetExt(); | |
9a83f860 VZ |
677 | if ( ext.Lower() == wxT("xrc") ) |
678 | mime = wxT("text/xml"); | |
e74f1202 | 679 | #if wxUSE_MIMETYPE |
c5d7b81e VS |
680 | else |
681 | { | |
682 | wxFileType *ft = wxTheMimeTypesManager->GetFileTypeFromExtension(ext); | |
683 | if ( ft ) | |
e74f1202 | 684 | { |
c5d7b81e | 685 | ft->GetMimeType(&mime); |
e74f1202 VZ |
686 | delete ft; |
687 | } | |
c5d7b81e | 688 | } |
e74f1202 | 689 | #endif // wxUSE_MIMETYPE |
c5d7b81e | 690 | |
5881d27b | 691 | s.Printf(" XRC_ADD_FILE(wxT(\"XRC_resource/" + flist[i] + |
9b1aeed1 | 692 | "\"), xml_res_file_%u, xml_res_size_%u, wxT(\"%s\"));\n", |
c5d7b81e | 693 | i, i, mime.c_str()); |
56d2f750 VS |
694 | file.Write(s); |
695 | } | |
f6853b4a | 696 | |
b4a980f4 | 697 | for (i = 0; i < parFiles.GetCount(); i++) |
f6853b4a | 698 | { |
5881d27b VS |
699 | file.Write(" wxXmlResource::Get()->Load(wxT(\"memory:XRC_resource/" + |
700 | GetInternalFileName(parFiles[i], flist) + "\"));\n"); | |
f6853b4a | 701 | } |
f80ea77b | 702 | |
5881d27b | 703 | file.Write("}\n"); |
56d2f750 | 704 | |
f6853b4a | 705 | |
56d2f750 | 706 | } |
c8b7a961 | 707 | |
1dce6f09 VS |
708 | void XmlResApp::GenCPPHeader() |
709 | { | |
21567b09 VZ |
710 | // Generate the output header in the same directory as the source file. |
711 | wxFileName headerName(parOutput); | |
712 | headerName.SetExt("h"); | |
f80ea77b | 713 | |
21567b09 | 714 | wxFFile file(headerName.GetFullPath(), wxT("wt")); |
1dce6f09 | 715 | file.Write( |
5881d27b VS |
716 | "//\n" |
717 | "// This file was automatically generated by wxrc, do not edit by hand.\n" | |
718 | "//\n\n" | |
21567b09 VZ |
719 | "#ifndef __" + headerName.GetName() + "_h__\n" |
720 | "#define __" + headerName.GetName() + "_h__\n" | |
f80ea77b | 721 | ); |
b4a980f4 | 722 | for(size_t i=0;i<aXRCWndClassData.GetCount();++i){ |
f80ea77b WS |
723 | aXRCWndClassData.Item(i).GenerateHeaderCode(file); |
724 | } | |
1dce6f09 | 725 | file.Write( |
5881d27b | 726 | "\nvoid \n" |
aa063b24 | 727 | + parFuncname |
5881d27b | 728 | + "();\n#endif\n"); |
1dce6f09 VS |
729 | } |
730 | ||
b8b8c49b VS |
731 | static wxString FileToPythonArray(wxString filename, int num) |
732 | { | |
733 | wxString output; | |
734 | wxString tmp; | |
735 | wxString snum; | |
5851504d | 736 | wxFFile file(filename, wxT("rb")); |
2ad1ff54 WS |
737 | wxFileOffset offset = file.Length(); |
738 | wxASSERT_MSG( offset >= 0 , wxT("Invalid file length") ); | |
17a1ebd1 VZ |
739 | |
740 | const size_t lng = wx_truncate_cast(size_t, offset); | |
81d3348a | 741 | wxASSERT_MSG( static_cast<wxFileOffset>(lng) == offset, |
563a24f0 | 742 | wxT("Huge file not supported") ); |
f80ea77b | 743 | |
9a83f860 | 744 | snum.Printf(wxT("%i"), num); |
09f01082 | 745 | output = " xml_res_file_" + snum + " = '''\\\n"; |
f80ea77b | 746 | |
b8b8c49b VS |
747 | unsigned char *buffer = new unsigned char[lng]; |
748 | file.Read(buffer, lng); | |
f80ea77b | 749 | |
b8b8c49b VS |
750 | for (size_t i = 0, linelng = 0; i < lng; i++) |
751 | { | |
752 | unsigned char c = buffer[i]; | |
753 | if (c == '\n') | |
754 | { | |
755 | tmp = (wxChar)c; | |
756 | linelng = 0; | |
757 | } | |
9a9942f7 | 758 | else if (c < 32 || c > 127 || c == '\'') |
9a83f860 | 759 | tmp.Printf(wxT("\\x%02x"), c); |
b8b8c49b | 760 | else if (c == '\\') |
9a83f860 | 761 | tmp = wxT("\\\\"); |
b8b8c49b VS |
762 | else |
763 | tmp = (wxChar)c; | |
764 | if (linelng > 70) | |
765 | { | |
766 | linelng = 0; | |
9a83f860 | 767 | output << wxT("\\\n"); |
b8b8c49b VS |
768 | } |
769 | output << tmp; | |
770 | linelng += tmp.Length(); | |
771 | } | |
f80ea77b | 772 | |
b8b8c49b | 773 | delete[] buffer; |
f80ea77b | 774 | |
9a83f860 | 775 | output += wxT("'''\n\n"); |
f80ea77b | 776 | |
b8b8c49b VS |
777 | return output; |
778 | } | |
779 | ||
780 | ||
781 | void XmlResApp::MakePackagePython(const wxArrayString& flist) | |
782 | { | |
5851504d | 783 | wxFFile file(parOutput, wxT("wt")); |
9b1aeed1 | 784 | unsigned i; |
b8b8c49b | 785 | |
f80ea77b | 786 | if (flagVerbose) |
9a83f860 | 787 | wxPrintf(wxT("creating Python source file ") + parOutput + wxT("...\n")); |
f80ea77b | 788 | |
b8b8c49b | 789 | file.Write( |
5881d27b VS |
790 | "#\n" |
791 | "# This file was automatically generated by wxrc, do not edit by hand.\n" | |
792 | "#\n\n" | |
793 | "import wx\n" | |
794 | "import wx.xrc\n\n" | |
b8b8c49b VS |
795 | ); |
796 | ||
f80ea77b | 797 | |
09f01082 | 798 | file.Write("def " + parFuncname + "():\n"); |
b8b8c49b | 799 | |
b4a980f4 | 800 | for (i = 0; i < flist.GetCount(); i++) |
4249ec2c VS |
801 | file.Write( |
802 | FileToPythonArray(parOutputPath + wxFILE_SEP_PATH + flist[i], i)); | |
b8b8c49b | 803 | |
2ad1ff54 | 804 | file.Write( |
5881d27b VS |
805 | " # check if the memory filesystem handler has been loaded yet, and load it if not\n" |
806 | " wx.MemoryFSHandler.AddFile('XRC_resource/dummy_file', 'dummy value')\n" | |
807 | " fsys = wx.FileSystem()\n" | |
808 | " f = fsys.OpenFile('memory:XRC_resource/dummy_file')\n" | |
809 | " wx.MemoryFSHandler.RemoveFile('XRC_resource/dummy_file')\n" | |
810 | " if f is not None:\n" | |
811 | " f.Destroy()\n" | |
812 | " else:\n" | |
813 | " wx.FileSystem.AddHandler(wx.MemoryFSHandler())\n" | |
814 | "\n" | |
815 | " # load all the strings as memory files and load into XmlRes\n" | |
b27a4ef4 RD |
816 | ); |
817 | ||
2ad1ff54 | 818 | |
b4a980f4 | 819 | for (i = 0; i < flist.GetCount(); i++) |
b8b8c49b VS |
820 | { |
821 | wxString s; | |
5881d27b | 822 | s.Printf(" wx.MemoryFSHandler.AddFile('XRC_resource/" + flist[i] + |
9b1aeed1 | 823 | "', xml_res_file_%u)\n", i); |
b8b8c49b VS |
824 | file.Write(s); |
825 | } | |
b4a980f4 | 826 | for (i = 0; i < parFiles.GetCount(); i++) |
b27a4ef4 | 827 | { |
5881d27b VS |
828 | file.Write(" wx.xrc.XmlResource.Get().Load('memory:XRC_resource/" + |
829 | GetInternalFileName(parFiles[i], flist) + "')\n"); | |
b27a4ef4 RD |
830 | } |
831 | ||
5881d27b | 832 | file.Write("\n"); |
b8b8c49b VS |
833 | } |
834 | ||
c8b7a961 VS |
835 | |
836 | ||
837 | void XmlResApp::OutputGettext() | |
838 | { | |
21b2dde5 | 839 | ExtractedStrings str = FindStrings(); |
f80ea77b | 840 | |
c8b7a961 | 841 | wxFFile fout; |
1dce6f09 VS |
842 | if (parOutput.empty()) |
843 | fout.Attach(stdout); | |
844 | else | |
845 | fout.Open(parOutput, wxT("wt")); | |
f80ea77b | 846 | |
21b2dde5 VS |
847 | for (ExtractedStrings::const_iterator i = str.begin(); i != str.end(); ++i) |
848 | { | |
0d373eac VS |
849 | const wxFileName filename(i->filename); |
850 | ||
21b2dde5 | 851 | wxString s; |
0d373eac VS |
852 | s.Printf("#line %d \"%s\"\n", |
853 | i->lineNo, filename.GetFullPath(wxPATH_UNIX)); | |
21b2dde5 | 854 | |
21b2dde5 VS |
855 | fout.Write(s); |
856 | fout.Write("_(\"" + i->str + "\");\n"); | |
857 | } | |
f80ea77b | 858 | |
c8b7a961 VS |
859 | if (!parOutput) fout.Detach(); |
860 | } | |
861 | ||
862 | ||
863 | ||
21b2dde5 | 864 | ExtractedStrings XmlResApp::FindStrings() |
c8b7a961 | 865 | { |
21b2dde5 | 866 | ExtractedStrings arr, a2; |
c8b7a961 | 867 | |
b4a980f4 | 868 | for (size_t i = 0; i < parFiles.GetCount(); i++) |
c8b7a961 | 869 | { |
f80ea77b | 870 | if (flagVerbose) |
9a83f860 | 871 | wxPrintf(wxT("processing ") + parFiles[i] + wxT("...\n")); |
c8b7a961 | 872 | |
f80ea77b | 873 | wxXmlDocument doc; |
c8b7a961 VS |
874 | if (!doc.Load(parFiles[i])) |
875 | { | |
9a83f860 | 876 | wxLogError(wxT("Error parsing file ") + parFiles[i]); |
c8b7a961 VS |
877 | retCode = 1; |
878 | continue; | |
879 | } | |
21b2dde5 VS |
880 | a2 = FindStrings(parFiles[i], doc.GetRoot()); |
881 | ||
c8b7a961 VS |
882 | WX_APPEND_ARRAY(arr, a2); |
883 | } | |
f80ea77b | 884 | |
c8b7a961 VS |
885 | return arr; |
886 | } | |
887 | ||
888 | ||
889 | ||
c109ef11 VS |
890 | static wxString ConvertText(const wxString& str) |
891 | { | |
892 | wxString str2; | |
893 | const wxChar *dt; | |
894 | ||
895 | for (dt = str.c_str(); *dt; dt++) | |
896 | { | |
897 | if (*dt == wxT('_')) | |
898 | { | |
899 | if ( *(++dt) == wxT('_') ) | |
900 | str2 << wxT('_'); | |
901 | else | |
902 | str2 << wxT('&') << *dt; | |
903 | } | |
f80ea77b | 904 | else |
c109ef11 VS |
905 | { |
906 | switch (*dt) | |
907 | { | |
908 | case wxT('\n') : str2 << wxT("\\n"); break; | |
909 | case wxT('\t') : str2 << wxT("\\t"); break; | |
910 | case wxT('\r') : str2 << wxT("\\r"); break; | |
2b5f62a0 VZ |
911 | case wxT('\\') : if ((*(dt+1) != 'n') && |
912 | (*(dt+1) != 't') && | |
913 | (*(dt+1) != 'r')) | |
914 | str2 << wxT("\\\\"); | |
915 | else | |
f80ea77b | 916 | str2 << wxT("\\"); |
2b5f62a0 | 917 | break; |
904a226c | 918 | case wxT('"') : str2 << wxT("\\\""); break; |
c109ef11 VS |
919 | default : str2 << *dt; break; |
920 | } | |
921 | } | |
922 | } | |
923 | ||
924 | return str2; | |
925 | } | |
926 | ||
927 | ||
21b2dde5 VS |
928 | ExtractedStrings |
929 | XmlResApp::FindStrings(const wxString& filename, wxXmlNode *node) | |
c8b7a961 | 930 | { |
21b2dde5 | 931 | ExtractedStrings arr; |
c8b7a961 VS |
932 | |
933 | wxXmlNode *n = node; | |
934 | if (n == NULL) return arr; | |
935 | n = n->GetChildren(); | |
f80ea77b | 936 | |
c8b7a961 VS |
937 | while (n) |
938 | { | |
939 | if ((node->GetType() == wxXML_ELEMENT_NODE) && | |
940 | // parent is an element, i.e. has subnodes... | |
f80ea77b | 941 | (n->GetType() == wxXML_TEXT_NODE || |
c8b7a961 VS |
942 | n->GetType() == wxXML_CDATA_SECTION_NODE) && |
943 | // ...it is textnode... | |
944 | ( | |
9a83f860 VZ |
945 | node/*not n!*/->GetName() == wxT("label") || |
946 | (node/*not n!*/->GetName() == wxT("value") && | |
c8b7a961 | 947 | !n->GetContent().IsNumber()) || |
9a83f860 VZ |
948 | node/*not n!*/->GetName() == wxT("help") || |
949 | node/*not n!*/->GetName() == wxT("longhelp") || | |
950 | node/*not n!*/->GetName() == wxT("tooltip") || | |
951 | node/*not n!*/->GetName() == wxT("htmlcode") || | |
952 | node/*not n!*/->GetName() == wxT("title") || | |
953 | node/*not n!*/->GetName() == wxT("item") | |
c8b7a961 | 954 | )) |
c109ef11 | 955 | // ...and known to contain translatable string |
c8b7a961 | 956 | { |
8da9d91c | 957 | if (!flagGettext || |
9a83f860 | 958 | node->GetAttribute(wxT("translate"), wxT("1")) != wxT("0")) |
8da9d91c | 959 | { |
21b2dde5 VS |
960 | arr.push_back |
961 | ( | |
962 | ExtractedString | |
963 | ( | |
964 | ConvertText(n->GetContent()), | |
965 | filename, | |
966 | n->GetLineNumber() | |
967 | ) | |
968 | ); | |
8da9d91c | 969 | } |
c8b7a961 | 970 | } |
f80ea77b | 971 | |
c8b7a961 VS |
972 | // subnodes: |
973 | if (n->GetType() == wxXML_ELEMENT_NODE) | |
974 | { | |
21b2dde5 | 975 | ExtractedStrings a2 = FindStrings(filename, n); |
c8b7a961 VS |
976 | WX_APPEND_ARRAY(arr, a2); |
977 | } | |
f80ea77b | 978 | |
c8b7a961 VS |
979 | n = n->GetNext(); |
980 | } | |
981 | return arr; | |
982 | } |