apps/gui/skin_engine/skin_render.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id: skin_parser.c 26752 2010-06-10 21:22:16Z bieber $
   9  *
  10  * Copyright (C) 2010 Jonathan Gordon
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21
  22 #include <stdlib.h>
  23 #include <stdio.h>
  24 #include <string.h>
  25 #include <stdbool.h>
  26 #include <ctype.h>
  27 #include "strlcat.h"
  28
  29 #include "config.h"
  30 #include "core_alloc.h"
  31 #include "kernel.h"
  32 #ifdef HAVE_ALBUMART
  33 #include "albumart.h"
  34 #endif
  35 #include "settings.h"
  36 #include "skin_display.h"
  37 #include "skin_engine.h"
  38 #include "skin_parser.h"
  39 #include "tag_table.h"
  40 #include "skin_scan.h"
  41 #if CONFIG_TUNER
  42 #include "radio.h"
  43 #endif
  44 #include "viewport.h"
  45 #include "cuesheet.h"
  46 #include "language.h"
  47 #include "playback.h"
  48 #include "playlist.h"
  49 #include "root_menu.h"
  50 #include "misc.h"
  51 #include "list.h"
  52
  53
  54 #define MAX_LINE 1024
  55
  56 struct skin_draw_info {
  57     struct gui_wps *gwps;
  58     struct skin_viewport *skin_vp;
  59     int line_number;
  60     unsigned long refresh_type;
  61     unsigned text_style;
  62
  63     char* cur_align_start;
  64     struct align_pos align;
  65     bool no_line_break;
  66     bool line_scrolls;
  67     bool force_redraw;
  68
  69     char *buf;
  70     size_t buf_size;
  71
  72     int offset; /* used by the playlist viewer */
  73 };
  74
  75 typedef bool (*skin_render_func)(struct skin_element* alternator, struct skin_draw_info *info);
  76 bool skin_render_alternator(struct skin_element* alternator, struct skin_draw_info *info);
  77
  78 #ifdef HAVE_LCD_BITMAP
  79 static void skin_render_playlistviewer(struct playlistviewer* viewer,
  80                                        struct gui_wps *gwps,
  81                                        struct skin_viewport* skin_viewport,
  82                                        unsigned long refresh_type);
  83 #endif
  84
  85 static char* skin_buffer;
  86 /* hack alert: fix skin_parser.c's skin_buffer pointer */
  87 void skinparser_set_buffer(char* pointer);
  88
  89 static inline struct skin_element*
  90 get_child(OFFSETTYPE(struct skin_element**) children, int child)
  91 {
  92     OFFSETTYPE(struct skin_element*) *kids = SKINOFFSETTOPTR(skin_buffer, children);
  93     return SKINOFFSETTOPTR(skin_buffer, kids[child]);
  94 }
  95
  96
  97 static bool do_non_text_tags(struct gui_wps *gwps, struct skin_draw_info *info,
  98                              struct skin_element *element, struct viewport* vp)
  99 {
 100 #ifndef HAVE_LCD_BITMAP
 101     (void)vp; /* silence warnings */
 102     (void)info;
 103 #endif
 104     struct wps_token *token = (struct wps_token *)SKINOFFSETTOPTR(skin_buffer, element->data);
 105
 106 #ifdef HAVE_LCD_BITMAP
 107     struct wps_data *data = gwps->data;
 108     bool do_refresh = (element->tag->flags & info->refresh_type) > 0;
 109 #endif
 110     switch (token->type)
 111     {
 112 #if (LCD_DEPTH > 1) || (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1))
 113         case SKIN_TOKEN_VIEWPORT_FGCOLOUR:
 114         {
 115             struct viewport_colour *col = SKINOFFSETTOPTR(skin_buffer, token->value.data);
 116             struct viewport *vp = SKINOFFSETTOPTR(skin_buffer, col->vp);
 117             vp->fg_pattern = col->colour;
 118         }
 119         break;
 120         case SKIN_TOKEN_VIEWPORT_BGCOLOUR:
 121         {
 122             struct viewport_colour *col = SKINOFFSETTOPTR(skin_buffer, token->value.data);
 123             struct viewport *vp = SKINOFFSETTOPTR(skin_buffer, col->vp);
 124             vp->bg_pattern = col->colour;
 125         }
 126         break;
 127         case SKIN_TOKEN_VIEWPORT_TEXTSTYLE:
 128             info->text_style = token->value.l;
 129             break;
 130 #endif
 131 #ifdef HAVE_LCD_COLOR
 132         case SKIN_TOKEN_VIEWPORT_GRADIENT_SETUP:
 133         {
 134             struct gradient_config *cfg = SKINOFFSETTOPTR(skin_buffer, token->value.data);
 135             vp->lss_pattern = cfg->start;
 136             vp->lse_pattern = cfg->end;
 137             vp->lst_pattern = cfg->text;
 138         }
 139         break;
 140 #endif
 141         case SKIN_TOKEN_VIEWPORT_ENABLE:
 142         {
 143             char *label = SKINOFFSETTOPTR(skin_buffer, token->value.data);
 144             char temp = VP_DRAW_HIDEABLE;
 145             struct skin_element *viewport = SKINOFFSETTOPTR(skin_buffer, gwps->data->tree);
 146             while (viewport)
 147             {
 148                 struct skin_viewport *skinvp = SKINOFFSETTOPTR(skin_buffer, viewport->data);
 149
 150                 char *vplabel = SKINOFFSETTOPTR(skin_buffer, skinvp->label);
 151                 if (skinvp->label == VP_DEFAULT_LABEL)
 152                     vplabel = VP_DEFAULT_LABEL_STRING;
 153                 if (vplabel && !skinvp->is_infovp &&
 154                     !strcmp(vplabel, label))
 155                 {
 156                     if (skinvp->hidden_flags&VP_DRAW_HIDDEN)
 157                     {
 158                         temp |= VP_DRAW_WASHIDDEN;
 159                     }
 160                     skinvp->hidden_flags = temp;
 161                 }
 162                 viewport = SKINOFFSETTOPTR(skin_buffer, viewport->next);
 163             }
 164         }
 165         break;
 166 #ifdef HAVE_LCD_BITMAP
 167         case SKIN_TOKEN_LIST_ITEM_CFG:
 168             skinlist_set_cfg(gwps->display->screen_type,
 169                                 SKINOFFSETTOPTR(skin_buffer, token->value.data));
 170             break;
 171         case SKIN_TOKEN_UIVIEWPORT_ENABLE:
 172             sb_set_info_vp(gwps->display->screen_type, token->value.data);
 173             break;
 174         case SKIN_TOKEN_PEAKMETER:
 175             data->peak_meter_enabled = true;
 176             if (do_refresh)
 177                 draw_peakmeters(gwps, info->line_number, vp);
 178             break;
 179         case SKIN_TOKEN_DRAWRECTANGLE:
 180             if (do_refresh)
 181             {
 182                 struct draw_rectangle *rect =
 183                         SKINOFFSETTOPTR(skin_buffer, token->value.data);
 184 #ifdef HAVE_LCD_COLOR
 185                 if (rect->start_colour != rect->end_colour &&
 186                         gwps->display->screen_type == SCREEN_MAIN)
 187                 {
 188                     gwps->display->gradient_fillrect(rect->x, rect->y, rect->width,
 189                             rect->height, rect->start_colour, rect->end_colour);
 190                 }
 191                 else
 192 #endif
 193                 {
 194 #if LCD_DEPTH > 1
 195                     unsigned backup = vp->fg_pattern;
 196                     vp->fg_pattern = rect->start_colour;
 197 #endif
 198                     gwps->display->fillrect(rect->x, rect->y, rect->width,
 199                             rect->height);
 200 #if LCD_DEPTH > 1
 201                     vp->fg_pattern = backup;
 202 #endif
 203                 }
 204             }
 205             break;
 206         case SKIN_TOKEN_PEAKMETER_LEFTBAR:
 207         case SKIN_TOKEN_PEAKMETER_RIGHTBAR:
 208             data->peak_meter_enabled = true;
 209             /* fall through to the progressbar code */
 210 #endif
 211         case SKIN_TOKEN_VOLUMEBAR:
 212         case SKIN_TOKEN_BATTERY_PERCENTBAR:
 213 #ifdef HAVE_LCD_BITMAP
 214         case SKIN_TOKEN_PROGRESSBAR:
 215         case SKIN_TOKEN_TUNER_RSSI_BAR:
 216         case SKIN_TOKEN_LIST_SCROLLBAR:
 217         {
 218             struct progressbar *bar = (struct progressbar*)SKINOFFSETTOPTR(skin_buffer, token->value.data);
 219             if (do_refresh)
 220                 draw_progressbar(gwps, info->line_number, bar);
 221         }
 222 #endif
 223         break;
 224 #ifdef HAVE_LCD_BITMAP
 225         case SKIN_TOKEN_IMAGE_DISPLAY:
 226         {
 227             struct gui_img *img = SKINOFFSETTOPTR(skin_buffer, token->value.data);
 228             if (img && img->loaded && do_refresh)
 229                 img->display = 0;
 230         }
 231         break;
 232         case SKIN_TOKEN_IMAGE_DISPLAY_LISTICON:
 233         case SKIN_TOKEN_IMAGE_PRELOAD_DISPLAY:
 234         {
 235             struct image_display *id = SKINOFFSETTOPTR(skin_buffer, token->value.data);
 236             const char* label = SKINOFFSETTOPTR(skin_buffer, id->label);
 237             struct gui_img *img = skin_find_item(label,SKIN_FIND_IMAGE, data);
 238             if (img && img->loaded)
 239             {
 240                 if (SKINOFFSETTOPTR(skin_buffer, id->token) == NULL)
 241                 {
 242                     img->display = id->subimage;
 243                 }
 244                 else
 245                 {
 246                     char buf[16];
 247                     const char *out;
 248                     int a = img->num_subimages;
 249                     out = get_token_value(gwps, SKINOFFSETTOPTR(skin_buffer, id->token),
 250                             info->offset, buf, sizeof(buf), &a);
 251
 252                     /* NOTE: get_token_value() returns values starting at 1! */
 253                     if (a == -1)
 254                         a = (out && *out) ? 1 : 2;
 255                     if (token->type == SKIN_TOKEN_IMAGE_DISPLAY_LISTICON)
 256                         a -= 2; /* 2 is added in statusbar-skinned.c! */
 257                     else
 258                         a--;
 259                     a += id->offset;
 260
 261                     /* Clear the image, as in conditionals */
 262                     clear_image_pos(gwps, img);
 263
 264                     /* If the token returned a value which is higher than
 265                      * the amount of subimages, don't draw it. */
 266                     if (a >= 0 && a < img->num_subimages)
 267                     {
 268                         img->display = a;
 269                     }
 270                 }
 271             }
 272             break;
 273         }
 274 #ifdef HAVE_ALBUMART
 275         case SKIN_TOKEN_ALBUMART_DISPLAY:
 276         {
 277             struct skin_albumart *aa = SKINOFFSETTOPTR(skin_buffer, data->albumart);
 278             /* now draw the AA */
 279             if (do_refresh && aa)
 280             {
 281                 int handle = playback_current_aa_hid(data->playback_aa_slot);
 282 #if CONFIG_TUNER
 283                 if (in_radio_screen() || (get_radio_status() != FMRADIO_OFF))
 284                 {
 285                     struct dim dim = {aa->width, aa->height};
 286                     handle = radio_get_art_hid(&dim);
 287                 }
 288 #endif
 289                 aa->draw_handle = handle;
 290             }
 291             break;
 292         }
 293 #endif
 294         case SKIN_TOKEN_DRAW_INBUILTBAR:
 295             gui_statusbar_draw(&(statusbars.statusbars[gwps->display->screen_type]),
 296                                info->refresh_type == SKIN_REFRESH_ALL,
 297                                SKINOFFSETTOPTR(skin_buffer, token->value.data));
 298             break;
 299         case SKIN_TOKEN_VIEWPORT_CUSTOMLIST:
 300             if (do_refresh)
 301                 skin_render_playlistviewer(SKINOFFSETTOPTR(skin_buffer, token->value.data), gwps,
 302                                            info->skin_vp, info->refresh_type);
 303             break;
 304
 305 #endif /* HAVE_LCD_BITMAP */
 306 #ifdef HAVE_SKIN_VARIABLES
 307         case SKIN_TOKEN_VAR_SET:
 308             {
 309                 struct skin_var_changer *data = SKINOFFSETTOPTR(skin_buffer, token->value.data);
 310                 struct skin_var *var = SKINOFFSETTOPTR(skin_buffer, data->var);
 311                 if (data->direct)
 312                     var->value = data->newval;
 313                 else
 314                 {
 315                     var->value += data->newval;
 316                     if (data->max)
 317                     {
 318                         if (var->value > data->max)
 319                             var->value = 1;
 320                         else if (var->value < 1)
 321                             var->value = data->max;
 322                     }
 323                 }
 324                 if (var->value < 1)
 325                     var->value = 1;
 326                 var->last_changed = current_tick;
 327             }
 328             break;
 329 #endif
 330         default:
 331             return false;
 332     }
 333     return true;
 334 }
 335
 336
 337
 338 static void do_tags_in_hidden_conditional(struct skin_element* branch,
 339                                           struct skin_draw_info *info)
 340 {
 341 #ifdef HAVE_LCD_BITMAP
 342     struct gui_wps *gwps = info->gwps;
 343     struct wps_data *data = gwps->data;
 344 #endif
 345     /* Tags here are ones which need to be "turned off" or cleared
 346      * if they are in a conditional branch which isnt being used */
 347     if (branch->type == LINE_ALTERNATOR)
 348     {
 349         int i;
 350         for (i=0; i<branch->children_count; i++)
 351         {
 352             do_tags_in_hidden_conditional(get_child(branch->children, i), info);
 353         }
 354     }
 355     else if (branch->type == LINE && branch->children_count)
 356     {
 357         struct skin_element *child = get_child(branch->children, 0);
 358 #if defined(HAVE_LCD_BITMAP) || defined(HAVE_ALBUMART)
 359         struct wps_token *token;
 360 #endif
 361         while (child)
 362         {
 363             if (child->type == CONDITIONAL)
 364             {
 365                 int i;
 366                 for (i=0; i<child->children_count; i++)
 367                 {
 368                     do_tags_in_hidden_conditional(get_child(child->children, i), info);
 369                 }
 370                 child = SKINOFFSETTOPTR(skin_buffer, child->next);
 371                 continue;
 372             }
 373             else if (child->type != TAG || !SKINOFFSETTOPTR(skin_buffer, child->data))
 374             {
 375                 child = SKINOFFSETTOPTR(skin_buffer, child->next);
 376                 continue;
 377             }
 378 #if defined(HAVE_LCD_BITMAP) || defined(HAVE_ALBUMART)
 379             token = (struct wps_token *)SKINOFFSETTOPTR(skin_buffer, child->data);
 380 #endif
 381 #ifdef HAVE_LCD_BITMAP
 382             /* clear all pictures in the conditional and nested ones */
 383             if (token->type == SKIN_TOKEN_IMAGE_PRELOAD_DISPLAY)
 384             {
 385                 struct image_display *id = SKINOFFSETTOPTR(skin_buffer, token->value.data);
 386                 struct gui_img *img = skin_find_item(SKINOFFSETTOPTR(skin_buffer, id->label),
 387                                                      SKIN_FIND_IMAGE, data);
 388                 clear_image_pos(gwps, img);
 389             }
 390             else if (token->type == SKIN_TOKEN_PEAKMETER)
 391             {
 392                 data->peak_meter_enabled = false;
 393             }
 394             else if (token->type == SKIN_TOKEN_VIEWPORT_ENABLE)
 395             {
 396                 char *label = SKINOFFSETTOPTR(skin_buffer, token->value.data);
 397                 struct skin_element *viewport;
 398                 for (viewport = SKINOFFSETTOPTR(skin_buffer, data->tree);
 399                      viewport;
 400                      viewport = SKINOFFSETTOPTR(skin_buffer, viewport->next))
 401                 {
 402                     struct skin_viewport *skin_viewport = SKINOFFSETTOPTR(skin_buffer, viewport->data);
 403
 404                     char *vplabel = SKINOFFSETTOPTR(skin_buffer, skin_viewport->label);
 405                     if (skin_viewport->label == VP_DEFAULT_LABEL)
 406                         vplabel = VP_DEFAULT_LABEL_STRING;
 407                     if (vplabel && strcmp(vplabel, label))
 408                         continue;
 409                     if (skin_viewport->hidden_flags&VP_NEVER_VISIBLE)
 410                     {
 411                         continue;
 412                     }
 413                     if (skin_viewport->hidden_flags&VP_DRAW_HIDEABLE)
 414                     {
 415                         if (skin_viewport->hidden_flags&VP_DRAW_HIDDEN)
 416                             skin_viewport->hidden_flags |= VP_DRAW_WASHIDDEN;
 417                         else
 418                         {
 419 #if (LCD_DEPTH > 1) || (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1))
 420                             if (skin_viewport->output_to_backdrop_buffer)
 421                             {
 422                                 void *backdrop = skin_backdrop_get_buffer(data->backdrop_id);
 423                                 gwps->display->set_framebuffer(backdrop);
 424                                 skin_backdrop_show(-1);
 425                             }
 426 #endif
 427                             gwps->display->set_viewport(&skin_viewport->vp);
 428                             gwps->display->clear_viewport();
 429                             gwps->display->scroll_stop(&skin_viewport->vp);
 430                             gwps->display->set_viewport(&info->skin_vp->vp);
 431                             skin_viewport->hidden_flags |= VP_DRAW_HIDDEN;
 432
 433 #if (LCD_DEPTH > 1) || (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1))
 434                             if (skin_viewport->output_to_backdrop_buffer)
 435                             {
 436                                 gwps->display->set_framebuffer(NULL);
 437                                 skin_backdrop_show(data->backdrop_id);
 438                             }
 439 #endif
 440                         }
 441                     }
 442                 }
 443             }
 444 #endif
 445 #ifdef HAVE_ALBUMART
 446             else if (data->albumart && token->type == SKIN_TOKEN_ALBUMART_DISPLAY)
 447             {
 448                 draw_album_art(gwps,
 449                         playback_current_aa_hid(data->playback_aa_slot), true);
 450             }
 451 #endif
 452             child = SKINOFFSETTOPTR(skin_buffer, child->next);
 453         }
 454     }
 455 }
 456
 457 static void fix_line_alignment(struct skin_draw_info *info, struct skin_element *element)
 458 {
 459     struct align_pos *align = &info->align;
 460     char *cur_pos = info->cur_align_start + strlen(info->cur_align_start);
 461     switch (element->tag->type)
 462     {
 463         case SKIN_TOKEN_ALIGN_LEFT:
 464             *cur_pos = '\0'; cur_pos++; *cur_pos = '\0';
 465             align->left = cur_pos;
 466             info->cur_align_start = cur_pos;
 467             break;
 468         case SKIN_TOKEN_ALIGN_LEFT_RTL:
 469             *cur_pos = '\0'; cur_pos++; *cur_pos = '\0';
 470             if (lang_is_rtl())
 471                 align->right = cur_pos;
 472             else
 473                 align->left = cur_pos;
 474             info->cur_align_start = cur_pos;
 475             break;
 476         case SKIN_TOKEN_ALIGN_CENTER:
 477             *cur_pos = '\0'; cur_pos++; *cur_pos = '\0';
 478             align->center = cur_pos;
 479             info->cur_align_start = cur_pos;
 480             break;
 481         case SKIN_TOKEN_ALIGN_RIGHT:
 482             *cur_pos = '\0'; cur_pos++; *cur_pos = '\0';
 483             align->right = cur_pos;
 484             info->cur_align_start = cur_pos;
 485             break;
 486         case SKIN_TOKEN_ALIGN_RIGHT_RTL:
 487             *cur_pos = '\0'; cur_pos++; *cur_pos = '\0';
 488             if (lang_is_rtl())
 489                 align->left = cur_pos;
 490             else
 491                 align->right = cur_pos;
 492             info->cur_align_start = cur_pos;
 493             break;
 494         default:
 495             break;
 496     }
 497 }
 498
 499 /* Draw a LINE element onto the display */
 500 static bool skin_render_line(struct skin_element* line, struct skin_draw_info *info)
 501 {
 502     bool needs_update = false;
 503     int last_value, value;
 504
 505     if (line->children_count == 0)
 506         return false; /* empty line, do nothing */
 507
 508     struct skin_element *child = get_child(line->children, 0);
 509     struct conditional *conditional;
 510     skin_render_func func = skin_render_line;
 511     int old_refresh_mode = info->refresh_type;
 512     while (child)
 513     {
 514         switch (child->type)
 515         {
 516             case CONDITIONAL:
 517                 conditional = SKINOFFSETTOPTR(skin_buffer, child->data);
 518                 last_value = conditional->last_value;
 519                 value = evaluate_conditional(info->gwps, info->offset,
 520                                              conditional, child->children_count);
 521                 conditional->last_value = value;
 522                 if (child->children_count == 1)
 523                 {
 524                     /* special handling so
 525                      * %?aa<true> and %?<true|false> need special handlng here */
 526
 527                     if (value == -1) /* tag is false */
 528                     {
 529                         /* we are in a false branch of a %?aa<true> conditional */
 530                         if (last_value == 0)
 531                             do_tags_in_hidden_conditional(get_child(child->children, 0), info);
 532                         break;
 533                     }
 534                 }
 535                 else
 536                 {
 537                     if (last_value >= 0 && value != last_value && last_value < child->children_count)
 538                         do_tags_in_hidden_conditional(get_child(child->children, last_value), info);
 539                 }
 540                 if (get_child(child->children, value)->type == LINE_ALTERNATOR)
 541                 {
 542                     func = skin_render_alternator;
 543                 }
 544                 else if (get_child(child->children, value)->type == LINE)
 545                     func = skin_render_line;
 546
 547                 if (value != last_value)
 548                 {
 549                     info->refresh_type = SKIN_REFRESH_ALL;
 550                     info->force_redraw = true;
 551                 }
 552
 553                 if (func(get_child(child->children, value), info))
 554                     needs_update = true;
 555                 else
 556                     needs_update = needs_update || (last_value != value);
 557
 558                 info->refresh_type = old_refresh_mode;
 559                 break;
 560             case TAG:
 561                 if (child->tag->flags & NOBREAK)
 562                     info->no_line_break = true;
 563                 if (child->tag->type == SKIN_TOKEN_SUBLINE_SCROLL)
 564                     info->line_scrolls = true;
 565
 566                 fix_line_alignment(info, child);
 567
 568                 if (!SKINOFFSETTOPTR(skin_buffer, child->data))
 569                 {
 570                     break;
 571                 }
 572                 if (!do_non_text_tags(info->gwps, info, child, &info->skin_vp->vp))
 573                 {
 574                     static char tempbuf[128];
 575                     const char *valuestr = get_token_value(info->gwps, SKINOFFSETTOPTR(skin_buffer, child->data),
 576                                                         info->offset, tempbuf,
 577                                                         sizeof(tempbuf), NULL);
 578                     if (valuestr)
 579                     {
 580 #if CONFIG_RTC
 581                         if (child->tag->flags&SKIN_RTC_REFRESH)
 582                             needs_update = needs_update || info->refresh_type&SKIN_REFRESH_DYNAMIC;
 583 #endif
 584                         needs_update = needs_update ||
 585                                 ((child->tag->flags&info->refresh_type)!=0);
 586                         strlcat(info->cur_align_start, valuestr,
 587                                 info->buf_size - (info->cur_align_start-info->buf));
 588                     }
 589                 }
 590                 break;
 591             case TEXT:
 592                 strlcat(info->cur_align_start, SKINOFFSETTOPTR(skin_buffer, child->data),
 593                         info->buf_size - (info->cur_align_start-info->buf));
 594                 needs_update = needs_update ||
 595                                 (info->refresh_type&SKIN_REFRESH_STATIC) != 0;
 596                 break;
 597             case COMMENT:
 598             default:
 599                 break;
 600         }
 601
 602         child = SKINOFFSETTOPTR(skin_buffer, child->next);
 603     }
 604     return needs_update;
 605 }
 606
 607 static int get_subline_timeout(struct gui_wps *gwps, struct skin_element* line)
 608 {
 609     struct skin_element *element=line;
 610     struct wps_token *token;
 611     int retval = DEFAULT_SUBLINE_TIME_MULTIPLIER*TIMEOUT_UNIT;
 612     if (element->type == LINE)
 613     {
 614         if (element->children_count == 0)
 615             return retval; /* empty line, so force redraw */
 616         element = get_child(element->children, 0);
 617     }
 618     while (element)
 619     {
 620         if (element->type == TAG &&
 621             element->tag->type == SKIN_TOKEN_SUBLINE_TIMEOUT )
 622         {
 623             token = SKINOFFSETTOPTR(skin_buffer, element->data);
 624             return token->value.i;
 625         }
 626         else if (element->type == CONDITIONAL)
 627         {
 628             struct conditional *conditional = SKINOFFSETTOPTR(skin_buffer, element->data);
 629             int val = evaluate_conditional(gwps, 0, conditional,
 630                                            element->children_count);
 631             if (val >= 0)
 632             {
 633                 retval = get_subline_timeout(gwps, get_child(element->children, val));
 634                 if (retval >= 0)
 635                     return retval;
 636             }
 637         }
 638         element = SKINOFFSETTOPTR(skin_buffer, element->next);
 639     }
 640     return retval;
 641 }
 642
 643 bool skin_render_alternator(struct skin_element* element, struct skin_draw_info *info)
 644 {
 645     bool changed_lines = false;
 646     struct line_alternator *alternator = SKINOFFSETTOPTR(skin_buffer, element->data);
 647     unsigned old_refresh = info->refresh_type;
 648     if (info->refresh_type == SKIN_REFRESH_ALL)
 649     {
 650         alternator->current_line = element->children_count-1;
 651         changed_lines = true;
 652     }
 653     else if (TIME_AFTER(current_tick, alternator->next_change_tick))
 654     {
 655         changed_lines = true;
 656     }
 657
 658     if (changed_lines)
 659     {
 660         struct skin_element *current_line;
 661         int start = alternator->current_line;
 662         int try_line = start;
 663         bool suitable = false;
 664         int rettimeout = DEFAULT_SUBLINE_TIME_MULTIPLIER*TIMEOUT_UNIT;
 665
 666         /* find a subline which has at least one token in it,
 667          * and that line doesnt have a timeout set to 0 through conditionals */
 668         do {
 669             try_line++;
 670             if (try_line >= element->children_count)
 671                 try_line = 0;
 672             if (get_child(element->children, try_line)->children_count != 0)
 673             {
 674                 current_line = get_child(element->children, try_line);
 675                 rettimeout = get_subline_timeout(info->gwps,
 676                                     get_child(current_line->children, 0));
 677                 if (rettimeout > 0)
 678                 {
 679                     suitable = true;
 680                 }
 681             }
 682         }
 683         while (try_line != start && !suitable);
 684
 685         if (suitable)
 686         {
 687             alternator->current_line = try_line;
 688             alternator->next_change_tick = current_tick + rettimeout;
 689         }
 690
 691         info->refresh_type = SKIN_REFRESH_ALL;
 692         info->force_redraw = true;
 693     }
 694     bool ret = skin_render_line(get_child(element->children, alternator->current_line), info);
 695     info->refresh_type = old_refresh;
 696     return changed_lines || ret;
 697 }
 698
 699 void skin_render_viewport(struct skin_element* viewport, struct gui_wps *gwps,
 700                         struct skin_viewport* skin_viewport, unsigned long refresh_type)
 701 {
 702     struct screen *display = gwps->display;
 703     char linebuf[MAX_LINE];
 704     skin_render_func func = skin_render_line;
 705     struct skin_element* line = viewport;
 706     struct skin_draw_info info = {
 707         .gwps = gwps,
 708         .buf = linebuf,
 709         .buf_size = sizeof(linebuf),
 710         .line_number = 0,
 711         .no_line_break = false,
 712         .line_scrolls = false,
 713         .refresh_type = refresh_type,
 714         .skin_vp = skin_viewport,
 715         .offset = 0,
 716         .text_style = STYLE_DEFAULT
 717     };
 718
 719     struct align_pos * align = &info.align;
 720     bool needs_update;
 721     skin_buffer = get_skin_buffer(gwps->data);
 722     skinparser_set_buffer(skin_buffer);
 723 #ifdef HAVE_LCD_BITMAP
 724     /* Set images to not to be displayed */
 725     struct skin_token_list *imglist = SKINOFFSETTOPTR(skin_buffer, gwps->data->images);
 726     while (imglist)
 727     {
 728         struct wps_token *token = SKINOFFSETTOPTR(skin_buffer, imglist->token);
 729         struct gui_img *img = (struct gui_img *)SKINOFFSETTOPTR(skin_buffer, token->value.data);
 730         img->display = -1;
 731         imglist = SKINOFFSETTOPTR(skin_buffer, imglist->next);
 732     }
 733
 734     /* fix font ID's */
 735     if (skin_viewport->parsed_fontid == 1)
 736         skin_viewport->vp.font = display->getuifont();
 737 #endif
 738
 739     while (line)
 740     {
 741         linebuf[0] = '\0';
 742         info.no_line_break = false;
 743         info.line_scrolls = false;
 744         info.force_redraw = false;
 745 #ifdef HAVE_LCD_COLOR
 746         if (info.text_style&STYLE_GRADIENT)
 747         {
 748             int cur = CURLN_UNPACK(info.text_style);
 749             int num = NUMLN_UNPACK(info.text_style);
 750             if (cur+1 == num)
 751                 info.text_style = STYLE_DEFAULT;
 752             else
 753                 info.text_style = STYLE_GRADIENT|CURLN_PACK(cur+1)|NUMLN_PACK(num);
 754         }
 755 #endif
 756         info.cur_align_start = info.buf;
 757         align->left = info.buf;
 758         align->center = NULL;
 759         align->right = NULL;
 760
 761
 762         if (line->type == LINE_ALTERNATOR)
 763             func = skin_render_alternator;
 764         else if (line->type == LINE)
 765             func = skin_render_line;
 766
 767         needs_update = func(line, &info);
 768 #if (LCD_DEPTH > 1) || (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1))
 769         if (skin_viewport->vp.fg_pattern != skin_viewport->start_fgcolour ||
 770             skin_viewport->vp.bg_pattern != skin_viewport->start_bgcolour)
 771         {
 772             /* 2bit lcd drivers need lcd_set_viewport() to be called to change
 773              * the colour, 16bit doesnt. But doing this makes static text
 774              * get the new colour also */
 775             needs_update = true;
 776             display->set_viewport(&skin_viewport->vp);
 777         }
 778 #endif
 779         /* only update if the line needs to be, and there is something to write */
 780         if (refresh_type && needs_update)
 781         {
 782             if (!info.force_redraw)
 783                 display->scroll_stop_line(&skin_viewport->vp, info.line_number);
 784             write_line(display, align, info.line_number,
 785                     info.line_scrolls, info.text_style);
 786         }
 787         if (!info.no_line_break)
 788             info.line_number++;
 789         line = SKINOFFSETTOPTR(skin_buffer, line->next);
 790     }
 791 #ifdef HAVE_LCD_BITMAP
 792     wps_display_images(gwps, &skin_viewport->vp);
 793 #endif
 794 }
 795
 796 void skin_render(struct gui_wps *gwps, unsigned refresh_mode)
 797 {
 798     struct wps_data *data = gwps->data;
 799     struct screen *display = gwps->display;
 800
 801     struct skin_element* viewport;
 802     struct skin_viewport* skin_viewport;
 803     char *label;
 804
 805     int old_refresh_mode = refresh_mode;
 806     skin_buffer = get_skin_buffer(gwps->data);
 807     skinparser_set_buffer(skin_buffer);
 808
 809 #ifdef HAVE_LCD_CHARCELLS
 810     int i;
 811     for (i = 0; i < 8; i++)
 812     {
 813         if (data->wps_progress_pat[i] == 0)
 814             data->wps_progress_pat[i] = display->get_locked_pattern();
 815     }
 816 #endif
 817
 818     viewport = SKINOFFSETTOPTR(skin_buffer, data->tree);
 819     skin_viewport = SKINOFFSETTOPTR(skin_buffer, viewport->data);
 820     label = SKINOFFSETTOPTR(skin_buffer, skin_viewport->label);
 821     if (skin_viewport->label == VP_DEFAULT_LABEL)
 822         label = VP_DEFAULT_LABEL_STRING;
 823     if (label && SKINOFFSETTOPTR(skin_buffer, viewport->next) &&
 824         !strcmp(label,VP_DEFAULT_LABEL_STRING))
 825         refresh_mode = 0;
 826
 827     for (viewport = SKINOFFSETTOPTR(skin_buffer, data->tree);
 828          viewport;
 829          viewport = SKINOFFSETTOPTR(skin_buffer, viewport->next))
 830     {
 831         /* SETUP */
 832         skin_viewport = SKINOFFSETTOPTR(skin_buffer, viewport->data);
 833         unsigned vp_refresh_mode = refresh_mode;
 834 #if (LCD_DEPTH > 1) || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)
 835         skin_viewport->vp.fg_pattern = skin_viewport->start_fgcolour;
 836         skin_viewport->vp.bg_pattern = skin_viewport->start_bgcolour;
 837         if (skin_viewport->output_to_backdrop_buffer)
 838         {
 839             display->set_framebuffer(skin_backdrop_get_buffer(data->backdrop_id));
 840             skin_backdrop_show(-1);
 841         }
 842         else
 843         {
 844             display->set_framebuffer(NULL);
 845             skin_backdrop_show(data->backdrop_id);
 846         }
 847 #endif
 848 #ifdef HAVE_LCD_COLOR
 849         skin_viewport->vp.lss_pattern = skin_viewport->start_gradient.start;
 850         skin_viewport->vp.lse_pattern = skin_viewport->start_gradient.end;
 851         skin_viewport->vp.lst_pattern = skin_viewport->start_gradient.text;
 852 #endif
 853
 854         /* dont redraw the viewport if its disabled */
 855         if (skin_viewport->hidden_flags&VP_NEVER_VISIBLE)
 856         {   /* don't draw anything into this one */
 857             vp_refresh_mode = 0;
 858         }
 859         else if ((skin_viewport->hidden_flags&VP_DRAW_HIDDEN))
 860         {
 861             skin_viewport->hidden_flags |= VP_DRAW_WASHIDDEN;
 862             continue;
 863         }
 864         else if (((skin_viewport->hidden_flags&
 865                    (VP_DRAW_WASHIDDEN|VP_DRAW_HIDEABLE))
 866                     == (VP_DRAW_WASHIDDEN|VP_DRAW_HIDEABLE)))
 867         {
 868             vp_refresh_mode = SKIN_REFRESH_ALL;
 869             skin_viewport->hidden_flags = VP_DRAW_HIDEABLE;
 870         }
 871
 872         display->set_viewport(&skin_viewport->vp);
 873         if ((vp_refresh_mode&SKIN_REFRESH_ALL) == SKIN_REFRESH_ALL)
 874         {
 875             display->clear_viewport();
 876         }
 877         /* render */
 878         if (viewport->children_count)
 879             skin_render_viewport(get_child(viewport->children, 0), gwps,
 880                                  skin_viewport, vp_refresh_mode);
 881         refresh_mode = old_refresh_mode;
 882     }
 883 #if (LCD_DEPTH > 1) || (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1))
 884     display->set_framebuffer(NULL);
 885     skin_backdrop_show(data->backdrop_id);
 886 #endif
 887     /* Restore the default viewport */
 888     display->set_viewport(NULL);
 889     display->update();
 890 }
 891
 892 #ifdef HAVE_LCD_BITMAP
 893 static __attribute__((noinline))
 894 void skin_render_playlistviewer(struct playlistviewer* viewer,
 895                                 struct gui_wps *gwps,
 896                                 struct skin_viewport* skin_viewport,
 897                                 unsigned long refresh_type)
 898 {
 899     struct screen *display = gwps->display;
 900     char linebuf[MAX_LINE];
 901     skin_render_func func = skin_render_line;
 902     struct skin_element* line;
 903     struct skin_draw_info info = {
 904         .gwps = gwps,
 905         .buf = linebuf,
 906         .buf_size = sizeof(linebuf),
 907         .line_number = 0,
 908         .no_line_break = false,
 909         .line_scrolls = false,
 910         .refresh_type = refresh_type,
 911         .skin_vp = skin_viewport,
 912         .offset = viewer->start_offset,
 913         .text_style = STYLE_DEFAULT
 914     };
 915
 916     struct align_pos * align = &info.align;
 917     bool needs_update;
 918     int cur_pos, start_item, max;
 919     int nb_lines = viewport_get_nb_lines(SKINOFFSETTOPTR(skin_buffer, viewer->vp));
 920 #if CONFIG_TUNER
 921     if (get_current_activity() == ACTIVITY_FM)
 922     {
 923         cur_pos = radio_current_preset();
 924         start_item = cur_pos + viewer->start_offset;
 925         max = start_item+radio_preset_count();
 926     }
 927     else
 928 #endif
 929     {
 930         struct cuesheet *cue = skin_get_global_state()->id3 ?
 931                                skin_get_global_state()->id3->cuesheet : NULL;
 932         cur_pos = playlist_get_display_index();
 933         max = playlist_amount()+1;
 934         if (cue)
 935             max += cue->track_count;
 936         start_item = MAX(0, cur_pos + viewer->start_offset);
 937     }
 938     if (max-start_item > nb_lines)
 939         max = start_item + nb_lines;
 940
 941     line = SKINOFFSETTOPTR(skin_buffer, viewer->line);
 942     while (start_item < max)
 943     {
 944         linebuf[0] = '\0';
 945         info.no_line_break = false;
 946         info.line_scrolls = false;
 947         info.force_redraw = false;
 948
 949         info.cur_align_start = info.buf;
 950         align->left = info.buf;
 951         align->center = NULL;
 952         align->right = NULL;
 953
 954
 955         if (line->type == LINE_ALTERNATOR)
 956             func = skin_render_alternator;
 957         else if (line->type == LINE)
 958             func = skin_render_line;
 959
 960         needs_update = func(line, &info);
 961
 962         /* only update if the line needs to be, and there is something to write */
 963         if (refresh_type && needs_update)
 964         {
 965             if (!info.force_redraw)
 966                 display->scroll_stop_line(&skin_viewport->vp, info.line_number);
 967             write_line(display, align, info.line_number,
 968                     info.line_scrolls, info.text_style);
 969         }
 970         info.line_number++;
 971         info.offset++;
 972         start_item++;
 973     }
 974 }
 975 #endif