?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix skin engine error message
[maemo-rb.git] / apps / gui / skin_engine / skin_parser.c
blob93f310df561b2ee4b3a145c396a0da2ed55ca4b7
1 /***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id$
9 *
10 * Copyright (C) 2007 Nicolas Pennequin, Dan Everton, Matthias Mohr
11 * 2010 Jonathan Gordon
12 *
13 * This program is free software; you can redistribute it and/or
14 * modify it under the terms of the GNU General Public License
15 * as published by the Free Software Foundation; either version 2
16 * of the License, or (at your option) any later version.
17 *
18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19 * KIND, either express or implied.
20 *
21 ****************************************************************************/
22
23 #include <stdio.h>
24 #include <string.h>
25 #include <stdlib.h>
26 #include "config.h"
27 #ifndef __PCTOOL__
28 #include "core_alloc.h"
29 #endif
30 #include "file.h"
31 #include "misc.h"
32 #include "plugin.h"
33 #include "viewport.h"
34
35 #include "skin_buffer.h"
36 #include "skin_debug.h"
37 #include "skin_parser.h"
38 #include "tag_table.h"
39
40 #ifdef __PCTOOL__
41 #ifdef WPSEDITOR
42 #include "proxy.h"
43 #include "sysfont.h"
44 #else
45 #include "action.h"
46 #include "checkwps.h"
47 #include "audio.h"
48 #define lang_is_rtl() (false)
49 #define DEBUGF printf
50 #endif /*WPSEDITOR*/
51 #else
52 #include "debug.h"
53 #include "language.h"
54 #endif /*__PCTOOL__*/
55
56 #include <ctype.h>
57 #include <stdbool.h>
58 #include "font.h"
59
60 #include "wps_internals.h"
61 #include "skin_engine.h"
62 #include "settings.h"
63 #include "settings_list.h"
64 #if CONFIG_TUNER
65 #include "radio.h"
66 #include "tuner.h"
67 #endif
68
69 #ifdef HAVE_LCD_BITMAP
70 #include "bmp.h"
71 #endif
72
73 #ifdef HAVE_ALBUMART
74 #include "playback.h"
75 #endif
76
77 #include "backdrop.h"
78 #include "statusbar-skinned.h"
79
80 #define WPS_ERROR_INVALID_PARAM -1
81
82 static char* skin_buffer = NULL;
83 #if (LCD_DEPTH > 1) || (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1))
84 static char *backdrop_filename;
85 #endif
86
87 static bool isdefault(struct skin_tag_parameter *param)
88 {
89 return param->type == DEFAULT;
90 }
91
92 static inline char*
93 get_param_text(struct skin_element *element, int param_number)
94 {
95 struct skin_tag_parameter* params = SKINOFFSETTOPTR(skin_buffer, element->params);
96 return SKINOFFSETTOPTR(skin_buffer, params[param_number].data.text);
97 }
98
99 static inline struct skin_element*
100 get_param_code(struct skin_element *element, int param_number)
101 {
102 struct skin_tag_parameter* params = SKINOFFSETTOPTR(skin_buffer, element->params);
103 return SKINOFFSETTOPTR(skin_buffer, params[param_number].data.code);
104 }
105
106 static inline struct skin_tag_parameter*
107 get_param(struct skin_element *element, int param_number)
108 {
109 struct skin_tag_parameter* params = SKINOFFSETTOPTR(skin_buffer, element->params);
110 return &params[param_number];
111 }
112
113 /* which screen are we parsing for? */
114 static enum screen_type curr_screen;
115
116 /* the current viewport */
117 static struct skin_element *curr_viewport_element;
118 static struct skin_viewport *curr_vp;
119 static struct skin_element *first_viewport;
120
121 static struct line *curr_line;
122
123 static int follow_lang_direction = 0;
124
125 typedef int (*parse_function)(struct skin_element *element,
126 struct wps_token *token,
127 struct wps_data *wps_data);
128
129 #ifdef HAVE_LCD_BITMAP
130 /* add a skin_token_list item to the list chain. ALWAYS appended because some of the
131 * chains require the order to be kept.
132 */
133 static void add_to_ll_chain(OFFSETTYPE(struct skin_token_list *) *listoffset,
134 struct skin_token_list *item)
135 {
136 struct skin_token_list *list = SKINOFFSETTOPTR(skin_buffer, *listoffset);
137 if (list == NULL)
138 {
139 *listoffset = PTRTOSKINOFFSET(skin_buffer, item);
140 }
141 else
142 {
143 while (SKINOFFSETTOPTR(skin_buffer, list->next))
144 list = SKINOFFSETTOPTR(skin_buffer, list->next);
145 list->next = PTRTOSKINOFFSET(skin_buffer, item);
146 }
147 }
148
149 #endif
150
151
152 void *skin_find_item(const char *label, enum skin_find_what what,
153 struct wps_data *data)
154 {
155 const char *itemlabel = NULL;
156 char *databuf = get_skin_buffer(data);
157 union {
158 struct skin_token_list *linkedlist;
159 struct skin_element *vplist;
160 } list = {NULL};
161 bool isvplist = false;
162 void *ret = NULL;
163 if (!databuf)
164 databuf = skin_buffer;
165 switch (what)
166 {
167 case SKIN_FIND_UIVP:
168 case SKIN_FIND_VP:
169 list.vplist = SKINOFFSETTOPTR(databuf, data->tree);
170 isvplist = true;
171 break;
172 #ifdef HAVE_LCD_BITMAP
173 case SKIN_FIND_IMAGE:
174 list.linkedlist = SKINOFFSETTOPTR(databuf, data->images);
175 break;
176 #endif
177 #ifdef HAVE_TOUCHSCREEN
178 case SKIN_FIND_TOUCHREGION:
179 list.linkedlist = SKINOFFSETTOPTR(databuf, data->touchregions);
180 break;
181 #endif
182 #ifdef HAVE_SKIN_VARIABLES
183 case SKIN_VARIABLE:
184 list.linkedlist = SKINOFFSETTOPTR(databuf, data->skinvars);
185 break;
186 #endif
187 }
188
189 while (list.linkedlist)
190 {
191 bool skip = false;
192 #ifdef HAVE_LCD_BITMAP
193 struct wps_token *token = NULL;
194 if (!isvplist)
195 token = SKINOFFSETTOPTR(databuf, list.linkedlist->token);
196 #endif
197 switch (what)
198 {
199 case SKIN_FIND_UIVP:
200 case SKIN_FIND_VP:
201 ret = SKINOFFSETTOPTR(databuf, list.vplist->data);
202 if (((struct skin_viewport *)ret)->label == VP_DEFAULT_LABEL)
203 itemlabel = VP_DEFAULT_LABEL_STRING;
204 else
205 itemlabel = SKINOFFSETTOPTR(databuf, ((struct skin_viewport *)ret)->label);
206 skip = !(((struct skin_viewport *)ret)->is_infovp ==
207 (what==SKIN_FIND_UIVP));
208 break;
209 #ifdef HAVE_LCD_BITMAP
210 case SKIN_FIND_IMAGE:
211 ret = SKINOFFSETTOPTR(databuf, token->value.data);
212 itemlabel = SKINOFFSETTOPTR(databuf, ((struct gui_img *)ret)->label);
213 break;
214 #endif
215 #ifdef HAVE_TOUCHSCREEN
216 case SKIN_FIND_TOUCHREGION:
217 ret = SKINOFFSETTOPTR(databuf, token->value.data);
218 itemlabel = SKINOFFSETTOPTR(databuf, ((struct touchregion *)ret)->label);
219 break;
220 #endif
221 #ifdef HAVE_SKIN_VARIABLES
222 case SKIN_VARIABLE:
223 ret = SKINOFFSETTOPTR(databuf, token->value.data);
224 itemlabel = SKINOFFSETTOPTR(databuf, ((struct skin_var *)ret)->label);
225 break;
226 #endif
227
228 }
229 if (!skip && itemlabel && !strcmp(itemlabel, label))
230 {
231 return ret;
232 }
233
234 if (isvplist)
235 list.vplist = SKINOFFSETTOPTR(databuf, list.vplist->next);
236 else
237 list.linkedlist = SKINOFFSETTOPTR(databuf, list.linkedlist->next);
238 }
239 return NULL;
240 }
241
242 #ifdef HAVE_LCD_BITMAP
243
244 /* create and init a new wpsll item.
245 * passing NULL to token will alloc a new one.
246 * You should only pass NULL for the token when the token type (table above)
247 * is WPS_NO_TOKEN which means it is not stored automatically in the skins token array
248 */
249 static struct skin_token_list *new_skin_token_list_item(struct wps_token *token,
250 void* token_data)
251 {
252 struct skin_token_list *llitem = skin_buffer_alloc(sizeof(*llitem));
253 if (!token)
254 token = skin_buffer_alloc(sizeof(*token));
255 if (!llitem || !token)
256 return NULL;
257 llitem->next = PTRTOSKINOFFSET(skin_buffer, NULL);
258 llitem->token = PTRTOSKINOFFSET(skin_buffer, token);
259 if (token_data)
260 token->value.data = PTRTOSKINOFFSET(skin_buffer, token_data);
261 return llitem;
262 }
263
264 static int parse_statusbar_tags(struct skin_element* element,
265 struct wps_token *token,
266 struct wps_data *wps_data)
267 {
268 (void)element;
269 if (token->type == SKIN_TOKEN_DRAW_INBUILTBAR)
270 {
271 token->value.data = PTRTOSKINOFFSET(skin_buffer, (void*)&curr_vp->vp);
272 }
273 else
274 {
275 struct skin_viewport *default_vp = SKINOFFSETTOPTR(skin_buffer, first_viewport->data);
276 if (first_viewport->params_count == 0)
277 {
278 wps_data->wps_sb_tag = true;
279 wps_data->show_sb_on_wps = (token->type == SKIN_TOKEN_ENABLE_THEME);
280 }
281 if (wps_data->show_sb_on_wps)
282 {
283 viewport_set_defaults(&default_vp->vp, curr_screen);
284 }
285 else
286 {
287 viewport_set_fullscreen(&default_vp->vp, curr_screen);
288 }
289 #ifdef HAVE_REMOTE_LCD
290 /* This parser requires viewports which will use the settings font to
291 * have font == 1, but the above viewport_set() calls set font to
292 * the current real font id. So force 1 here it will be set correctly
293 * at the end
294 */
295 default_vp->vp.font = 1;
296 #endif
297 }
298 return 0;
299 }
300
301 static int get_image_id(int c)
302 {
303 if(c >= 'a' && c <= 'z')
304 return c - 'a';
305 else if(c >= 'A' && c <= 'Z')
306 return c - 'A' + 26;
307 else
308 return -1;
309 }
310
311 void get_image_filename(const char *start, const char* bmpdir,
312 char *buf, int buf_size)
313 {
314 snprintf(buf, buf_size, "%s/%s", bmpdir, start);
315 }
316
317 static int parse_image_display(struct skin_element *element,
318 struct wps_token *token,
319 struct wps_data *wps_data)
320 {
321 char *label = get_param_text(element, 0);
322 char sublabel = '\0';
323 int subimage;
324 struct gui_img *img;
325 struct image_display *id = skin_buffer_alloc(sizeof(*id));
326
327 if (element->params_count == 1 && strlen(label) <= 2)
328 {
329 /* backwards compatability. Allow %xd(Aa) to still work */
330 sublabel = label[1];
331 label[1] = '\0';
332 }
333 /* sanity check */
334 img = skin_find_item(label, SKIN_FIND_IMAGE, wps_data);
335 if (!img || !id)
336 {
337 return WPS_ERROR_INVALID_PARAM;
338 }
339 id->label = img->label;
340 id->offset = 0;
341 id->token = PTRTOSKINOFFSET(skin_buffer, NULL);
342 if (img->using_preloaded_icons)
343 {
344 token->type = SKIN_TOKEN_IMAGE_DISPLAY_LISTICON;
345 }
346
347 if (element->params_count > 1)
348 {
349 if (get_param(element, 1)->type == CODE)
350 id->token = get_param_code(element, 1)->data;
351 /* specify a number. 1 being the first subimage (i.e top) NOT 0 */
352 else if (get_param(element, 1)->type == INTEGER)
353 id->subimage = get_param(element, 1)->data.number - 1;
354 if (element->params_count > 2)
355 id->offset = get_param(element, 2)->data.number;
356 }
357 else
358 {
359 if ((subimage = get_image_id(sublabel)) != -1)
360 {
361 if (subimage >= img->num_subimages)
362 return WPS_ERROR_INVALID_PARAM;
363 id->subimage = subimage;
364 } else {
365 id->subimage = 0;
366 }
367 }
368 token->value.data = PTRTOSKINOFFSET(skin_buffer, id);
369 return 0;
370 }
371
372 static int parse_image_load(struct skin_element *element,
373 struct wps_token *token,
374 struct wps_data *wps_data)
375 {
376 const char* filename;
377 const char* id;
378 int x = 0,y = 0, subimages = 1;
379 struct gui_img *img;
380
381 /* format: %x(n,filename.bmp[,x,y])
382 or %xl(n,filename.bmp[,x,y])
383 or %xl(n,filename.bmp[,x,y,num_subimages])
384 */
385
386 id = get_param_text(element, 0);
387 filename = get_param_text(element, 1);
388 /* x,y,num_subimages handling:
389 * If all 3 are left out use sane defaults.
390 * If there are 2 params it must be x,y
391 * if there is only 1 param it must be the num_subimages
392 */
393 if (element->params_count == 3)
394 subimages = get_param(element, 2)->data.number;
395 else if (element->params_count > 3)
396 {
397 x = get_param(element, 2)->data.number;
398 y = get_param(element, 3)->data.number;
399 if (element->params_count == 5)
400 subimages = get_param(element, 4)->data.number;
401 }
402 /* check the image number and load state */
403 if(skin_find_item(id, SKIN_FIND_IMAGE, wps_data))
404 {
405 /* Invalid image ID */
406 return WPS_ERROR_INVALID_PARAM;
407 }
408 img = skin_buffer_alloc(sizeof(*img));
409 if (!img)
410 return WPS_ERROR_INVALID_PARAM;
411 /* save a pointer to the filename */
412 img->bm.data = (char*)filename;
413 img->label = PTRTOSKINOFFSET(skin_buffer, (void*)id);
414 img->x = x;
415 img->y = y;
416 img->num_subimages = subimages;
417 img->display = -1;
418 img->using_preloaded_icons = false;
419 img->buflib_handle = -1;
420
421 /* save current viewport */
422 img->vp = PTRTOSKINOFFSET(skin_buffer, &curr_vp->vp);
423
424 if (token->type == SKIN_TOKEN_IMAGE_DISPLAY)
425 token->value.data = PTRTOSKINOFFSET(skin_buffer, img);
426
427 if (!strcmp(img->bm.data, "__list_icons__"))
428 {
429 img->num_subimages = Icon_Last_Themeable;
430 img->using_preloaded_icons = true;
431 }
432
433 struct skin_token_list *item = new_skin_token_list_item(NULL, img);
434 if (!item)
435 return WPS_ERROR_INVALID_PARAM;
436 add_to_ll_chain(&wps_data->images, item);
437
438 return 0;
439 }
440 struct skin_font {
441 int id; /* the id from font_load */
442 char *name; /* filename without path and extension */
443 int glyphs; /* how many glyphs to reserve room for */
444 };
445 static struct skin_font skinfonts[MAXUSERFONTS];
446 static int parse_font_load(struct skin_element *element,
447 struct wps_token *token,
448 struct wps_data *wps_data)
449 {
450 (void)wps_data; (void)token;
451 int id = get_param(element, 0)->data.number;
452 char *filename = get_param_text(element, 1);
453 int glyphs;
454 char *ptr;
455
456 if(element->params_count > 2)
457 glyphs = get_param(element, 2)->data.number;
458 else
459 glyphs = global_settings.glyphs_to_cache;
460 if (id < 2)
461 {
462 DEBUGF("font id must be >= 2 (%d)\n", id);
463 return 1;
464 }
465 #if defined(DEBUG) || defined(SIMULATOR)
466 if (skinfonts[id-2].name != NULL)
467 {
468 DEBUGF("font id %d already being used\n", id);
469 }
470 #endif
471 /* make sure the filename contains .fnt,
472 * we dont actually use it, but require it anyway */
473 ptr = strchr(filename, '.');
474 if (!ptr || strncmp(ptr, ".fnt", 4))
475 return WPS_ERROR_INVALID_PARAM;
476 skinfonts[id-2].id = -1;
477 skinfonts[id-2].name = filename;
478 skinfonts[id-2].glyphs = glyphs;
479
480 return 0;
481 }
482
483
484 #ifdef HAVE_LCD_BITMAP
485
486 static int parse_playlistview(struct skin_element *element,
487 struct wps_token *token,
488 struct wps_data *wps_data)
489 {
490 (void)wps_data;
491 struct playlistviewer *viewer = skin_buffer_alloc(sizeof(*viewer));
492 if (!viewer)
493 return WPS_ERROR_INVALID_PARAM;
494 viewer->vp = PTRTOSKINOFFSET(skin_buffer, &curr_vp->vp);
495 viewer->show_icons = true;
496 viewer->start_offset = get_param(element, 0)->data.number;
497 viewer->line = PTRTOSKINOFFSET(skin_buffer, get_param_code(element, 1));
498
499 token->value.data = PTRTOSKINOFFSET(skin_buffer, (void*)viewer);
500
501 return 0;
502 }
503 #endif
504 #ifdef HAVE_LCD_COLOR
505 static int parse_viewport_gradient_setup(struct skin_element *element,
506 struct wps_token *token,
507 struct wps_data *wps_data)
508 {
509 (void)wps_data;
510 struct gradient_config *cfg;
511 if (element->params_count < 2) /* only start and end are required */
512 return 1;
513 cfg = skin_buffer_alloc(sizeof(*cfg));
514 if (!cfg)
515 return 1;
516 if (!parse_color(curr_screen, get_param_text(element, 0), &cfg->start) ||
517 !parse_color(curr_screen, get_param_text(element, 1), &cfg->end))
518 return 1;
519 if (element->params_count > 2)
520 {
521 if (!parse_color(curr_screen, get_param_text(element, 2), &cfg->text))
522 return 1;
523 }
524 else
525 {
526 cfg->text = curr_vp->vp.fg_pattern;
527 }
528
529 token->value.data = PTRTOSKINOFFSET(skin_buffer, cfg);
530 return 0;
531 }
532 #endif
533
534 static int parse_listitem(struct skin_element *element,
535 struct wps_token *token,
536 struct wps_data *wps_data)
537 {
538 (void)wps_data;
539 struct listitem *li = skin_buffer_alloc(sizeof(*li));
540 if (!li)
541 return 1;
542 token->value.data = PTRTOSKINOFFSET(skin_buffer, li);
543 if (element->params_count == 0)
544 li->offset = 0;
545 else
546 {
547 li->offset = get_param(element, 0)->data.number;
548 if (element->params_count > 1)
549 li->wrap = strcasecmp(get_param_text(element, 1), "nowrap") != 0;
550 else
551 li->wrap = true;
552 }
553 return 0;
554 }
555
556 static int parse_listitemviewport(struct skin_element *element,
557 struct wps_token *token,
558 struct wps_data *wps_data)
559 {
560 #ifndef __PCTOOL__
561 struct listitem_viewport_cfg *cfg = skin_buffer_alloc(sizeof(*cfg));
562 if (!cfg)
563 return -1;
564 cfg->data = wps_data;
565 cfg->tile = false;
566 cfg->label = PTRTOSKINOFFSET(skin_buffer, get_param_text(element, 0));
567 cfg->width = -1;
568 cfg->height = -1;
569 if (!isdefault(get_param(element, 1)))
570 cfg->width = get_param(element, 1)->data.number;
571 if (!isdefault(get_param(element, 2)))
572 cfg->height = get_param(element, 2)->data.number;
573 if (element->params_count > 3 &&
574 !strcmp(get_param_text(element, 3), "tile"))
575 cfg->tile = true;
576 token->value.data = PTRTOSKINOFFSET(skin_buffer, (void*)cfg);
577 #endif
578 return 0;
579 }
580
581 #if (LCD_DEPTH > 1) || (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1))
582 static int parse_viewporttextstyle(struct skin_element *element,
583 struct wps_token *token,
584 struct wps_data *wps_data)
585 {
586 (void)wps_data;
587 int style;
588 char *mode = get_param_text(element, 0);
589 unsigned colour;
590
591 if (!strcmp(mode, "invert"))
592 {
593 style = STYLE_INVERT;
594 }
595 else if (!strcmp(mode, "colour") || !strcmp(mode, "color"))
596 {
597 if (element->params_count < 2 ||
598 !parse_color(curr_screen, get_param_text(element, 1), &colour))
599 return 1;
600 style = STYLE_COLORED|(STYLE_COLOR_MASK&colour);
601 }
602 #ifdef HAVE_LCD_COLOR
603 else if (!strcmp(mode, "gradient"))
604 {
605 int num_lines;
606 if (element->params_count < 2)
607 num_lines = 1;
608 else /* atoi() instead of using a number in the parser is because [si]
609 * will select the number for something which looks like a colour
610 * making the "colour" case (above) harder to parse */
611 num_lines = atoi(get_param_text(element, 1));
612 style = STYLE_GRADIENT|NUMLN_PACK(num_lines)|CURLN_PACK(0);
613 }
614 #endif
615 else if (!strcmp(mode, "clear"))
616 {
617 style = STYLE_DEFAULT;
618 }
619 else
620 return 1;
621 token->value.l = style;
622 return 0;
623 }
624
625 static int parse_drawrectangle( struct skin_element *element,
626 struct wps_token *token,
627 struct wps_data *wps_data)
628 {
629 (void)wps_data;
630 struct draw_rectangle *rect = skin_buffer_alloc(sizeof(*rect));
631
632 if (!rect)
633 return -1;
634
635 rect->x = get_param(element, 0)->data.number;
636 rect->y = get_param(element, 1)->data.number;
637
638 if (isdefault(get_param(element, 2)))
639 rect->width = curr_vp->vp.width - rect->x;
640 else
641 rect->width = get_param(element, 2)->data.number;
642
643 if (isdefault(get_param(element, 3)))
644 rect->height = curr_vp->vp.height - rect->y;
645 else
646 rect->height = get_param(element, 3)->data.number;
647
648 rect->start_colour = curr_vp->vp.fg_pattern;
649 rect->end_colour = curr_vp->vp.fg_pattern;
650
651 if (element->params_count > 4)
652 {
653 if (!parse_color(curr_screen, get_param_text(element, 4),
654 &rect->start_colour))
655 return -1;
656 rect->end_colour = rect->start_colour;
657 }
658 if (element->params_count > 5)
659 {
660 if (!parse_color(curr_screen, get_param_text(element, 5),
661 &rect->end_colour))
662 return -1;
663 }
664 token->value.data = PTRTOSKINOFFSET(skin_buffer, rect);
665
666 return 0;
667 }
668
669 static int parse_viewportcolour(struct skin_element *element,
670 struct wps_token *token,
671 struct wps_data *wps_data)
672 {
673 (void)wps_data;
674 struct skin_tag_parameter *param = get_param(element, 0);
675 struct viewport_colour *colour = skin_buffer_alloc(sizeof(*colour));
676 if (!colour)
677 return -1;
678 if (isdefault(param))
679 {
680 colour->colour = get_viewport_default_colour(curr_screen,
681 token->type == SKIN_TOKEN_VIEWPORT_FGCOLOUR);
682 }
683 else
684 {
685 if (!parse_color(curr_screen, SKINOFFSETTOPTR(skin_buffer, param->data.text),
686 &colour->colour))
687 return -1;
688 }
689 colour->vp = PTRTOSKINOFFSET(skin_buffer, &curr_vp->vp);
690 token->value.data = PTRTOSKINOFFSET(skin_buffer, colour);
691 if (element->line == curr_viewport_element->line)
692 {
693 if (token->type == SKIN_TOKEN_VIEWPORT_FGCOLOUR)
694 {
695 curr_vp->start_fgcolour = colour->colour;
696 curr_vp->vp.fg_pattern = colour->colour;
697 }
698 else
699 {
700 curr_vp->start_bgcolour = colour->colour;
701 curr_vp->vp.bg_pattern = colour->colour;
702 }
703 }
704 return 0;
705 }
706
707 static int parse_image_special(struct skin_element *element,
708 struct wps_token *token,
709 struct wps_data *wps_data)
710 {
711 (void)wps_data; /* kill warning */
712 (void)token;
713
714 #if LCD_DEPTH > 1
715 char *filename;
716 if (token->type == SKIN_TOKEN_IMAGE_BACKDROP)
717 {
718 if (isdefault(get_param(element, 0)))
719 {
720 filename = "-";
721 }
722 else
723 {
724 filename = get_param_text(element, 0);
725 /* format: %X(filename.bmp) or %X(d) */
726 if (!strcmp(filename, "d"))
727 filename = NULL;
728 }
729 backdrop_filename = filename;
730 }
731 #endif
732
733 return 0;
734 }
735 #endif
736
737 #endif /* HAVE_LCD_BITMAP */
738
739 static int parse_progressbar_tag(struct skin_element* element,
740 struct wps_token *token,
741 struct wps_data *wps_data);
742
743 static int parse_setting_and_lang(struct skin_element *element,
744 struct wps_token *token,
745 struct wps_data *wps_data)
746 {
747 /* NOTE: both the string validations that happen in here will
748 * automatically PASS on checkwps because its too hard to get
749 * settings_list.c and english.lang built for it.
750 * If that ever changes remove the #ifndef __PCTOOL__'s here
751 */
752 (void)wps_data;
753 char *temp = get_param_text(element, 0);
754 int i;
755
756 if (token->type == SKIN_TOKEN_TRANSLATEDSTRING)
757 {
758 #ifndef __PCTOOL__
759 i = lang_english_to_id(temp);
760 if (i < 0)
761 return WPS_ERROR_INVALID_PARAM;
762 #endif
763 }
764 else if (element->params_count > 1)
765 {
766 if (element->params_count > 4)
767 return parse_progressbar_tag(element, token, wps_data);
768 else
769 return WPS_ERROR_INVALID_PARAM;
770 }
771 else
772 {
773 #ifndef __PCTOOL__
774 if (find_setting_by_cfgname(temp, &i) == NULL)
775 return WPS_ERROR_INVALID_PARAM;
776 #endif
777 }
778 /* Store the setting number */
779 token->value.i = i;
780 return 0;
781 }
782
783 static int parse_logical_andor(struct skin_element *element,
784 struct wps_token *token,
785 struct wps_data *wps_data)
786 {
787 (void)wps_data;
788 token->value.data = PTRTOSKINOFFSET(skin_buffer, element);
789 return 0;
790 }
791
792 static int parse_logical_if(struct skin_element *element,
793 struct wps_token *token,
794 struct wps_data *wps_data)
795 {
796 (void)wps_data;
797 char *op = get_param_text(element, 1);
798 struct logical_if *lif = skin_buffer_alloc(sizeof(*lif));
799 if (!lif)
800 return -1;
801 token->value.data = PTRTOSKINOFFSET(skin_buffer, lif);
802 lif->token = get_param_code(element, 0)->data;
803
804 if (!strncmp(op, "=", 1))
805 lif->op = IF_EQUALS;
806 else if (!strncmp(op, "!=", 2))
807 lif->op = IF_NOTEQUALS;
808 else if (!strncmp(op, ">=", 2))
809 lif->op = IF_GREATERTHAN_EQ;
810 else if (!strncmp(op, "<=", 2))
811 lif->op = IF_LESSTHAN_EQ;
812 else if (!strncmp(op, ">", 2))
813 lif->op = IF_GREATERTHAN;
814 else if (!strncmp(op, "<", 1))
815 lif->op = IF_LESSTHAN;
816
817 memcpy(&lif->operand, get_param(element, 2), sizeof(lif->operand));
818 if (element->params_count > 3)
819 lif->num_options = get_param(element, 3)->data.number;
820 else
821 lif->num_options = TOKEN_VALUE_ONLY;
822 return 0;
823
824 }
825
826 static int parse_timeout_tag(struct skin_element *element,
827 struct wps_token *token,
828 struct wps_data *wps_data)
829 {
830 (void)wps_data;
831 int val = 0;
832 if (element->params_count == 0)
833 {
834 switch (token->type)
835 {
836 case SKIN_TOKEN_SUBLINE_TIMEOUT:
837 return -1;
838 case SKIN_TOKEN_BUTTON_VOLUME:
839 case SKIN_TOKEN_TRACK_STARTING:
840 case SKIN_TOKEN_TRACK_ENDING:
841 val = 10;
842 break;
843 default:
844 break;
845 }
846 }
847 else
848 val = get_param(element, 0)->data.number;
849 token->value.i = val * TIMEOUT_UNIT;
850 return 0;
851 }
852
853 static int parse_substring_tag(struct skin_element* element,
854 struct wps_token *token,
855 struct wps_data *wps_data)
856 {
857 (void)wps_data;
858 struct substring *ss = skin_buffer_alloc(sizeof(*ss));
859 if (!ss)
860 return 1;
861 ss->start = get_param(element, 0)->data.number;
862 if (get_param(element, 1)->type == DEFAULT)
863 ss->length = -1;
864 else
865 ss->length = get_param(element, 1)->data.number;
866 ss->token = get_param_code(element, 2)->data;
867 if (element->params_count > 3)
868 ss->expect_number = !strcmp(get_param_text(element, 3), "number");
869 else
870 ss->expect_number = false;
871 token->value.data = PTRTOSKINOFFSET(skin_buffer, ss);
872 return 0;
873 }
874
875 static int parse_progressbar_tag(struct skin_element* element,
876 struct wps_token *token,
877 struct wps_data *wps_data)
878 {
879 #ifdef HAVE_LCD_BITMAP
880 struct progressbar *pb;
881 struct viewport *vp = &curr_vp->vp;
882 struct skin_tag_parameter *param = get_param(element, 0);
883 int curr_param = 0;
884 char *image_filename = NULL;
885 #ifdef HAVE_TOUCHSCREEN
886 bool suppress_touchregion = false;
887 #endif
888
889 if (element->params_count == 0 &&
890 element->tag->type != SKIN_TOKEN_PROGRESSBAR)
891 return 0; /* nothing to do */
892 pb = skin_buffer_alloc(sizeof(*pb));
893
894 token->value.data = PTRTOSKINOFFSET(skin_buffer, pb);
895
896 if (!pb)
897 return WPS_ERROR_INVALID_PARAM;
898 pb->vp = PTRTOSKINOFFSET(skin_buffer, vp);
899 pb->follow_lang_direction = follow_lang_direction > 0;
900 pb->nofill = false;
901 pb->nobar = false;
902 pb->image = PTRTOSKINOFFSET(skin_buffer, NULL);
903 pb->slider = PTRTOSKINOFFSET(skin_buffer, NULL);
904 pb->backdrop = PTRTOSKINOFFSET(skin_buffer, NULL);
905 pb->setting_id = -1;
906 pb->invert_fill_direction = false;
907 pb->horizontal = true;
908
909 if (element->params_count == 0)
910 {
911 pb->x = 0;
912 pb->width = vp->width;
913 pb->height = SYSFONT_HEIGHT-2;
914 pb->y = -1; /* Will be computed during the rendering */
915 pb->type = element->tag->type;
916 return 0;
917 }
918
919 /* (x, y, width, height, ...) */
920 if (!isdefault(param))
921 pb->x = param->data.number;
922 else
923 pb->x = 0;
924 param++;
925
926 if (!isdefault(param))
927 pb->y = param->data.number;
928 else
929 pb->y = -1; /* computed at rendering */
930 param++;
931
932 if (!isdefault(param))
933 pb->width = param->data.number;
934 else
935 pb->width = vp->width - pb->x;
936 param++;
937
938 if (!isdefault(param))
939 {
940 /* A zero height makes no sense - reject it */
941 if (param->data.number == 0)
942 return WPS_ERROR_INVALID_PARAM;
943
944 pb->height = param->data.number;
945 }
946 else
947 {
948 if (vp->font > FONT_UI)
949 pb->height = -1; /* calculate at display time */
950 else
951 {
952 #ifndef __PCTOOL__
953 pb->height = font_get(vp->font)->height;
954 #else
955 pb->height = 8;
956 #endif
957 }
958 }
959 /* optional params, first is the image filename if it isnt recognised as a keyword */
960
961 curr_param = 4;
962 if (isdefault(get_param(element, curr_param)))
963 {
964 param++;
965 curr_param++;
966 }
967
968 pb->horizontal = pb->width > pb->height;
969 while (curr_param < element->params_count)
970 {
971 char* text;
972 param++;
973 text = SKINOFFSETTOPTR(skin_buffer, param->data.text);
974 if (!strcmp(text, "invert"))
975 pb->invert_fill_direction = true;
976 else if (!strcmp(text, "nofill"))
977 pb->nofill = true;
978 else if (!strcmp(text, "nobar"))
979 pb->nobar = true;
980 else if (!strcmp(text, "slider"))
981 {
982 if (curr_param+1 < element->params_count)
983 {
984 curr_param++;
985 param++;
986 text = SKINOFFSETTOPTR(skin_buffer, param->data.text);
987 pb->slider = PTRTOSKINOFFSET(skin_buffer,
988 skin_find_item(text, SKIN_FIND_IMAGE, wps_data));
989 }
990 else /* option needs the next param */
991 return -1;
992 }
993 else if (!strcmp(text, "image"))
994 {
995 if (curr_param+1 < element->params_count)
996 {
997 curr_param++;
998 param++;
999 image_filename = SKINOFFSETTOPTR(skin_buffer, param->data.text);
1000 }
1001 else /* option needs the next param */
1002 return -1;
1003 }
1004 else if (!strcmp(text, "backdrop"))
1005 {
1006 if (curr_param+1 < element->params_count)
1007 {
1008 curr_param++;
1009 param++;
1010 text = SKINOFFSETTOPTR(skin_buffer, param->data.text);
1011 pb->backdrop = PTRTOSKINOFFSET(skin_buffer,
1012 skin_find_item(text, SKIN_FIND_IMAGE, wps_data));
1013
1014 }
1015 else /* option needs the next param */
1016 return -1;
1017 }
1018 else if (!strcmp(text, "vertical"))
1019 {
1020 pb->horizontal = false;
1021 if (isdefault(get_param(element, 3)))
1022 pb->height = vp->height - pb->y;
1023 }
1024 else if (!strcmp(text, "horizontal"))
1025 pb->horizontal = true;
1026 #ifdef HAVE_TOUCHSCREEN
1027 else if (!strcmp(text, "notouch"))
1028 suppress_touchregion = true;
1029 #endif
1030 else if (token->type == SKIN_TOKEN_SETTING && !strcmp(text, "setting"))
1031 {
1032 if (curr_param+1 < element->params_count)
1033 {
1034 curr_param++;
1035 param++;
1036 text = SKINOFFSETTOPTR(skin_buffer, param->data.text);
1037 #ifndef __PCTOOL__
1038 if (find_setting_by_cfgname(text, &pb->setting_id) == NULL)
1039 return WPS_ERROR_INVALID_PARAM;
1040 #endif
1041 }
1042 }
1043 else if (curr_param == 4)
1044 image_filename = text;
1045
1046 curr_param++;
1047 }
1048
1049 if (image_filename)
1050 {
1051 pb->image = PTRTOSKINOFFSET(skin_buffer,
1052 skin_find_item(image_filename, SKIN_FIND_IMAGE, wps_data));
1053 if (!SKINOFFSETTOPTR(skin_buffer, pb->image)) /* load later */
1054 {
1055 struct gui_img *img = skin_buffer_alloc(sizeof(*img));
1056 if (!img)
1057 return WPS_ERROR_INVALID_PARAM;
1058 /* save a pointer to the filename */
1059 img->bm.data = (char*)image_filename;
1060 img->label = PTRTOSKINOFFSET(skin_buffer, image_filename);
1061 img->x = 0;
1062 img->y = 0;
1063 img->num_subimages = 1;
1064 img->display = -1;
1065 img->using_preloaded_icons = false;
1066 img->buflib_handle = -1;
1067 img->vp = PTRTOSKINOFFSET(skin_buffer, &curr_vp->vp);
1068 struct skin_token_list *item = new_skin_token_list_item(NULL, img);
1069 if (!item)
1070 return WPS_ERROR_INVALID_PARAM;
1071 add_to_ll_chain(&wps_data->images, item);
1072 pb->image = PTRTOSKINOFFSET(skin_buffer, img);
1073 }
1074 }
1075
1076 if (token->type == SKIN_TOKEN_VOLUME)
1077 token->type = SKIN_TOKEN_VOLUMEBAR;
1078 else if (token->type == SKIN_TOKEN_BATTERY_PERCENT)
1079 token->type = SKIN_TOKEN_BATTERY_PERCENTBAR;
1080 else if (token->type == SKIN_TOKEN_TUNER_RSSI)
1081 token->type = SKIN_TOKEN_TUNER_RSSI_BAR;
1082 else if (token->type == SKIN_TOKEN_PEAKMETER_LEFT)
1083 token->type = SKIN_TOKEN_PEAKMETER_LEFTBAR;
1084 else if (token->type == SKIN_TOKEN_PEAKMETER_RIGHT)
1085 token->type = SKIN_TOKEN_PEAKMETER_RIGHTBAR;
1086 else if (token->type == SKIN_TOKEN_LIST_NEEDS_SCROLLBAR)
1087 token->type = SKIN_TOKEN_LIST_SCROLLBAR;
1088 else if (token->type == SKIN_TOKEN_SETTING)
1089 token->type = SKIN_TOKEN_SETTINGBAR;
1090 pb->type = token->type;
1091
1092 #ifdef HAVE_TOUCHSCREEN
1093 if (!suppress_touchregion &&
1094 (token->type == SKIN_TOKEN_VOLUMEBAR ||
1095 token->type == SKIN_TOKEN_PROGRESSBAR ||
1096 token->type == SKIN_TOKEN_SETTINGBAR))
1097 {
1098 struct touchregion *region = skin_buffer_alloc(sizeof(*region));
1099 struct skin_token_list *item;
1100 int wpad, hpad;
1101
1102 if (!region)
1103 return 0;
1104
1105 if (token->type == SKIN_TOKEN_VOLUMEBAR)
1106 region->action = ACTION_TOUCH_VOLUME;
1107 else if (token->type == SKIN_TOKEN_SETTINGBAR)
1108 region->action = ACTION_TOUCH_SETTING;
1109 else
1110 region->action = ACTION_TOUCH_SCROLLBAR;
1111
1112 /* try to add some extra space on either end to make pressing the
1113 * full bar easier. ~5% on either side
1114 */
1115 wpad = pb->width * 5 / 100;
1116 if (wpad > 10)
1117 wpad = 10;
1118 hpad = pb->height * 5 / 100;
1119 if (hpad > 10)
1120 hpad = 10;
1121
1122 region->x = pb->x - wpad;
1123 if (region->x < 0)
1124 region->x = 0;
1125 region->width = pb->width + 2 * wpad;
1126 if (region->x + region->width > curr_vp->vp.x + curr_vp->vp.width)
1127 region->width = curr_vp->vp.x + curr_vp->vp.width - region->x;
1128
1129 region->y = pb->y - hpad;
1130 if (region->y < 0)
1131 region->y = 0;
1132 region->height = pb->height + 2 * hpad;
1133 if (region->y + region->height > curr_vp->vp.y + curr_vp->vp.height)
1134 region->height = curr_vp->vp.y + curr_vp->vp.height - region->y;
1135
1136 region->wvp = PTRTOSKINOFFSET(skin_buffer, curr_vp);
1137 region->reverse_bar = false;
1138 region->allow_while_locked = false;
1139 region->press_length = PRESS;
1140 region->last_press = 0xffff;
1141 region->armed = false;
1142 region->bar = PTRTOSKINOFFSET(skin_buffer, pb);
1143
1144 item = new_skin_token_list_item(NULL, region);
1145 if (!item)
1146 return WPS_ERROR_INVALID_PARAM;
1147 add_to_ll_chain(&wps_data->touchregions, item);
1148 }
1149 #endif
1150
1151 return 0;
1152
1153 #else
1154 (void)element;
1155 if (token->type == SKIN_TOKEN_PROGRESSBAR ||
1156 token->type == SKIN_TOKEN_PLAYER_PROGRESSBAR)
1157 {
1158 wps_data->full_line_progressbar =
1159 token->type == SKIN_TOKEN_PLAYER_PROGRESSBAR;
1160 }
1161 return 0;
1162
1163 #endif
1164 }
1165
1166 #ifdef HAVE_ALBUMART
1167 static int parse_albumart_load(struct skin_element* element,
1168 struct wps_token *token,
1169 struct wps_data *wps_data)
1170 {
1171 struct dim dimensions;
1172 int albumart_slot;
1173 bool swap_for_rtl = lang_is_rtl() && follow_lang_direction;
1174 struct skin_albumart *aa = skin_buffer_alloc(sizeof(*aa));
1175 (void)token; /* silence warning */
1176 if (!aa)
1177 return -1;
1178
1179 /* reset albumart info in wps */
1180 aa->width = -1;
1181 aa->height = -1;
1182 aa->xalign = WPS_ALBUMART_ALIGN_CENTER; /* default */
1183 aa->yalign = WPS_ALBUMART_ALIGN_CENTER; /* default */
1184
1185 aa->x = get_param(element, 0)->data.number;
1186 aa->y = get_param(element, 1)->data.number;
1187 aa->width = get_param(element, 2)->data.number;
1188 aa->height = get_param(element, 3)->data.number;
1189
1190 aa->vp = PTRTOSKINOFFSET(skin_buffer, &curr_vp->vp);
1191 aa->draw_handle = -1;
1192
1193 /* if we got here, we parsed everything ok .. ! */
1194 if (aa->width < 0)
1195 aa->width = 0;
1196 else if (aa->width > LCD_WIDTH)
1197 aa->width = LCD_WIDTH;
1198
1199 if (aa->height < 0)
1200 aa->height = 0;
1201 else if (aa->height > LCD_HEIGHT)
1202 aa->height = LCD_HEIGHT;
1203
1204 if (swap_for_rtl)
1205 aa->x = LCD_WIDTH - (aa->x + aa->width);
1206
1207 aa->state = WPS_ALBUMART_LOAD;
1208 wps_data->albumart = PTRTOSKINOFFSET(skin_buffer, aa);
1209
1210 dimensions.width = aa->width;
1211 dimensions.height = aa->height;
1212
1213 albumart_slot = playback_claim_aa_slot(&dimensions);
1214
1215 if (0 <= albumart_slot)
1216 wps_data->playback_aa_slot = albumart_slot;
1217
1218 if (element->params_count > 4 && !isdefault(get_param(element, 4)))
1219 {
1220 switch (*get_param_text(element, 4))
1221 {
1222 case 'l':
1223 case 'L':
1224 if (swap_for_rtl)
1225 aa->xalign = WPS_ALBUMART_ALIGN_RIGHT;
1226 else
1227 aa->xalign = WPS_ALBUMART_ALIGN_LEFT;
1228 break;
1229 case 'c':
1230 case 'C':
1231 aa->xalign = WPS_ALBUMART_ALIGN_CENTER;
1232 break;
1233 case 'r':
1234 case 'R':
1235 if (swap_for_rtl)
1236 aa->xalign = WPS_ALBUMART_ALIGN_LEFT;
1237 else
1238 aa->xalign = WPS_ALBUMART_ALIGN_RIGHT;
1239 break;
1240 }
1241 }
1242 if (element->params_count > 5 && !isdefault(get_param(element, 5)))
1243 {
1244 switch (*get_param_text(element, 5))
1245 {
1246 case 't':
1247 case 'T':
1248 aa->yalign = WPS_ALBUMART_ALIGN_TOP;
1249 break;
1250 case 'c':
1251 case 'C':
1252 aa->yalign = WPS_ALBUMART_ALIGN_CENTER;
1253 break;
1254 case 'b':
1255 case 'B':
1256 aa->yalign = WPS_ALBUMART_ALIGN_BOTTOM;
1257 break;
1258 }
1259 }
1260 return 0;
1261 }
1262
1263 #endif /* HAVE_ALBUMART */
1264 #ifdef HAVE_SKIN_VARIABLES
1265 static struct skin_var* find_or_add_var(const char* label,
1266 struct wps_data *data)
1267 {
1268 struct skin_var* ret = skin_find_item(label, SKIN_VARIABLE, data);
1269 if (ret)
1270 return ret;
1271
1272 ret = skin_buffer_alloc(sizeof(*ret));
1273 if (!ret)
1274 return ret;
1275 ret->label = PTRTOSKINOFFSET(skin_buffer, label);
1276 ret->value = 1;
1277 ret->last_changed = 0xffff;
1278 struct skin_token_list *item = new_skin_token_list_item(NULL, ret);
1279 if (!item)
1280 return NULL;
1281 add_to_ll_chain(&data->skinvars, item);
1282 return ret;
1283 }
1284 static int parse_skinvar( struct skin_element *element,
1285 struct wps_token *token,
1286 struct wps_data *wps_data)
1287 {
1288 const char* label = get_param_text(element, 0);
1289 struct skin_var* var = find_or_add_var(label, wps_data);
1290 if (!var)
1291 return WPS_ERROR_INVALID_PARAM;
1292 switch (token->type)
1293 {
1294 case SKIN_TOKEN_VAR_GETVAL:
1295 token->value.data = PTRTOSKINOFFSET(skin_buffer, var);
1296 return 0;
1297 case SKIN_TOKEN_VAR_SET:
1298 {
1299 struct skin_var_changer *data = skin_buffer_alloc(sizeof(*data));
1300 if (!data)
1301 return WPS_ERROR_INVALID_PARAM;
1302 data->var = PTRTOSKINOFFSET(skin_buffer, var);
1303 if (!isdefault(get_param(element, 2)))
1304 data->newval = get_param(element, 2)->data.number;
1305 else if (strcmp(get_param_text(element, 1), "touch"))
1306 return WPS_ERROR_INVALID_PARAM;
1307 data->max = 0;
1308 if (!strcmp(get_param_text(element, 1), "set"))
1309 data->direct = true;
1310 else if (!strcmp(get_param_text(element, 1), "inc"))
1311 {
1312 data->direct = false;
1313 }
1314 else if (!strcmp(get_param_text(element, 1), "dec"))
1315 {
1316 data->direct = false;
1317 data->newval *= -1;
1318 }
1319 else if (!strcmp(get_param_text(element, 1), "touch"))
1320 {
1321 data->direct = false;
1322 data->newval = 0;
1323 }
1324 if (element->params_count > 3)
1325 data->max = get_param(element, 3)->data.number;
1326 token->value.data = PTRTOSKINOFFSET(skin_buffer, data);
1327 }
1328 return 0;
1329 case SKIN_TOKEN_VAR_TIMEOUT:
1330 {
1331 struct skin_var_lastchange *data = skin_buffer_alloc(sizeof(*data));
1332 if (!data)
1333 return WPS_ERROR_INVALID_PARAM;
1334 data->var = PTRTOSKINOFFSET(skin_buffer, var);
1335 data->timeout = 10;
1336 if (element->params_count > 1)
1337 data->timeout = get_param(element, 1)->data.number;
1338 data->timeout *= TIMEOUT_UNIT;
1339 token->value.data = PTRTOSKINOFFSET(skin_buffer, data);
1340 }
1341 default:
1342 return 0;
1343 }
1344 }
1345 #endif /* HAVE_SKIN_VARIABLES */
1346 #ifdef HAVE_TOUCHSCREEN
1347 static int parse_lasttouch(struct skin_element *element,
1348 struct wps_token *token,
1349 struct wps_data *wps_data)
1350 {
1351 struct touchregion_lastpress *data = skin_buffer_alloc(sizeof(*data));
1352 int i;
1353 struct touchregion *region = NULL;
1354 if (!data)
1355 return WPS_ERROR_INVALID_PARAM;
1356
1357 data->timeout = 10;
1358
1359 for (i=0; i<element->params_count; i++)
1360 {
1361 if (get_param(element, i)->type == STRING)
1362 region = skin_find_item(get_param_text(element, i),
1363 SKIN_FIND_TOUCHREGION, wps_data);
1364 else if (get_param(element, i)->type == INTEGER ||
1365 get_param(element, i)->type == DECIMAL)
1366 data->timeout = get_param(element, i)->data.number;
1367 }
1368
1369 data->region = PTRTOSKINOFFSET(skin_buffer, region);
1370 data->timeout *= TIMEOUT_UNIT;
1371 token->value.data = PTRTOSKINOFFSET(skin_buffer, data);
1372 return 0;
1373 }
1374
1375 struct touchaction {const char* s; int action;};
1376 static const struct touchaction touchactions[] = {
1377 /* generic actions, convert to screen actions on use */
1378 {"none", ACTION_TOUCHSCREEN_IGNORE},{"lock", ACTION_TOUCH_SOFTLOCK },
1379 {"prev", ACTION_STD_PREV }, {"next", ACTION_STD_NEXT },
1380 {"hotkey", ACTION_STD_HOTKEY}, {"select", ACTION_STD_OK },
1381 {"menu", ACTION_STD_MENU }, {"cancel", ACTION_STD_CANCEL },
1382 {"contextmenu", ACTION_STD_CONTEXT},{"quickscreen", ACTION_STD_QUICKSCREEN },
1383
1384 /* list/tree actions */
1385 { "resumeplayback", ACTION_TREE_WPS}, /* returns to previous music, WPS/FM */
1386 /* not really WPS specific, but no equivilant ACTION_STD_* */
1387 {"voldown", ACTION_WPS_VOLDOWN}, {"volup", ACTION_WPS_VOLUP},
1388 {"mute", ACTION_TOUCH_MUTE },
1389
1390 /* generic settings changers */
1391 {"setting_inc", ACTION_SETTINGS_INC}, {"setting_dec", ACTION_SETTINGS_DEC},
1392 {"setting_set", ACTION_SETTINGS_SET},
1393
1394 /* WPS specific actions */
1395 {"rwd", ACTION_WPS_SEEKBACK }, {"ffwd", ACTION_WPS_SEEKFWD },
1396 {"wps_prev", ACTION_WPS_SKIPPREV }, {"wps_next", ACTION_WPS_SKIPNEXT },
1397 {"browse", ACTION_WPS_BROWSE },
1398 {"play", ACTION_WPS_PLAY }, {"stop", ACTION_WPS_STOP },
1399 {"shuffle", ACTION_TOUCH_SHUFFLE }, {"repmode", ACTION_TOUCH_REPMODE },
1400 {"pitch", ACTION_WPS_PITCHSCREEN}, {"trackinfo", ACTION_WPS_ID3SCREEN },
1401 {"playlist", ACTION_WPS_VIEW_PLAYLIST },
1402 {"listbookmarks", ACTION_WPS_LIST_BOOKMARKS },
1403 {"createbookmark", ACTION_WPS_CREATE_BOOKMARK },
1404
1405 #if CONFIG_TUNER
1406 /* FM screen actions */
1407 /* Also allow browse, play, stop from WPS codes */
1408 {"mode", ACTION_FM_MODE }, {"record", ACTION_FM_RECORD },
1409 {"presets", ACTION_FM_PRESET},
1410 #endif
1411 };
1412
1413 static int touchregion_setup_setting(struct skin_element *element, int param_no,
1414 struct touchregion *region)
1415 {
1416 #ifndef __PCTOOL__
1417 int p = param_no;
1418 char *name = get_param_text(element, p++);
1419 int j;
1420
1421 region->setting_data.setting = find_setting_by_cfgname(name, &j);
1422 if (region->setting_data.setting == NULL)
1423 return WPS_ERROR_INVALID_PARAM;
1424
1425 if (region->action == ACTION_SETTINGS_SET)
1426 {
1427 char* text;
1428 int temp;
1429 struct touchsetting *setting =
1430 &region->setting_data;
1431 if (element->params_count < p+1)
1432 return -1;
1433
1434 text = get_param_text(element, p++);
1435 switch (settings[j].flags&F_T_MASK)
1436 {
1437 case F_T_CUSTOM:
1438 setting->value.text = PTRTOSKINOFFSET(skin_buffer, text);
1439 break;
1440 case F_T_INT:
1441 case F_T_UINT:
1442 if (settings[j].cfg_vals == NULL)
1443 {
1444 setting->value.number = atoi(text);
1445 }
1446 else if (cfg_string_to_int(j, &temp, text))
1447 {
1448 if (settings[j].flags&F_TABLE_SETTING)
1449 setting->value.number =
1450 settings[j].table_setting->values[temp];
1451 else
1452 setting->value.number = temp;
1453 }
1454 else
1455 return -1;
1456 break;
1457 case F_T_BOOL:
1458 if (cfg_string_to_int(j, &temp, text))
1459 {
1460 setting->value.number = temp;
1461 }
1462 else
1463 return -1;
1464 break;
1465 default:
1466 return -1;
1467 }
1468 }
1469 return p-param_no;
1470 #endif /* __PCTOOL__ */
1471 return 0;
1472 }
1473
1474 static int parse_touchregion(struct skin_element *element,
1475 struct wps_token *token,
1476 struct wps_data *wps_data)
1477 {
1478 (void)token;
1479 unsigned i, imax;
1480 int p;
1481 struct touchregion *region = NULL;
1482 const char *action;
1483 const char pb_string[] = "progressbar";
1484 const char vol_string[] = "volume";
1485
1486 /* format: %T([label,], x,y,width,height,action[, ...])
1487 * if action starts with & the area must be held to happen
1488 */
1489
1490
1491 region = skin_buffer_alloc(sizeof(*region));
1492 if (!region)
1493 return WPS_ERROR_INVALID_PARAM;
1494
1495 /* should probably do some bounds checking here with the viewport... but later */
1496 region->action = ACTION_NONE;
1497
1498 if (get_param(element, 0)->type == STRING)
1499 {
1500 region->label = PTRTOSKINOFFSET(skin_buffer, get_param_text(element, 0));
1501 p = 1;
1502 /* "[SI]III[SI]|SS" is the param list. There MUST be 4 numbers
1503 * followed by at least one string. Verify that here */
1504 if (element->params_count < 6 ||
1505 get_param(element, 4)->type != INTEGER)
1506 return WPS_ERROR_INVALID_PARAM;
1507 }
1508 else
1509 {
1510 region->label = PTRTOSKINOFFSET(skin_buffer, NULL);
1511 p = 0;
1512 }
1513
1514 region->x = get_param(element, p++)->data.number;
1515 region->y = get_param(element, p++)->data.number;
1516 region->width = get_param(element, p++)->data.number;
1517 region->height = get_param(element, p++)->data.number;
1518 region->wvp = PTRTOSKINOFFSET(skin_buffer, curr_vp);
1519 region->armed = false;
1520 region->reverse_bar = false;
1521 region->value = 0;
1522 region->last_press = 0xffff;
1523 region->press_length = PRESS;
1524 region->allow_while_locked = false;
1525 region->bar = PTRTOSKINOFFSET(skin_buffer, NULL);
1526 action = get_param_text(element, p++);
1527
1528 /* figure out the action */
1529 if(!strcmp(pb_string, action))
1530 region->action = ACTION_TOUCH_SCROLLBAR;
1531 else if(!strcmp(vol_string, action))
1532 region->action = ACTION_TOUCH_VOLUME;
1533 else
1534 {
1535 imax = ARRAYLEN(touchactions);
1536 for (i = 0; i < imax; i++)
1537 {
1538 /* try to match with one of our touchregion screens */
1539 if (!strcmp(touchactions[i].s, action))
1540 {
1541 region->action = touchactions[i].action;
1542 if (region->action == ACTION_SETTINGS_INC ||
1543 region->action == ACTION_SETTINGS_DEC ||
1544 region->action == ACTION_SETTINGS_SET)
1545 {
1546 int val;
1547 if (element->params_count < p+1)
1548 return WPS_ERROR_INVALID_PARAM;
1549 val = touchregion_setup_setting(element, p, region);
1550 if (val < 0)
1551 return WPS_ERROR_INVALID_PARAM;
1552 p += val;
1553 }
1554 break;
1555 }
1556 }
1557 if (region->action == ACTION_NONE)
1558 return WPS_ERROR_INVALID_PARAM;
1559 }
1560 while (p < element->params_count)
1561 {
1562 char* param = get_param_text(element, p++);
1563 if (!strcmp(param, "allow_while_locked"))
1564 region->allow_while_locked = true;
1565 else if (!strcmp(param, "reverse_bar"))
1566 region->reverse_bar = true;
1567 else if (!strcmp(param, "repeat_press"))
1568 region->press_length = REPEAT;
1569 else if (!strcmp(param, "long_press"))
1570 region->press_length = LONG_PRESS;
1571 }
1572 struct skin_token_list *item = new_skin_token_list_item(NULL, region);
1573 if (!item)
1574 return WPS_ERROR_INVALID_PARAM;
1575 add_to_ll_chain(&wps_data->touchregions, item);
1576
1577 if (region->action == ACTION_TOUCH_MUTE)
1578 {
1579 region->value = global_settings.volume;
1580 }
1581
1582
1583 return 0;
1584 }
1585 #endif
1586
1587 static bool check_feature_tag(const int type)
1588 {
1589 switch (type)
1590 {
1591 case SKIN_TOKEN_RTC_PRESENT:
1592 #if CONFIG_RTC
1593 return true;
1594 #else
1595 return false;
1596 #endif
1597 case SKIN_TOKEN_HAVE_RECORDING:
1598 #ifdef HAVE_RECORDING
1599 return true;
1600 #else
1601 return false;
1602 #endif
1603 case SKIN_TOKEN_HAVE_TUNER:
1604 #if CONFIG_TUNER
1605 if (radio_hardware_present())
1606 return true;
1607 #endif
1608 return false;
1609 case SKIN_TOKEN_HAVE_TOUCH:
1610 #ifdef HAVE_TOUCHSCREEN
1611 return true;
1612 #else
1613 return false;
1614 #endif
1615
1616 #if CONFIG_TUNER
1617 case SKIN_TOKEN_HAVE_RDS:
1618 #ifdef HAVE_RDS_CAP
1619 return true;
1620 #else
1621 return false;
1622 #endif /* HAVE_RDS_CAP */
1623 #endif /* CONFIG_TUNER */
1624 default: /* not a tag we care about, just don't skip */
1625 return true;
1626 }
1627 }
1628
1629 /* This is used to free any buflib allocations before the rest of
1630 * wps_data is reset.
1631 * The call to this in settings_apply_skins() is the last chance to do
1632 * any core_free()'s before wps_data is trashed and those handles lost
1633 */
1634 void skin_data_free_buflib_allocs(struct wps_data *wps_data)
1635 {
1636 if (wps_data->wps_loaded)
1637 skin_buffer = get_skin_buffer(wps_data);
1638 #ifdef HAVE_LCD_BITMAP
1639 #ifndef __PCTOOL__
1640 struct skin_token_list *list = SKINOFFSETTOPTR(skin_buffer, wps_data->images);
1641 int *font_ids = SKINOFFSETTOPTR(skin_buffer, wps_data->font_ids);
1642 while (list)
1643 {
1644 struct wps_token *token = SKINOFFSETTOPTR(skin_buffer, list->token);
1645 struct gui_img *img = (struct gui_img*)SKINOFFSETTOPTR(skin_buffer, token->value.data);
1646 if (img->buflib_handle > 0)
1647 core_free(img->buflib_handle);
1648 list = SKINOFFSETTOPTR(skin_buffer, list->next);
1649 }
1650 wps_data->images = PTRTOSKINOFFSET(skin_buffer, NULL);
1651 if (font_ids != NULL)
1652 {
1653 while (wps_data->font_count > 0)
1654 font_unload(font_ids[--wps_data->font_count]);
1655 }
1656 wps_data->font_ids = PTRTOSKINOFFSET(skin_buffer, NULL);
1657 if (wps_data->buflib_handle > 0)
1658 core_free(wps_data->buflib_handle);
1659 wps_data->buflib_handle = -1;
1660 #endif
1661 #endif
1662 }
1663
1664 /*
1665 * initial setup of wps_data; does reset everything
1666 * except fields which need to survive, i.e.
1667 * Also called if the load fails
1668 **/
1669 static void skin_data_reset(struct wps_data *wps_data)
1670 {
1671 skin_data_free_buflib_allocs(wps_data);
1672 #ifdef HAVE_LCD_BITMAP
1673 wps_data->images = INVALID_OFFSET;
1674 #endif
1675 wps_data->tree = INVALID_OFFSET;
1676 #ifdef HAVE_BACKDROP_IMAGE
1677 if (wps_data->backdrop_id >= 0)
1678 skin_backdrop_unload(wps_data->backdrop_id);
1679 backdrop_filename = NULL;
1680 #endif
1681 #ifdef HAVE_TOUCHSCREEN
1682 wps_data->touchregions = INVALID_OFFSET;
1683 #endif
1684 #ifdef HAVE_SKIN_VARIABLES
1685 wps_data->skinvars = INVALID_OFFSET;
1686 #endif
1687 #ifdef HAVE_ALBUMART
1688 wps_data->albumart = INVALID_OFFSET;
1689 if (wps_data->playback_aa_slot >= 0)
1690 {
1691 playback_release_aa_slot(wps_data->playback_aa_slot);
1692 wps_data->playback_aa_slot = -1;
1693 }
1694 #endif
1695
1696 #ifdef HAVE_LCD_BITMAP
1697 wps_data->peak_meter_enabled = false;
1698 wps_data->wps_sb_tag = false;
1699 wps_data->show_sb_on_wps = false;
1700 #else /* HAVE_LCD_CHARCELLS */
1701 /* progress bars */
1702 int i;
1703 for (i = 0; i < 8; i++)
1704 {
1705 wps_data->wps_progress_pat[i] = 0;
1706 }
1707 wps_data->full_line_progressbar = false;
1708 #endif
1709 wps_data->wps_loaded = false;
1710 }
1711
1712 #ifdef HAVE_LCD_BITMAP
1713 #ifndef __PCTOOL__
1714 static int currently_loading_handle = -1;
1715 static int buflib_move_callback(int handle, void* current, void* new)
1716 {
1717 (void)current;
1718 (void)new;
1719 if (handle == currently_loading_handle)
1720 return BUFLIB_CB_CANNOT_MOVE;
1721 return BUFLIB_CB_OK;
1722 }
1723 static struct buflib_callbacks buflib_ops = {buflib_move_callback, NULL, NULL};
1724 static void lock_handle(int handle)
1725 {
1726 currently_loading_handle = handle;
1727 }
1728 static void unlock_handle(void)
1729 {
1730 currently_loading_handle = -1;
1731 }
1732 #endif
1733
1734 static int load_skin_bmp(struct wps_data *wps_data, struct bitmap *bitmap, char* bmpdir)
1735 {
1736 (void)wps_data; /* only needed for remote targets */
1737 char img_path[MAX_PATH];
1738 int fd;
1739 int handle;
1740 get_image_filename(bitmap->data, bmpdir,
1741 img_path, sizeof(img_path));
1742
1743 /* load the image */
1744 int format;
1745 #ifdef HAVE_REMOTE_LCD
1746 if (curr_screen == SCREEN_REMOTE)
1747 format = FORMAT_ANY|FORMAT_REMOTE;
1748 else
1749 #endif
1750 format = FORMAT_ANY|FORMAT_TRANSPARENT;
1751
1752 fd = open(img_path, O_RDONLY);
1753 if (fd < 0)
1754 {
1755 DEBUGF("Couldn't open %s\n", img_path);
1756 return fd;
1757 }
1758 #ifndef __PCTOOL__
1759 size_t buf_size = read_bmp_fd(fd, bitmap, 0,
1760 format|FORMAT_RETURN_SIZE, NULL);
1761 handle = core_alloc_ex(bitmap->data, buf_size, &buflib_ops);
1762 if (handle <= 0)
1763 {
1764 DEBUGF("Not enough skin buffer: need %zd more.\n",
1765 buf_size - skin_buffer_freespace());
1766 close(fd);
1767 return handle;
1768 }
1769 lseek(fd, 0, SEEK_SET);
1770 lock_handle(handle);
1771 bitmap->data = core_get_data(handle);
1772 int ret = read_bmp_fd(fd, bitmap, buf_size, format, NULL);
1773 bitmap->data = NULL; /* do this to force a crash later if the
1774 caller doesnt call core_get_data() */
1775 unlock_handle();
1776 close(fd);
1777 if (ret > 0)
1778 {
1779 /* free unused alpha channel, if any */
1780 core_shrink(handle, core_get_data(handle), ret);
1781 return handle;
1782 }
1783 else
1784 {
1785 /* Abort if we can't load an image */
1786 DEBUGF("Couldn't load '%s'\n", img_path);
1787 core_free(handle);
1788 return -1;
1789 }
1790 #else /* !__PCTOOL__ */
1791 close(fd);
1792 return 1;
1793 #endif
1794 }
1795
1796 static bool load_skin_bitmaps(struct wps_data *wps_data, char *bmpdir)
1797 {
1798 struct skin_token_list *list;
1799 bool retval = true; /* return false if a single image failed to load */
1800
1801 /* regular images */
1802 list = SKINOFFSETTOPTR(skin_buffer, wps_data->images);
1803 while (list)
1804 {
1805 struct wps_token *token = SKINOFFSETTOPTR(skin_buffer, list->token);
1806 struct gui_img *img = (struct gui_img*)SKINOFFSETTOPTR(skin_buffer, token->value.data);
1807 if (img->bm.data)
1808 {
1809 if (img->using_preloaded_icons)
1810 {
1811 img->loaded = true;
1812 token->type = SKIN_TOKEN_IMAGE_DISPLAY_LISTICON;
1813 }
1814 else
1815 {
1816 img->buflib_handle = load_skin_bmp(wps_data, &img->bm, bmpdir);
1817 img->loaded = img->buflib_handle >= 0;
1818 if (img->loaded)
1819 img->subimage_height = img->bm.height / img->num_subimages;
1820 else
1821 retval = false;
1822 }
1823 }
1824 list = SKINOFFSETTOPTR(skin_buffer, list->next);
1825 }
1826
1827 #ifdef HAVE_BACKDROP_IMAGE
1828 wps_data->backdrop_id = skin_backdrop_assign(backdrop_filename, bmpdir, curr_screen);
1829 #endif /* has backdrop support */
1830 return retval;
1831 }
1832
1833 static bool skin_load_fonts(struct wps_data *data)
1834 {
1835 /* don't spit out after the first failue to aid debugging */
1836 int id_array[MAXUSERFONTS];
1837 int font_count = 0;
1838 bool success = true;
1839 struct skin_element *vp_list;
1840 int font_id;
1841 /* walk though each viewport and assign its font */
1842 for(vp_list = SKINOFFSETTOPTR(skin_buffer, data->tree);
1843 vp_list; vp_list = SKINOFFSETTOPTR(skin_buffer, vp_list->next))
1844 {
1845 /* first, find the viewports that have a non-sys/ui-font font */
1846 struct skin_viewport *skin_vp =
1847 SKINOFFSETTOPTR(skin_buffer, vp_list->data);
1848 struct viewport *vp = &skin_vp->vp;
1849
1850 font_id = skin_vp->parsed_fontid;
1851 if (font_id == 1)
1852 { /* the usual case -> built-in fonts */
1853 vp->font = screens[curr_screen].getuifont();
1854 continue;
1855 }
1856 else if (font_id <= 0)
1857 {
1858 vp->font = FONT_SYSFIXED;
1859 continue;
1860 }
1861
1862 /* now find the corresponding skin_font */
1863 struct skin_font *font = &skinfonts[font_id-2];
1864 if (!font->name)
1865 {
1866 if (success)
1867 {
1868 DEBUGF("font %d not specified\n", font_id);
1869 }
1870 success = false;
1871 continue;
1872 }
1873
1874 /* load the font - will handle loading the same font again if
1875 * multiple viewports use the same */
1876 if (font->id < 0)
1877 {
1878 char path[MAX_PATH];
1879 snprintf(path, sizeof path, FONT_DIR "/%s", font->name);
1880 #ifndef __PCTOOL__
1881 font->id = font_load_ex(path, 0, skinfonts[font_id-2].glyphs);
1882
1883 #else
1884 font->id = font_load(path);
1885 #endif
1886 //printf("[%d] %s -> %d\n",font_id, font->name, font->id);
1887 id_array[font_count++] = font->id;
1888 }
1889
1890 if (font->id < 0)
1891 {
1892 DEBUGF("Unable to load font %d: '%s'\n", font_id, font->name);
1893 font->name = NULL; /* to stop trying to load it again if we fail */
1894 success = false;
1895 continue;
1896 }
1897
1898 /* finally, assign the font_id to the viewport */
1899 vp->font = font->id;
1900 }
1901 if (font_count)
1902 {
1903 int *font_ids = skin_buffer_alloc(font_count * sizeof(int));
1904 if (!success || font_ids == NULL)
1905 {
1906 while (font_count > 0)
1907 {
1908 if(id_array[--font_count] != -1)
1909 font_unload(id_array[font_count]);
1910 }
1911 data->font_ids = PTRTOSKINOFFSET(skin_buffer, NULL);
1912 return false;
1913 }
1914 memcpy(font_ids, id_array, sizeof(int)*font_count);
1915 data->font_count = font_count;
1916 data->font_ids = PTRTOSKINOFFSET(skin_buffer, font_ids);
1917 }
1918 else
1919 {
1920 data->font_count = 0;
1921 data->font_ids = PTRTOSKINOFFSET(skin_buffer, NULL);
1922 }
1923 return success;
1924 }
1925
1926 #endif /* HAVE_LCD_BITMAP */
1927 static int convert_viewport(struct wps_data *data, struct skin_element* element)
1928 {
1929 struct skin_viewport *skin_vp = skin_buffer_alloc(sizeof(*skin_vp));
1930 struct screen *display = &screens[curr_screen];
1931
1932 if (!skin_vp)
1933 return CALLBACK_ERROR;
1934
1935 skin_vp->hidden_flags = 0;
1936 skin_vp->label = PTRTOSKINOFFSET(skin_buffer, NULL);
1937 skin_vp->is_infovp = false;
1938 skin_vp->parsed_fontid = 1;
1939 element->data = PTRTOSKINOFFSET(skin_buffer, skin_vp);
1940 curr_vp = skin_vp;
1941 curr_viewport_element = element;
1942 if (!first_viewport)
1943 first_viewport = element;
1944
1945 viewport_set_defaults(&skin_vp->vp, curr_screen);
1946
1947 #if (LCD_DEPTH > 1) || (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1))
1948 skin_vp->output_to_backdrop_buffer = false;
1949 skin_vp->start_fgcolour = skin_vp->vp.fg_pattern;
1950 skin_vp->start_bgcolour = skin_vp->vp.bg_pattern;
1951 #endif
1952 #ifdef HAVE_LCD_COLOR
1953 skin_vp->start_gradient.start = skin_vp->vp.lss_pattern;
1954 skin_vp->start_gradient.end = skin_vp->vp.lse_pattern;
1955 skin_vp->start_gradient.text = skin_vp->vp.lst_pattern;
1956 #endif
1957
1958
1959 struct skin_tag_parameter *param = get_param(element, 0);
1960 if (element->params_count == 0) /* default viewport */
1961 {
1962 if (data->tree < 0) /* first viewport in the skin */
1963 data->tree = PTRTOSKINOFFSET(skin_buffer, element);
1964 skin_vp->label = VP_DEFAULT_LABEL;
1965 return CALLBACK_OK;
1966 }
1967
1968 if (element->params_count == 6)
1969 {
1970 if (element->tag->type == SKIN_TOKEN_UIVIEWPORT_LOAD)
1971 {
1972 skin_vp->is_infovp = true;
1973 if (isdefault(param))
1974 {
1975 skin_vp->hidden_flags = VP_NEVER_VISIBLE;
1976 skin_vp->label = VP_DEFAULT_LABEL;
1977 }
1978 else
1979 {
1980 skin_vp->hidden_flags = VP_NEVER_VISIBLE;
1981 skin_vp->label = param->data.text;
1982 }
1983 }
1984 else
1985 {
1986 skin_vp->hidden_flags = VP_DRAW_HIDEABLE|VP_DRAW_HIDDEN;
1987 skin_vp->label = param->data.text;
1988 }
1989 param++;
1990 }
1991 /* x */
1992 if (!isdefault(param))
1993 {
1994 skin_vp->vp.x = param->data.number;
1995 if (param->data.number < 0)
1996 skin_vp->vp.x += display->lcdwidth;
1997 else if (param->type == PERCENT)
1998 skin_vp->vp.x = param->data.number * display->lcdwidth / 1000;
1999 }
2000 param++;
2001 /* y */
2002 if (!isdefault(param))
2003 {
2004 skin_vp->vp.y = param->data.number;
2005 if (param->data.number < 0)
2006 skin_vp->vp.y += display->lcdheight;
2007 else if (param->type == PERCENT)
2008 skin_vp->vp.y = param->data.number * display->lcdheight / 1000;
2009 }
2010 param++;
2011 /* width */
2012 if (!isdefault(param))
2013 {
2014 skin_vp->vp.width = param->data.number;
2015 if (param->data.number < 0)
2016 skin_vp->vp.width = (skin_vp->vp.width + display->lcdwidth) - skin_vp->vp.x;
2017 else if (param->type == PERCENT)
2018 skin_vp->vp.width = param->data.number * display->lcdwidth / 1000;
2019 }
2020 else
2021 {
2022 skin_vp->vp.width = display->lcdwidth - skin_vp->vp.x;
2023 }
2024 param++;
2025 /* height */
2026 if (!isdefault(param))
2027 {
2028 skin_vp->vp.height = param->data.number;
2029 if (param->data.number < 0)
2030 skin_vp->vp.height = (skin_vp->vp.height + display->lcdheight) - skin_vp->vp.y;
2031 else if (param->type == PERCENT)
2032 skin_vp->vp.height = param->data.number * display->lcdheight / 1000;
2033 }
2034 else
2035 {
2036 skin_vp->vp.height = display->lcdheight - skin_vp->vp.y;
2037 }
2038 param++;
2039 #ifdef HAVE_LCD_BITMAP
2040 /* font */
2041 if (!isdefault(param))
2042 skin_vp->parsed_fontid = param->data.number;
2043 #endif
2044 if ((unsigned) skin_vp->vp.x >= (unsigned) display->lcdwidth ||
2045 skin_vp->vp.width + skin_vp->vp.x > display->lcdwidth ||
2046 (unsigned) skin_vp->vp.y >= (unsigned) display->lcdheight ||
2047 skin_vp->vp.height + skin_vp->vp.y > display->lcdheight)
2048 return CALLBACK_ERROR;
2049
2050 /* Fix x position for RTL languages */
2051 if (follow_lang_direction && lang_is_rtl())
2052 skin_vp->vp.x = display->lcdwidth - skin_vp->vp.x - skin_vp->vp.width;
2053
2054 return CALLBACK_OK;
2055 }
2056
2057 static int skin_element_callback(struct skin_element* element, void* data)
2058 {
2059 struct wps_data *wps_data = (struct wps_data *)data;
2060 struct wps_token *token;
2061 parse_function function = NULL;
2062
2063 switch (element->type)
2064 {
2065 /* IMPORTANT: element params are shared, so copy them if needed
2066 * or use then NOW, dont presume they have a long lifespan
2067 */
2068 case TAG:
2069 {
2070 token = skin_buffer_alloc(sizeof(*token));
2071 memset(token, 0, sizeof(*token));
2072 token->type = element->tag->type;
2073 token->value.data = INVALID_OFFSET;
2074
2075 if (element->tag->flags&SKIN_RTC_REFRESH)
2076 {
2077 #if CONFIG_RTC
2078 curr_line->update_mode |= SKIN_REFRESH_DYNAMIC;
2079 #else
2080 curr_line->update_mode |= SKIN_REFRESH_STATIC;
2081 #endif
2082 }
2083 else
2084 curr_line->update_mode |= element->tag->flags&SKIN_REFRESH_ALL;
2085
2086 element->data = PTRTOSKINOFFSET(skin_buffer, token);
2087
2088 /* Some tags need special handling for the tag, so add them here */
2089 switch (token->type)
2090 {
2091 case SKIN_TOKEN_ALIGN_LANGDIRECTION:
2092 follow_lang_direction = 2;
2093 break;
2094 case SKIN_TOKEN_LOGICAL_IF:
2095 function = parse_logical_if;
2096 break;
2097 case SKIN_TOKEN_LOGICAL_AND:
2098 case SKIN_TOKEN_LOGICAL_OR:
2099 function = parse_logical_andor;
2100 break;
2101 case SKIN_TOKEN_SUBSTRING:
2102 function = parse_substring_tag;
2103 break;
2104 case SKIN_TOKEN_PROGRESSBAR:
2105 case SKIN_TOKEN_VOLUME:
2106 case SKIN_TOKEN_BATTERY_PERCENT:
2107 case SKIN_TOKEN_PLAYER_PROGRESSBAR:
2108 case SKIN_TOKEN_PEAKMETER_LEFT:
2109 case SKIN_TOKEN_PEAKMETER_RIGHT:
2110 case SKIN_TOKEN_LIST_NEEDS_SCROLLBAR:
2111 #ifdef HAVE_RADIO_RSSI
2112 case SKIN_TOKEN_TUNER_RSSI:
2113 #endif
2114 function = parse_progressbar_tag;
2115 break;
2116 case SKIN_TOKEN_SUBLINE_TIMEOUT:
2117 case SKIN_TOKEN_BUTTON_VOLUME:
2118 case SKIN_TOKEN_TRACK_STARTING:
2119 case SKIN_TOKEN_TRACK_ENDING:
2120 function = parse_timeout_tag;
2121 break;
2122 #ifdef HAVE_LCD_BITMAP
2123 case SKIN_TOKEN_LIST_ITEM_TEXT:
2124 case SKIN_TOKEN_LIST_ITEM_ICON:
2125 function = parse_listitem;
2126 break;
2127 case SKIN_TOKEN_DISABLE_THEME:
2128 case SKIN_TOKEN_ENABLE_THEME:
2129 case SKIN_TOKEN_DRAW_INBUILTBAR:
2130 function = parse_statusbar_tags;
2131 break;
2132 case SKIN_TOKEN_LIST_TITLE_TEXT:
2133 #ifndef __PCTOOL__
2134 sb_skin_has_title(curr_screen);
2135 #endif
2136 break;
2137 #endif
2138 #if (LCD_DEPTH > 1) || (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1))
2139 case SKIN_TOKEN_DRAWRECTANGLE:
2140 function = parse_drawrectangle;
2141 break;
2142 #endif
2143 case SKIN_TOKEN_FILE_DIRECTORY:
2144 token->value.i = get_param(element, 0)->data.number;
2145 break;
2146 #ifdef HAVE_BACKDROP_IMAGE
2147 case SKIN_TOKEN_VIEWPORT_FGCOLOUR:
2148 case SKIN_TOKEN_VIEWPORT_BGCOLOUR:
2149 function = parse_viewportcolour;
2150 break;
2151 case SKIN_TOKEN_IMAGE_BACKDROP:
2152 function = parse_image_special;
2153 break;
2154 case SKIN_TOKEN_VIEWPORT_TEXTSTYLE:
2155 function = parse_viewporttextstyle;
2156 break;
2157 case SKIN_TOKEN_VIEWPORT_DRAWONBG:
2158 curr_vp->output_to_backdrop_buffer = true;
2159 backdrop_filename = BACKDROP_BUFFERNAME;
2160 wps_data->use_extra_framebuffer = true;
2161 break;
2162 #endif
2163 #ifdef HAVE_LCD_COLOR
2164 case SKIN_TOKEN_VIEWPORT_GRADIENT_SETUP:
2165 function = parse_viewport_gradient_setup;
2166 break;
2167 #endif
2168 case SKIN_TOKEN_TRANSLATEDSTRING:
2169 case SKIN_TOKEN_SETTING:
2170 function = parse_setting_and_lang;
2171 break;
2172 #ifdef HAVE_LCD_BITMAP
2173 case SKIN_TOKEN_VIEWPORT_CUSTOMLIST:
2174 function = parse_playlistview;
2175 break;
2176 case SKIN_TOKEN_LOAD_FONT:
2177 function = parse_font_load;
2178 break;
2179 case SKIN_TOKEN_VIEWPORT_ENABLE:
2180 case SKIN_TOKEN_UIVIEWPORT_ENABLE:
2181 token->value.data = get_param(element, 0)->data.text;
2182 break;
2183 case SKIN_TOKEN_IMAGE_PRELOAD_DISPLAY:
2184 function = parse_image_display;
2185 break;
2186 case SKIN_TOKEN_IMAGE_PRELOAD:
2187 case SKIN_TOKEN_IMAGE_DISPLAY:
2188 function = parse_image_load;
2189 break;
2190 case SKIN_TOKEN_LIST_ITEM_CFG:
2191 function = parse_listitemviewport;
2192 break;
2193 #endif
2194 #ifdef HAVE_TOUCHSCREEN
2195 case SKIN_TOKEN_TOUCHREGION:
2196 function = parse_touchregion;
2197 break;
2198 case SKIN_TOKEN_LASTTOUCH:
2199 function = parse_lasttouch;
2200 break;
2201 #endif
2202 #ifdef HAVE_ALBUMART
2203 case SKIN_TOKEN_ALBUMART_DISPLAY:
2204 if (SKINOFFSETTOPTR(skin_buffer, wps_data->albumart))
2205 {
2206 struct skin_albumart *aa = SKINOFFSETTOPTR(skin_buffer, wps_data->albumart);
2207 aa->vp = PTRTOSKINOFFSET(skin_buffer, &curr_vp->vp);
2208 }
2209 break;
2210 case SKIN_TOKEN_ALBUMART_LOAD:
2211 function = parse_albumart_load;
2212 break;
2213 #endif
2214 #ifdef HAVE_SKIN_VARIABLES
2215 case SKIN_TOKEN_VAR_SET:
2216 case SKIN_TOKEN_VAR_GETVAL:
2217 case SKIN_TOKEN_VAR_TIMEOUT:
2218 function = parse_skinvar;
2219 break;
2220 #endif
2221 default:
2222 break;
2223 }
2224 if (function)
2225 {
2226 if (function(element, token, wps_data) < 0)
2227 return CALLBACK_ERROR;
2228 }
2229 /* tags that start with 'F', 'I' or 'D' are for the next file */
2230 if ( *(element->tag->name) == 'I' || *(element->tag->name) == 'F' ||
2231 *(element->tag->name) == 'D')
2232 token->next = true;
2233 if (follow_lang_direction > 0 )
2234 follow_lang_direction--;
2235 break;
2236 }
2237 case VIEWPORT:
2238 return convert_viewport(wps_data, element);
2239 case LINE:
2240 {
2241 curr_line = skin_buffer_alloc(sizeof(*curr_line));
2242 curr_line->update_mode = SKIN_REFRESH_STATIC;
2243 element->data = PTRTOSKINOFFSET(skin_buffer, curr_line);
2244 }
2245 break;
2246 case LINE_ALTERNATOR:
2247 {
2248 struct line_alternator *alternator = skin_buffer_alloc(sizeof(*alternator));
2249 alternator->current_line = 0;
2250 #ifndef __PCTOOL__
2251 alternator->next_change_tick = current_tick;
2252 #endif
2253 element->data = PTRTOSKINOFFSET(skin_buffer, alternator);
2254 }
2255 break;
2256 case CONDITIONAL:
2257 {
2258 struct conditional *conditional = skin_buffer_alloc(sizeof(*conditional));
2259 conditional->last_value = -1;
2260 conditional->token = element->data;
2261 element->data = PTRTOSKINOFFSET(skin_buffer, conditional);
2262 if (!check_feature_tag(element->tag->type))
2263 {
2264 return FEATURE_NOT_AVAILABLE;
2265 }
2266 return CALLBACK_OK;
2267 }
2268 case TEXT:
2269 curr_line->update_mode |= SKIN_REFRESH_STATIC;
2270 break;
2271 default:
2272 break;
2273 }
2274 return CALLBACK_OK;
2275 }
2276
2277 /* to setup up the wps-data from a format-buffer (isfile = false)
2278 from a (wps-)file (isfile = true)*/
2279 bool skin_data_load(enum screen_type screen, struct wps_data *wps_data,
2280 const char *buf, bool isfile)
2281 {
2282 char *wps_buffer = NULL;
2283 if (!wps_data || !buf)
2284 return false;
2285 #ifdef HAVE_ALBUMART
2286 int status;
2287 struct mp3entry *curtrack;
2288 long offset;
2289 struct skin_albumart old_aa = {.state = WPS_ALBUMART_NONE};
2290 struct skin_albumart *aa = SKINOFFSETTOPTR(skin_buffer, wps_data->albumart);
2291 if (aa)
2292 {
2293 old_aa.state = aa->state;
2294 old_aa.height = aa->height;
2295 old_aa.width = aa->width;
2296 }
2297 #endif
2298 #ifdef HAVE_LCD_BITMAP
2299 int i;
2300 for (i=0;i<MAXUSERFONTS;i++)
2301 {
2302 skinfonts[i].id = -1;
2303 skinfonts[i].name = NULL;
2304 }
2305 #endif
2306 #ifdef DEBUG_SKIN_ENGINE
2307 if (isfile && debug_wps)
2308 {
2309 DEBUGF("\n=====================\nLoading '%s'\n=====================\n", buf);
2310 }
2311 #endif
2312
2313
2314 /* get buffer space from the plugin buffer */
2315 size_t buffersize = 0;
2316 wps_buffer = (char *)plugin_get_buffer(&buffersize);
2317
2318 if (!wps_buffer)
2319 return false;
2320
2321 skin_data_reset(wps_data);
2322 wps_data->wps_loaded = false;
2323 curr_screen = screen;
2324 curr_line = NULL;
2325 curr_vp = NULL;
2326 curr_viewport_element = NULL;
2327 first_viewport = NULL;
2328
2329 if (isfile)
2330 {
2331 int fd = open_utf8(buf, O_RDONLY);
2332
2333 if (fd < 0)
2334 return false;
2335 /* copy the file's content to the buffer for parsing,
2336 ensuring that every line ends with a newline char. */
2337 unsigned int start = 0;
2338 while(read_line(fd, wps_buffer + start, buffersize - start) > 0)
2339 {
2340 start += strlen(wps_buffer + start);
2341 if (start < buffersize - 1)
2342 {
2343 wps_buffer[start++] = '\n';
2344 wps_buffer[start] = 0;
2345 }
2346 }
2347 close(fd);
2348 if (start <= 0)
2349 return false;
2350 start++;
2351 skin_buffer = &wps_buffer[start];
2352 buffersize -= start;
2353 }
2354 else
2355 {
2356 skin_buffer = wps_buffer;
2357 wps_buffer = (char*)buf;
2358 }
2359 skin_buffer = (void *)(((unsigned long)skin_buffer + 3) & ~3);
2360 buffersize -= 3;
2361 #ifdef HAVE_BACKDROP_IMAGE
2362 backdrop_filename = "-";
2363 wps_data->backdrop_id = -1;
2364 #endif
2365 /* parse the skin source */
2366 skin_buffer_init(skin_buffer, buffersize);
2367 struct skin_element *tree = skin_parse(wps_buffer, skin_element_callback, wps_data);
2368 wps_data->tree = PTRTOSKINOFFSET(skin_buffer, tree);
2369 if (!SKINOFFSETTOPTR(skin_buffer, wps_data->tree)) {
2370 #ifdef DEBUG_SKIN_ENGINE
2371 if (isfile && debug_wps)
2372 skin_error_format_message();
2373 #endif
2374 skin_data_reset(wps_data);
2375 return false;
2376 }
2377
2378 #ifdef HAVE_LCD_BITMAP
2379 char bmpdir[MAX_PATH];
2380 if (isfile)
2381 {
2382 /* get the bitmap dir */
2383 char *dot = strrchr(buf, '.');
2384 strlcpy(bmpdir, buf, dot - buf + 1);
2385 }
2386 else
2387 {
2388 snprintf(bmpdir, MAX_PATH, "%s", BACKDROP_DIR);
2389 }
2390 /* load the bitmaps that were found by the parsing */
2391 if (!load_skin_bitmaps(wps_data, bmpdir) ||
2392 !skin_load_fonts(wps_data))
2393 {
2394 skin_data_reset(wps_data);
2395 return false;
2396 }
2397 #endif
2398 #if defined(HAVE_ALBUMART) && !defined(__PCTOOL__)
2399 status = audio_status();
2400 if (status & AUDIO_STATUS_PLAY)
2401 {
2402 struct skin_albumart *aa = SKINOFFSETTOPTR(skin_buffer, wps_data->albumart);
2403 if (aa && ((aa->state && !old_aa.state) ||
2404 (aa->state &&
2405 (((old_aa.height != aa->height) ||
2406 (old_aa.width != aa->width))))))
2407 {
2408 curtrack = audio_current_track();
2409 offset = curtrack->offset;
2410 audio_stop();
2411 if (!(status & AUDIO_STATUS_PAUSE))
2412 audio_play(offset);
2413 }
2414 }
2415 #endif
2416 #ifndef __PCTOOL__
2417 wps_data->buflib_handle = core_alloc(isfile ? buf : "failsafe skin",
2418 skin_buffer_usage());
2419 if (wps_data->buflib_handle > 0)
2420 {
2421 wps_data->wps_loaded = true;
2422 memcpy(core_get_data(wps_data->buflib_handle), skin_buffer,
2423 skin_buffer_usage());
2424 }
2425 #else
2426 wps_data->wps_loaded = wps_data->tree >= 0;
2427 #endif
2428
2429 #ifdef HAVE_TOUCHSCREEN
2430 /* Check if there are any touch regions from the skin and not just
2431 * auto-created ones for bars */
2432 struct skin_token_list *regions = SKINOFFSETTOPTR(skin_buffer,
2433 wps_data->touchregions);
2434 bool user_touch_region_found = false;
2435 while (regions)
2436 {
2437 struct wps_token *token = SKINOFFSETTOPTR(skin_buffer, regions->token);
2438 struct touchregion *r = SKINOFFSETTOPTR(skin_buffer, token->value.data);
2439
2440 if (r->action != ACTION_TOUCH_SCROLLBAR &&
2441 r->action != ACTION_TOUCH_VOLUME)
2442 {
2443 user_touch_region_found = true;
2444 break;
2445 }
2446 regions = SKINOFFSETTOPTR(skin_buffer, regions->next);
2447 }
2448 regions = SKINOFFSETTOPTR(skin_buffer, wps_data->touchregions);
2449 if (regions && !user_touch_region_found)
2450 wps_data->touchregions = PTRTOSKINOFFSET(skin_buffer, NULL);
2451 #endif
2452
2453 skin_buffer = NULL;
2454 return true;
2455 }
thomasjfox's rockbox modifications (mameo port)