0e05ad0f200f76ba3a221de8d3f6385669405d30
[pandora-libraries.git] / lib / pnd_tinyxml.cpp
1
2 #include <stdio.h>
3 #include "tinyxml/tinyxml.h"
4 #include "../include/pnd_pxml.h"
5 #include "pnd_tinyxml.h"
6 #include "pnd_logger.h"
7
8 //Easily change the tag names if required (globally in this file):
9 #include "pnd_pxml_names.h"
10
11 extern "C" {
12
13 char *pnd_pxml_get_attribute(TiXmlElement *elem, const char *name)
14 {
15         const char *value = elem->Attribute(name);
16         if (value)
17                 return strdup(value);
18         else
19                 return NULL;
20 }
21
22 unsigned char pnd_pxml_parse_titles(const TiXmlHandle hRoot, pnd_pxml_t *app) {
23   TiXmlElement *pElem;
24   app->titles_alloc_c = 4;  //TODO: adjust this based on how many titles a PXML usually has. Power of 2.
25
26   app->titles = (pnd_localized_string_t *)malloc(sizeof(pnd_localized_string_t) * app->titles_alloc_c);
27   if (!app->titles) return (0); //errno = NOMEM
28
29   //Go through all title tags and load them.
30   for (pElem = hRoot.FirstChild(PND_PXML_ENAME_TITLE).Element(); pElem;
31        pElem = pElem->NextSiblingElement(PND_PXML_ENAME_TITLE))
32   {
33
34     if ( ! pElem->GetText() ) {
35       continue;
36     }
37
38     char *text = strdup(pElem->GetText());
39     if (!text) continue;
40
41     char *lang = pnd_pxml_get_attribute(pElem, PND_PXML_ATTRNAME_TITLELANG);
42     if (!lang) continue;
43
44     app->titles_c++;
45     if (app->titles_c > app->titles_alloc_c) //we don't have enough strings allocated
46     {
47       app->titles_alloc_c <<= 1;
48       app->titles = (pnd_localized_string_t *)realloc((void*)app->titles, app->titles_alloc_c);
49       if (!app->titles) return (0); //errno = ENOMEM
50     }
51
52     pnd_localized_string_t *title = &app->titles[app->titles_c - 1];
53     title->language = lang;
54     title->string = text;
55
56     pnd_log ( PND_LOG_DEFAULT, (char*)"    Title/Lang: %s/%s\n", text, lang );
57
58   }
59
60   return ( 1 );
61 }
62
63 unsigned char pnd_pxml_parse_descriptions(const TiXmlHandle hRoot, pnd_pxml_t *app)
64 {
65         TiXmlElement *pElem;
66         app->descriptions_alloc_c = 4; //TODO: adjust this based on how many descriptions a PXML usually has. Power of 2.
67
68         app->descriptions = (pnd_localized_string_t *)malloc(sizeof(pnd_localized_string_t) * app->descriptions_alloc_c);
69         if (!app->descriptions) 
70         {
71                 app->descriptions_alloc_c = 0;
72                 return (0); //errno = NOMEM
73         }
74
75         for (pElem = hRoot.FirstChild(PND_PXML_ENAME_DESCRIPTION).Element(); pElem; 
76                 pElem = pElem->NextSiblingElement(PND_PXML_ENAME_DESCRIPTION))
77         {
78
79           if ( ! pElem->GetText() ) {
80             continue;
81           }
82
83                 char *text = strdup(pElem->GetText());
84                 if (!text) continue;
85
86                 char *lang = pnd_pxml_get_attribute(pElem, PND_PXML_ATTRNAME_DESCRLANG);
87                 if (!lang) continue;
88
89                 app->descriptions_c++;
90                 if (app->descriptions_c > app->descriptions_alloc_c) //we don't have enough strings allocated
91                 {
92                         app->descriptions_alloc_c <<= 1;
93                         app->descriptions = (pnd_localized_string_t*)realloc((void*)app->descriptions, app->descriptions_alloc_c);
94                         if (!app->descriptions) return (0); //errno = ENOMEM
95                 }
96
97                 pnd_localized_string_t *description = &app->descriptions[app->descriptions_c - 1];
98                 description->language = lang;
99                 description->string = text;
100         }
101         return (1);
102 }
103
104 unsigned char pnd_pxml_parse ( const char *pFilename, char *buffer, unsigned int length, pnd_pxml_t **apps ) {
105
106   //Load the XML document
107   TiXmlDocument doc;
108   doc.Parse(buffer);
109
110   unsigned char appwrappermode = 0; // >=1 -> using <application>...</application> wrapper
111   unsigned char appcount = 0;
112   pnd_pxml_t *app = NULL;
113
114   TiXmlElement *pElem = NULL;
115   TiXmlElement *appElem = NULL;
116
117   //Find the root element
118   TiXmlHandle hDoc(&doc);
119   TiXmlHandle hRoot(0);
120
121   pElem = hDoc.FirstChild("PXML").Element();
122   if (!pElem) return (0);
123
124   // new Strategy; really, we want multiple app support within a PXML, without the lameness of
125   // multiple <PXML>..</PXML> within a single PXML.xml file. As such, we should have an app within
126   // an <application>..</application> wrapper level, with the ID on that. Further, the icon and
127   // .desktop filenames can have a # appended which is the application-count-# within the PXML,
128   // so that they can have their own .desktop and icon without collisions, but still use the
129   // same unique-id if they want to.
130   //   To avoid breaking existing PXML's (even though we're pre-launch), can detect if ID
131   // is present in PXML line or not; if not, assume application mode?
132   hRoot = TiXmlHandle(pElem);
133
134   if ( hRoot.FirstChild(PND_PXML_APP).Element() != NULL ) {
135     appwrappermode = 1;
136     appElem = hRoot.FirstChild(PND_PXML_APP).Element();
137     hRoot = TiXmlHandle ( appElem );
138   }
139
140   // until we run out of applications in the PXML..
141   while ( 1 ) {
142
143     pnd_log ( PND_LOG_DEFAULT, (char*)"  App #%u inside of PXML %s\n", appcount, pFilename );
144
145     // create the buffer to hold the pxml
146     apps [ appcount ] = (pnd_pxml_t*) malloc ( sizeof(pnd_pxml_t) );
147     memset ( apps [ appcount ], '\0', sizeof(pnd_pxml_t) );
148
149     // due to old code, just make life easier a minute..
150     app = apps [ appcount ];
151     if ( appwrappermode ) {
152       app -> subapp_number = appcount;
153     } else {
154       app -> subapp_number = 0;
155     }
156
157     //Get unique ID first.
158     if ( appwrappermode ) {
159       app->unique_id = pnd_pxml_get_attribute(appElem, PND_PXML_ATTRNAME_UID);
160       pnd_log ( PND_LOG_DEFAULT, (char*)"  Subapp #%u has unique_id %s\n", appcount, app -> unique_id );
161     } else {
162       app->unique_id = pnd_pxml_get_attribute(hRoot.Element(), PND_PXML_ATTRNAME_UID);
163       pnd_log ( PND_LOG_DEFAULT, (char*)"  Only-app #%u has unique_id %s\n", appcount, app -> unique_id );
164     }
165
166     //Everything related to the title:
167     pnd_pxml_parse_titles(hRoot, app);
168
169     //Everything description-related:
170     pnd_pxml_parse_descriptions(hRoot, app);
171
172     //Everything launcher-related in one tag:
173     if ( (pElem = hRoot.FirstChild(PND_PXML_ENAME_EXEC).Element()) )
174      {
175        app->background = pnd_pxml_get_attribute(pElem, PND_PXML_ATTRNAME_EXECBG); //if this returns NULL, the struct is filled with NULL. No need to check.
176        app->standalone = pnd_pxml_get_attribute(pElem, PND_PXML_ATTRNAME_EXECSTAL);
177        app->exec       = pnd_pxml_get_attribute(pElem, PND_PXML_ATTRNAME_EXECCMD);
178        app->startdir   = pnd_pxml_get_attribute(pElem, PND_PXML_ATTRNAME_EXECWD);
179        app->exec_no_x11     = pnd_pxml_get_attribute(pElem, PND_PXML_ATTRNAME_EXECNOX11);
180        app->execargs   = pnd_pxml_get_attribute(pElem, PND_PXML_ATTRNAME_EXECARGS);
181      }
182
183     //The app icon:
184     if ( (pElem = hRoot.FirstChild(PND_PXML_ENAME_ICON).Element()) ) {
185       app->icon       = pnd_pxml_get_attribute(pElem, PND_PXML_ATTRNAME_ICONSRC);
186     }
187
188     //The preview pics:
189     if ( (pElem = hRoot.FirstChild(PND_PXML_NODENAME_PREVPICS).Element()) )
190     {
191       //TODO: Change this if pnd_pxml_t gains the feature of more pics than 2.
192       if ( (pElem = pElem->FirstChildElement(PND_PXML_ENAME_PREVPIC)) )
193       {
194         app->previewpic1 = pnd_pxml_get_attribute(pElem, PND_PXML_ATTRNAME_PREVPICSRC);
195
196         if ( (pElem = pElem->NextSiblingElement(PND_PXML_ENAME_PREVPIC)) )
197         {
198           app->previewpic2 = pnd_pxml_get_attribute(pElem, PND_PXML_ATTRNAME_PREVPICSRC);
199         }
200       } 
201     } //previewpic
202
203     //The author info:
204     if ( (pElem = hRoot.FirstChild(PND_PXML_ENAME_AUTHOR).Element()) )
205     {
206       app->author_name    = pnd_pxml_get_attribute(pElem, PND_PXML_ATTRNAME_AUTHORNAME);
207       app->author_website = pnd_pxml_get_attribute(pElem, PND_PXML_ATTRNAME_AUTHORWWW);
208       //TODO: Uncomment this if the author gets email support.
209       //app->author_email = pnd_pxml_get_attribute(pElem, PND_PXML_ATTRNAME_AUTHOREMAIL));
210     }
211
212     //The version info:
213     if ( (pElem = hRoot.FirstChild(PND_PXML_ENAME_VERSION).Element()) )
214     {
215       app->version_major   = pnd_pxml_get_attribute(pElem, PND_PXML_ATTRNAME_VERMAJOR);
216       app->version_minor   = pnd_pxml_get_attribute(pElem, PND_PXML_ATTRNAME_VERMINOR);
217       app->version_release = pnd_pxml_get_attribute(pElem, PND_PXML_ATTRNAME_VERREL);
218       app->version_build   = pnd_pxml_get_attribute(pElem, PND_PXML_ATTRNAME_VERBUILD);
219     }
220
221     //The OS version info:
222     if ( (pElem = hRoot.FirstChild(PND_PXML_ENAME_OSVERSION).Element()) )
223     {
224       app->osversion_major   = pnd_pxml_get_attribute(pElem, PND_PXML_ATTRNAME_OSVERMAJOR);
225       app->osversion_minor   = pnd_pxml_get_attribute(pElem, PND_PXML_ATTRNAME_OSVERMINOR);
226       app->osversion_release = pnd_pxml_get_attribute(pElem, PND_PXML_ATTRNAME_OSVERREL);
227       app->osversion_build   = pnd_pxml_get_attribute(pElem, PND_PXML_ATTRNAME_OSVERBUILD);
228     }
229
230     int i; //For now, we need to keep track of the index of categories.
231     //Categories:
232     if ( (pElem = hRoot.FirstChildElement(PND_PXML_NODENAME_CATS).Element()) ) //First, enter the "categories" node.
233     {
234       i = 0;
235
236       //Goes through all the top-level categories and their sub-categories. i helps limit these to 2.
237       for (pElem = pElem->FirstChildElement(PND_PXML_ENAME_CAT); pElem && i < 2; 
238            pElem = pElem->NextSiblingElement(PND_PXML_ENAME_CAT), i++)
239       {
240         //TODO: Fix pnd_pxml_t so that there can be more than 2 category 'trees' and more than 2 subcategories. Then this can be removed.
241         switch (i)
242         {
243         case 0: //first category counts as the main cat for now
244           app->main_category = pnd_pxml_get_attribute(pElem, PND_PXML_ATTRNAME_CATNAME);
245           break;
246
247         case 1: //...second as the alternative
248           app->altcategory = pnd_pxml_get_attribute(pElem, PND_PXML_ATTRNAME_CATNAME);
249         }
250
251         TiXmlElement *pSubCatElem; //the sub-elements for a main category.
252         int j = 0; //the subcategory index within this category
253
254         //Goes through all the subcategories within this category. j helps limit these to 2.
255         for (pSubCatElem = pElem->FirstChildElement(PND_PXML_ENAME_SUBCAT); pSubCatElem && j < 2;
256              pSubCatElem = pSubCatElem->NextSiblingElement(PND_PXML_ENAME_SUBCAT), j++)
257         {
258           char *subcat = pnd_pxml_get_attribute(pSubCatElem, PND_PXML_ATTRNAME_SUBCATNAME);
259           if (!(subcat)) continue;
260
261           //TODO: This is ugly. Fix pnd_pxml_t so that there can be more than 2 category 'trees' and more than 2 subcategories. Then this can be removed.
262           switch (j | (i << 1))
263           {
264           case 0:
265             app->subcategory1 = subcat;
266             break;
267           case 1:
268             app->subcategory2 = subcat;
269             break;
270           case 2:
271             app->altsubcategory1 = subcat;
272             break;
273           case 3:
274             app->altsubcategory2 = subcat;
275           }
276         }
277       }
278     }
279
280     //All file associations:
281     //Step into the associations node
282     if ( (pElem = hRoot.FirstChild(PND_PXML_NODENAME_ASSOCS).Element()) )
283     {
284       i = 0;
285       //Go through all associations. i serves as index; since the format only supports 3 associations we need to keep track of the number.
286       for (pElem = pElem->FirstChildElement(PND_PXML_ENAME_ASSOC); pElem && i < 3; 
287            pElem = pElem->NextSiblingElement(PND_PXML_ENAME_ASSOC), i++)
288       {
289         char *name = pnd_pxml_get_attribute(pElem, PND_PXML_ATTRNAME_ASSOCNAME);
290         char *filetype = pnd_pxml_get_attribute(pElem, PND_PXML_ATTRNAME_ASSOCFTYPE);
291         char *paramter = pnd_pxml_get_attribute(pElem, PND_PXML_ATTRNAME_ASSOCARGS);
292
293         if (!(name && filetype && paramter)) continue;
294
295         switch(i) //TODO: same problem here: only 3 associations supported
296         {
297         case 0:
298         {
299           app->associationitem1_name      = name;
300           app->associationitem1_filetype  = filetype;
301           app->associationitem1_parameter = paramter;
302           break;
303         }
304         case 1:
305         {
306           app->associationitem2_name      = name;
307           app->associationitem2_filetype  = filetype;
308           app->associationitem2_parameter = paramter;
309           break;
310         }
311         case 2:
312         {
313           app->associationitem3_name      = name;
314           app->associationitem3_filetype  = filetype;
315           app->associationitem3_parameter = paramter;
316         }
317         }
318       }
319     }
320
321     //Performance related things (aka: Clockspeed XD):
322     pElem = hRoot.FirstChild(PND_PXML_ENAME_CLOCK).Element();
323     if (pElem)
324     {   
325       app->clockspeed = pnd_pxml_get_attribute(pElem, PND_PXML_ATTRNAME_CLOCKFREQ);
326     }
327
328     // Package
329     pElem = hRoot.FirstChild ( PND_PXML_ENAME_PACKAGE ).Element();
330     if ( pElem ) {      
331       app -> package_name = pnd_pxml_get_attribute ( pElem, PND_PXML_ATTRNAME_PACKAGE_NAME );
332       app -> package_release_date = pnd_pxml_get_attribute ( pElem, PND_PXML_ATTRNAME_PACKAGE_DATE );
333     }
334
335     // mkdir request
336     if ( (pElem = hRoot.FirstChild(PND_PXML_NODENAME_MKDIR).Element()) ) {
337
338       // seek <dir>
339       if ( (pElem = pElem->FirstChildElement(PND_PXML_ENAME_MKDIR)) ) {
340         char *t;
341
342         if ( ( t = pnd_pxml_get_attribute(pElem, PND_PXML_ATTRNAME_MKDIRPATH) ) ) {
343           // first <dir>, so just replace it wholesale; we use strdup so we can free() easily later, consistently. Mmm, leak seems imminent.
344           app -> mkdir_sp = strdup ( t );
345         }
346
347         while ( ( pElem = pElem -> NextSiblingElement ( PND_PXML_ENAME_MKDIR ) ) ) {
348               
349           if ( ( t = pnd_pxml_get_attribute(pElem, PND_PXML_ATTRNAME_MKDIRPATH) ) ) {
350             char *foo = (char*) malloc ( strlen ( app -> mkdir_sp ) + strlen ( t ) + 1 /*:*/ + 1 /*\0*/ );
351
352             if ( foo ) {
353               sprintf ( foo, "%s:%s", app -> mkdir_sp, t );
354               free ( app -> mkdir_sp );
355               app -> mkdir_sp = foo;
356             } // assuming we got ram, lets cat it all together
357
358           } // got another elem?
359
360         } // while
361
362       } // found a <dir>
363
364 #if 0
365       if ( app -> mkdir_sp ) {
366         printf ( "mkdir: %s\n", app -> mkdir_sp );
367       }
368 #endif
369
370     } // mkdir
371
372     // if in <application> mode, do we find another app?
373     if ( appwrappermode ) {
374       appElem = appElem -> NextSiblingElement ( PND_PXML_APP );
375       if ( ! appElem ) {
376         pnd_log ( PND_LOG_DEFAULT, (char*)"  No more applications within PXML\n" );
377         break; // no more applications
378       }
379       // got another application..
380       //pnd_log ( PND_LOG_DEFAULT, "  Found another applications within PXML\n" );
381       appwrappermode++;
382       hRoot = TiXmlHandle ( appElem );
383
384       appcount++;
385
386       if ( appcount == PXML_MAXAPPS ) {
387         return ( 1 ); // thats all we can handle; we're not going to auto-extend this
388       }
389
390     } else {
391       break; // single-app old PXML
392     }
393
394   } // while finding apps
395
396   return (1);
397 }
398
399 } // extern C