← Back to branch summary

~ubuntu-branches/ubuntu/trusty/gcompris/trusty

« back to all changes in this revision

Viewing changes to src/gcompris/skin.c

  • Committer: Bazaar Package Importer
  • Author(s): Yann Dirson
  • Date: 2006-12-15 23:08:17 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20061215230817-exr5ks1hd73s3tlk
Tags: 8.2.2-1
http://bugs.debian.org/396523
* New upstream bugfix release, fixes among other things the support for
  the version of gnucap shipped in etch.
* Add missing dependency on python-gtk2 (Closes: #396523).
* Removed reference to non-existent sound file from memory.c (upstream
  fix - impacts 8.2 as well).  
* Now suggests gnuchess, gnucap, and tuxpaint.
* Updated extended description for the main package.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gcompris/skin.c
16
16
 *   along with this program; if not, write to the Free Software
17
17
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
18
 */
19
 
 
 
19
 
 
20
#include "string.h"
 
21
 
20
22
#include "skin.h"
21
23
#include <libxml/tree.h>
22
24
#include <libxml/parser.h>
23
25
 
24
 
GHashTable* gcompris_skin_fonts = NULL;
25
 
GHashTable* gcompris_skin_colors = NULL;
26
 
 
27
 
guint32 gcompris_skin_color_title;
28
 
guint32 gcompris_skin_color_text_button;
29
 
guint32 gcompris_skin_color_content;
30
 
guint32 gcompris_skin_color_subtitle;
31
 
 
32
 
gchar* gcompris_skin_font_title;
33
 
gchar* gcompris_skin_font_subtitle;
34
 
gchar* gcompris_skin_font_content;
35
 
 
36
 
gchar* gcompris_skin_font_board_tiny;
37
 
gchar* gcompris_skin_font_board_small;
38
 
gchar* gcompris_skin_font_board_medium;
39
 
gchar* gcompris_skin_font_board_big;
40
 
gchar* gcompris_skin_font_board_big_bold;
41
 
gchar* gcompris_skin_font_board_fixed;
42
 
gchar* gcompris_skin_font_board_title;
43
 
gchar* gcompris_skin_font_board_title_bold;
44
 
gchar* gcompris_skin_font_board_huge;
45
 
gchar* gcompris_skin_font_board_huge_bold;
 
26
GHashTable* gc_skin_fonts   = NULL;
 
27
GHashTable* gc_skin_colors  = NULL;
 
28
GHashTable* gc_skin_numbers = NULL;
 
29
 
 
30
guint32 gc_skin_color_title;
 
31
guint32 gc_skin_color_text_button;
 
32
guint32 gc_skin_color_content;
 
33
guint32 gc_skin_color_subtitle;
 
34
guint32 gc_skin_color_shadow;
 
35
 
 
36
gchar* gc_skin_font_title;
 
37
gchar* gc_skin_font_subtitle;
 
38
gchar* gc_skin_font_content;
 
39
 
 
40
gchar* gc_skin_font_board_tiny;
 
41
gchar* gc_skin_font_board_small;
 
42
gchar* gc_skin_font_board_medium;
 
43
gchar* gc_skin_font_board_big;
 
44
gchar* gc_skin_font_board_big_bold;
 
45
gchar* gc_skin_font_board_fixed;
 
46
gchar* gc_skin_font_board_title;
 
47
gchar* gc_skin_font_board_title_bold;
 
48
gchar* gc_skin_font_board_huge;
 
49
gchar* gc_skin_font_board_huge_bold;
46
50
 
47
51
 
48
52
/*
52
56
 *
53
57
 * The caller must free the returned string
54
58
 */
55
 
gchar *gcompris_image_to_skin(gchar *pixmapfile)
 
59
gchar *
 
60
gc_skin_image_get(gchar *pixmapfile)
56
61
{
57
 
  GcomprisProperties    *properties = gcompris_get_properties();
 
62
  GcomprisProperties *properties = gc_prop_get();
58
63
  gchar *filename;
59
64
 
60
65
  /* First, test if pixmapfile is in the current skin dir */
61
 
  filename = g_strdup_printf("%s/skins/%s/%s", PACKAGE_DATA_DIR, properties->skin, pixmapfile);
 
66
  filename = g_strdup_printf("%s/skins/%s/%s",
 
67
                             properties->package_data_dir,
 
68
                             properties->skin, pixmapfile);
62
69
 
63
70
  if (g_file_test ((filename), G_FILE_TEST_EXISTS)) {
64
71
    g_free(filename);
65
 
    
 
72
 
66
73
    filename = g_strdup_printf("skins/%s/%s", properties->skin, pixmapfile);
67
74
 
68
75
    return(filename);
69
76
  }
70
 
 
71
 
  /* Now check if pixmapfile is in the default skin dir */
72
 
 
73
 
  filename = g_strdup_printf("%s/skins/%s/%s", PACKAGE_DATA_DIR, DEFAULT_SKIN, pixmapfile);
74
 
    
75
 
  if (g_file_test ((filename), G_FILE_TEST_EXISTS)) {
76
 
    g_free(filename);
77
 
 
78
 
    filename = g_strdup_printf("skins/%s/%s", DEFAULT_SKIN, pixmapfile);
79
 
 
 
77
  g_free(filename);
 
78
 
 
79
  /* Check it's on the server */
 
80
  filename = gc_net_get_url_from_file("boards/skins/%s/%s", properties->skin, pixmapfile);
 
81
  if(filename)
80
82
    return(filename);
81
 
  }
82
 
 
83
 
  g_warning (_("Couldn't find file %s !"), filename);
84
 
 
85
 
  return(NULL);
 
83
 
 
84
  /* Return the default skin dir */
 
85
  filename = g_strdup_printf("skins/%s/%s", DEFAULT_SKIN, pixmapfile);
 
86
  return(filename);
86
87
}
87
88
 
88
89
/*
90
91
 * If not found, try in the default skin directory
91
92
 * If not found abort gcompris
92
93
 */
93
 
GdkPixbuf *gcompris_load_skin_pixmap(char *pixmapfile)
 
94
GdkPixbuf *
 
95
gc_skin_pixmap_load(char *pixmapfile)
94
96
{
95
97
  gchar *filename;
96
 
  GcomprisProperties    *properties = gcompris_get_properties();
97
98
  GdkPixbuf *result_pixbuf;
98
99
 
99
 
  filename = gcompris_image_to_skin(pixmapfile);
100
 
 
101
 
  result_pixbuf = gcompris_load_pixmap (filename);
102
 
  
 
100
  filename = gc_skin_image_get(pixmapfile);
 
101
 
 
102
  result_pixbuf = gc_pixmap_load (filename);
 
103
 
103
104
  g_free(filename);
104
 
  
 
105
 
105
106
  return (result_pixbuf);
106
107
}
107
108
 
108
109
/*
109
 
 * Utility function used when freeing the memory used by 
 
110
 * Utility function used when freeing the memory used by
110
111
 * a hashtable containing strings.
111
 
 */ 
112
 
void gcompris_skin_free_string(gpointer data)
 
112
 */
 
113
static void
 
114
gc_skin_free_string(gpointer data)
113
115
{
114
116
  g_free(data);
115
117
}
116
118
 
117
119
/*
118
 
 * Initialize some common variables 
 
120
 * Initialize some common variables
119
121
 * (the one that have to be defined in each skin)
120
122
 */
121
 
void gcompris_skin_setup_vars(void)
 
123
void
 
124
gc_skin_setup_vars(void)
122
125
{
123
 
  gcompris_skin_color_title = 
124
 
    gcompris_skin_get_color_default("gcompris/title", COLOR_TITLE);
125
 
  gcompris_skin_color_text_button = 
126
 
    gcompris_skin_get_color_default("gcompris/text button", COLOR_TEXT_BUTTON);
127
 
  gcompris_skin_color_content = 
128
 
    gcompris_skin_get_color_default("gcompris/content", COLOR_CONTENT);
129
 
  gcompris_skin_color_subtitle = 
130
 
    gcompris_skin_get_color_default("gcompris/subtitle", COLOR_SUBTITLE);
131
 
  
132
 
  gcompris_skin_font_title = 
133
 
    gcompris_skin_get_font_default("gcompris/title", FONT_TITLE);
134
 
  gcompris_skin_font_subtitle =
135
 
    gcompris_skin_get_font_default("gcompris/subtitle", FONT_SUBTITLE);
136
 
  gcompris_skin_font_content = 
137
 
    gcompris_skin_get_font_default("gcompris/content", FONT_CONTENT);
138
 
  
139
 
  gcompris_skin_font_board_tiny =
140
 
    gcompris_skin_get_font_default("gcompris/board/tiny", FONT_BOARD_TINY);
141
 
  gcompris_skin_font_board_small =
142
 
    gcompris_skin_get_font_default("gcompris/board/small", FONT_BOARD_SMALL);
143
 
  gcompris_skin_font_board_medium =
144
 
    gcompris_skin_get_font_default("gcompris/board/medium", FONT_BOARD_MEDIUM);
145
 
  gcompris_skin_font_board_big =
146
 
    gcompris_skin_get_font_default("gcompris/board/big", FONT_BOARD_BIG);
147
 
  gcompris_skin_font_board_big_bold =
148
 
    gcompris_skin_get_font_default("gcompris/board/big bold", FONT_BOARD_BIG_BOLD);
149
 
  gcompris_skin_font_board_fixed =
150
 
    gcompris_skin_get_font_default("gcompris/board/fixed", FONT_BOARD_FIXED);
151
 
  gcompris_skin_font_board_title =
152
 
    gcompris_skin_get_font_default("gcompris/board/title", FONT_BOARD_TITLE);
153
 
  gcompris_skin_font_board_title_bold =
154
 
    gcompris_skin_get_font_default("gcompris/board/title bold", FONT_BOARD_TITLE_BOLD);
155
 
  gcompris_skin_font_board_huge =
156
 
    gcompris_skin_get_font_default("gcompris/board/huge", FONT_BOARD_HUGE);
157
 
  gcompris_skin_font_board_huge_bold =
158
 
    gcompris_skin_get_font_default("gcompris/board/huge bold", FONT_BOARD_HUGE_BOLD);
 
126
  gc_skin_color_title =
 
127
    gc_skin_get_color_default("gcompris/title", COLOR_TITLE);
 
128
  gc_skin_color_text_button =
 
129
    gc_skin_get_color_default("gcompris/text button", COLOR_TEXT_BUTTON);
 
130
  gc_skin_color_content =
 
131
    gc_skin_get_color_default("gcompris/content", COLOR_CONTENT);
 
132
  gc_skin_color_subtitle =
 
133
    gc_skin_get_color_default("gcompris/subtitle", COLOR_SUBTITLE);
 
134
  gc_skin_color_shadow =
 
135
    gc_skin_get_color_default("gcompris/shadow", COLOR_SHADOW);
 
136
 
 
137
  gc_skin_font_title =
 
138
    gc_skin_get_font_default("gcompris/title", FONT_TITLE);
 
139
  gc_skin_font_subtitle =
 
140
    gc_skin_get_font_default("gcompris/subtitle", FONT_SUBTITLE);
 
141
  gc_skin_font_content =
 
142
    gc_skin_get_font_default("gcompris/content", FONT_CONTENT);
 
143
 
 
144
  gc_skin_font_board_tiny =
 
145
    gc_skin_get_font_default("gcompris/board/tiny", FONT_BOARD_TINY);
 
146
  gc_skin_font_board_small =
 
147
    gc_skin_get_font_default("gcompris/board/small", FONT_BOARD_SMALL);
 
148
  gc_skin_font_board_medium =
 
149
    gc_skin_get_font_default("gcompris/board/medium", FONT_BOARD_MEDIUM);
 
150
  gc_skin_font_board_big =
 
151
    gc_skin_get_font_default("gcompris/board/big", FONT_BOARD_BIG);
 
152
  gc_skin_font_board_big_bold =
 
153
    gc_skin_get_font_default("gcompris/board/big bold", FONT_BOARD_BIG_BOLD);
 
154
  gc_skin_font_board_fixed =
 
155
    gc_skin_get_font_default("gcompris/board/fixed", FONT_BOARD_FIXED);
 
156
  gc_skin_font_board_title =
 
157
    gc_skin_get_font_default("gcompris/board/title", FONT_BOARD_TITLE);
 
158
  gc_skin_font_board_title_bold =
 
159
    gc_skin_get_font_default("gcompris/board/title bold", FONT_BOARD_TITLE_BOLD);
 
160
  gc_skin_font_board_huge =
 
161
    gc_skin_get_font_default("gcompris/board/huge", FONT_BOARD_HUGE);
 
162
  gc_skin_font_board_huge_bold =
 
163
    gc_skin_get_font_default("gcompris/board/huge bold", FONT_BOARD_HUGE_BOLD);
159
164
}
160
165
 
161
166
/*
162
167
 * Convert from string a color expressed in the form 0xRRGGBBAA
163
168
 * to a unsigned 32 bit integer.
164
169
 */
165
 
gboolean gcompris_skin_str_to_color(gchar* data, guint32* color){
 
170
gboolean gc_skin_str_to_color(gchar* data, guint32* color){
166
171
  char c;
167
172
  int i;
168
173
  int n = 32;
241
246
 * Parse a skin.xml file located in the skin directory
242
247
 * and load the skin properties into memory
243
248
 */
244
 
void gcompris_skin_xml_load (gchar* skin)
 
249
static void
 
250
skin_xml_load (gchar* skin)
245
251
{
246
252
  gchar* xmlfilename;
247
253
  xmlDocPtr xmldoc;
252
258
  guint32 color;
253
259
 
254
260
  g_return_if_fail(skin!=NULL);
255
 
  
256
 
  xmlfilename = g_strdup_printf("%s/skins/%s/skin.xml", PACKAGE_DATA_DIR, skin);
 
261
 
 
262
  xmlfilename = \
 
263
    gc_file_find_absolute("skins/%s/skin.xml",
 
264
                                    skin,
 
265
                                    NULL);
257
266
 
258
267
  /* if the file doesn't exist */
259
 
  if(!g_file_test(xmlfilename, G_FILE_TEST_EXISTS))
 
268
  if(!xmlfilename)
260
269
    {
261
 
      g_warning(_("Couldn't find file %s !"), xmlfilename);
 
270
      g_warning("Couldn't find skin file %s !", skin);
262
271
      return;
263
272
    }
264
273
 
265
 
  xmldoc = xmlParseFile(xmlfilename);
266
 
  g_free(xmlfilename);  
 
274
  xmldoc = gc_net_load_xml(xmlfilename);
 
275
  g_free(xmlfilename);
267
276
 
268
277
  if(!xmldoc)
269
278
    return;
273
282
     /* if it doesn't have a name */
274
283
     !xmldoc->children->name ||
275
284
     /* if it isn't a GCompris node */
276
 
     g_strcasecmp(xmldoc->children->name,"GCompris")!=0) {
 
285
     g_strcasecmp((gchar *)xmldoc->children->name, "GCompris")!=0) {
277
286
    g_warning("No Gcompris node");
278
287
    xmlFreeDoc(xmldoc);
279
288
    return;
282
291
  skinNode = xmldoc->children->children;
283
292
  while((skinNode!=NULL)&&(skinNode->type!=XML_ELEMENT_NODE))
284
293
    skinNode = skinNode->next;
285
 
  
 
294
 
286
295
  if((skinNode==NULL)||
287
 
     g_strcasecmp(skinNode->name,"Skin")!=0) {
 
296
     g_strcasecmp((gchar *)skinNode->name, "Skin")!=0) {
288
297
    g_warning("No Skin node %s", xmldoc->children->children->name);
289
298
    xmlFreeDoc(xmldoc);
290
299
    return;
293
302
  node = skinNode->children;
294
303
  while(node !=NULL)
295
304
    {
296
 
      if(g_strcasecmp(node->name,"color")==0){
297
 
        key = xmlGetProp(node, "id");
298
 
        data = xmlGetProp(node, "rgba");
 
305
      if(g_strcasecmp((gchar *)node->name, "color")==0){
 
306
        key = (gchar *)xmlGetProp(node,  BAD_CAST "id");
 
307
        data =(gchar *) xmlGetProp(node,  BAD_CAST "rgba");
299
308
        if((key!=NULL)&&(data!=NULL)){
300
 
          if(gcompris_skin_str_to_color(data, &color)){
301
 
            g_hash_table_insert(gcompris_skin_colors, key, GUINT_TO_POINTER(color));
 
309
          if(gc_skin_str_to_color(data, &color)){
 
310
            g_hash_table_insert(gc_skin_colors, key, GUINT_TO_POINTER(color));
302
311
          } else {
303
312
            if(key!=NULL) g_free(key);
304
 
          }     
 
313
          }
305
314
        }
306
315
        if(data!=NULL) g_free(data);
307
 
      } 
308
 
      else if(g_strcasecmp(node->name,"font")==0){
309
 
        key = xmlGetProp(node, "id");
310
 
        data = xmlGetProp(node, "name");
311
 
        if((key!=NULL)&&(data!=NULL)){
312
 
          g_hash_table_insert(gcompris_skin_fonts, key, data);
313
 
        } else {
314
 
          if(key!=NULL) g_free(key);
315
 
          if(data!=NULL) g_free(data);
316
 
        }       
 
316
      }
 
317
      else if(g_strcasecmp((gchar *)node->name, "font")==0){
 
318
        key = (gchar *)xmlGetProp(node,  BAD_CAST "id");
 
319
        data = (gchar *)xmlGetProp(node,  BAD_CAST "name");
 
320
        if((key!=NULL)&&(data!=NULL)){
 
321
          g_hash_table_insert(gc_skin_fonts, key, data);
 
322
        } else {
 
323
          if(key!=NULL) g_free(key);
 
324
          if(data!=NULL) g_free(data);
 
325
        }
 
326
      }
 
327
      else if(g_strcasecmp((gchar *)node->name, "number")==0){
 
328
        key = (gchar *)xmlGetProp(node, BAD_CAST "id");
 
329
        data = (gchar *)xmlGetProp(node, BAD_CAST "value");
 
330
        if((key!=NULL)&&(data!=NULL)){
 
331
          int number = atoi(data);
 
332
          g_hash_table_insert(gc_skin_numbers, key, GUINT_TO_POINTER(number));
 
333
          g_free(data);
 
334
        } else {
 
335
          if(key!=NULL) g_free(key);
 
336
          if(data!=NULL) g_free(data);
 
337
        }
317
338
      }
318
339
      node = node->next;
319
340
    }
322
343
}
323
344
 
324
345
/*
325
 
 * Parse the default skin.xml file and the one located in the skin 
 
346
 * Parse the default skin.xml file and the one located in the skin
326
347
 * directory then load all skins properties into memory
327
348
 */
328
 
void gcompris_skin_load (gchar* skin)
 
349
void
 
350
gc_skin_load (gchar* skin)
329
351
{
330
352
 
331
353
  if(skin==NULL)
332
354
    return;
333
355
 
334
 
  gcompris_skin_free();
335
 
  
336
 
  gcompris_skin_fonts = g_hash_table_new_full(g_str_hash, g_str_equal,
337
 
                                              gcompris_skin_free_string,
338
 
                                              gcompris_skin_free_string);
339
 
  gcompris_skin_colors = g_hash_table_new_full(g_str_hash, g_str_equal,
340
 
                                              gcompris_skin_free_string,
341
 
                                              NULL);
342
 
  gcompris_skin_xml_load("default");
343
 
  if(strcmp(skin,"default")!=0)
344
 
    gcompris_skin_xml_load(skin);
345
 
 
346
 
  gcompris_skin_setup_vars();
 
356
  gc_skin_free();
 
357
 
 
358
  gc_skin_fonts = g_hash_table_new_full(g_str_hash, g_str_equal,
 
359
                                              gc_skin_free_string,
 
360
                                              gc_skin_free_string);
 
361
  gc_skin_colors = g_hash_table_new_full(g_str_hash, g_str_equal,
 
362
                                              gc_skin_free_string,
 
363
                                              NULL);
 
364
  gc_skin_numbers = g_hash_table_new_full(g_str_hash, g_str_equal,
 
365
                                              gc_skin_free_string,
 
366
                                              NULL);
 
367
  skin_xml_load(DEFAULT_SKIN);
 
368
  if(strcmp(skin,DEFAULT_SKIN)!=0)
 
369
    skin_xml_load(skin);
 
370
 
 
371
  gc_skin_setup_vars();
347
372
}
348
373
 
349
374
/*
350
375
 * Free the memory used to store the skin properties.
351
376
 */
352
 
void gcompris_skin_free (void)
 
377
void
 
378
gc_skin_free (void)
353
379
{
354
 
  if(gcompris_skin_fonts!=NULL)
355
 
    g_hash_table_destroy(gcompris_skin_fonts);
356
 
 
357
 
  if(gcompris_skin_colors!=NULL)
358
 
    g_hash_table_destroy(gcompris_skin_colors);
 
380
  if(gc_skin_fonts!=NULL)
 
381
    g_hash_table_destroy(gc_skin_fonts);
 
382
 
 
383
  if(gc_skin_colors!=NULL)
 
384
    g_hash_table_destroy(gc_skin_colors);
 
385
 
 
386
  if(gc_skin_numbers!= NULL)
 
387
      g_hash_table_destroy(gc_skin_numbers);
359
388
}
360
389
 
361
390
/*
362
391
 * Get the skin color associated to the id
363
392
 */
364
 
guint32 gcompris_skin_get_color_default(gchar* id, guint32 def)
 
393
guint32
 
394
gc_skin_get_color_default(gchar* id, guint32 def)
365
395
{
366
396
  gpointer result;
367
 
  result = g_hash_table_lookup(gcompris_skin_colors, (gpointer)id);
 
397
  result = g_hash_table_lookup(gc_skin_colors, (gpointer)id);
368
398
  if(result!=NULL)
369
399
    return GPOINTER_TO_UINT(result);
370
400
  return def;
371
401
}
372
402
 
373
403
/*
 
404
 * Get the skin gdkcolor associated to the id
 
405
 *
 
406
 * The color is returned in the given gdkcolor
 
407
 */
 
408
void
 
409
gc_skin_get_gdkcolor_default(gchar* id, guint32 def, GdkColor *gdkcolor)
 
410
{
 
411
  gchar *tmp;
 
412
  guint32 color;
 
413
 
 
414
  color = gc_skin_get_color_default(id, def);
 
415
 
 
416
  tmp = g_strdup_printf("#%06X", gc_skin_get_color(id) >> 8);
 
417
  gdk_color_parse(tmp, gdkcolor);
 
418
  g_free(tmp);
 
419
}
 
420
 
 
421
/*
374
422
 * Get the skin font name associated to the id
375
423
 */
376
 
gchar* gcompris_skin_get_font_default(gchar* id, gchar* def)
 
424
gchar*
 
425
gc_skin_get_font_default(gchar* id, gchar* def)
377
426
{
378
427
  gpointer result;
379
 
  result = g_hash_table_lookup(gcompris_skin_fonts, (gpointer)id);
 
428
  result = g_hash_table_lookup(gc_skin_fonts, (gpointer)id);
380
429
  if(result!=NULL)
381
430
    return (gchar*)result;
382
431
  return def;
383
432
}
 
433
 
 
434
/*
 
435
 * Get the skin 'number' associated to the id
 
436
 */
 
437
guint32
 
438
gc_skin_get_number_default(gchar* id, guint32 def)
 
439
{
 
440
  gpointer result;
 
441
  result = g_hash_table_lookup(gc_skin_numbers, (gpointer)id);
 
442
  if(result!=NULL)
 
443
    return GPOINTER_TO_UINT(result);
 
444
  return def;
 
445
}