apps/gui/statusbar-skinned.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2009 Thomas Martitz
  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 "config.h"
  23
  24 #include "action.h"
  25 #include "system.h"
  26 #include "settings.h"
  27 #include "appevents.h"
  28 #include "screens.h"
  29 #include "screen_access.h"
  30 #include "strlcpy.h"
  31 #include "skin_parser.h"
  32 #include "skin_buffer.h"
  33 #include "skin_engine/skin_engine.h"
  34 #include "skin_engine/wps_internals.h"
  35 #include "viewport.h"
  36 #include "statusbar.h"
  37 #include "statusbar-skinned.h"
  38 #include "debug.h"
  39 #include "font.h"
  40 #include "icon.h"
  41 #include "option_select.h"
  42 #ifdef HAVE_TOUCHSCREEN
  43 #include "sound.h"
  44 #include "misc.h"
  45 #endif
  46
  47 /* initial setup of wps_data  */
  48 static int update_delay = DEFAULT_UPDATE_DELAY;
  49
  50 static bool sbs_has_title[NB_SCREENS];
  51 static char* sbs_title[NB_SCREENS];
  52 static enum themable_icons sbs_icon[NB_SCREENS];
  53
  54 bool sb_set_title_text(char* title, enum themable_icons icon, enum screen_type screen)
  55 {
  56     sbs_title[screen] = title;
  57     /* Icon_NOICON == -1 which the skin engine wants at position 1, so + 2 */
  58     sbs_icon[screen] = icon + 2;
  59     return sbs_has_title[screen];
  60 }
  61
  62 void sb_skin_has_title(enum screen_type screen)
  63 {
  64     sbs_has_title[screen] = true;
  65 }
  66
  67 const char* sb_get_title(enum screen_type screen)
  68 {
  69     return sbs_has_title[screen] ? sbs_title[screen] : NULL;
  70 }
  71 enum themable_icons sb_get_icon(enum screen_type screen)
  72 {
  73     return sbs_has_title[screen] ? sbs_icon[screen] : Icon_NOICON + 2;
  74 }
  75
  76 int sb_preproccess(enum screen_type screen, struct wps_data *data)
  77 {
  78     (void)data;
  79     sbs_has_title[screen] = false;
  80     viewportmanager_theme_enable(screen, false, NULL);
  81     return 1;
  82 }
  83 int sb_postproccess(enum screen_type screen, struct wps_data *data)
  84 {
  85     if (data->wps_loaded)
  86     {
  87         /* hide the sb's default viewport because it has nasty effect with stuff
  88         * not part of the statusbar,
  89         * hence .sbs's without any other vps are unsupported*/
  90         struct skin_viewport *vp = skin_find_item(VP_DEFAULT_LABEL, SKIN_FIND_VP, data);
  91         struct skin_element *next_vp = data->tree->next;
  92
  93         if (vp)
  94         {
  95             if (!next_vp)
  96             {    /* no second viewport, let parsing fail */
  97                 return 0;
  98             }
  99             /* hide this viewport, forever */
 100             vp->hidden_flags = VP_NEVER_VISIBLE;
 101         }
 102         sb_set_info_vp(screen, VP_DEFAULT_LABEL);
 103     }
 104     viewportmanager_theme_undo(screen, false);
 105     return 1;
 106 }
 107
 108 static char *infovp_label[NB_SCREENS];
 109 static char *oldinfovp_label[NB_SCREENS];
 110 void sb_set_info_vp(enum screen_type screen, char *label)
 111 {
 112     infovp_label[screen] = label;
 113 }
 114
 115 struct viewport *sb_skin_get_info_vp(enum screen_type screen)
 116 {
 117     struct wps_data *data = skin_get_gwps(CUSTOM_STATUSBAR, screen)->data;
 118     struct skin_viewport *vp = NULL;
 119     if (oldinfovp_label[screen] &&
 120         strcmp(oldinfovp_label[screen], infovp_label[screen]))
 121     {
 122         /* UI viewport changed, so force a redraw */
 123         oldinfovp_label[screen] = infovp_label[screen];
 124         viewportmanager_theme_enable(screen, false, NULL);
 125         viewportmanager_theme_undo(screen, true);
 126     }
 127     vp = skin_find_item(infovp_label[screen], SKIN_FIND_UIVP, data);
 128     return &vp->vp;
 129 }
 130
 131 #if (LCD_DEPTH > 1) || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)
 132 int sb_get_backdrop(enum screen_type screen)
 133 {
 134     struct wps_data *data = skin_get_gwps(CUSTOM_STATUSBAR, screen)->data;
 135     if (data->wps_loaded)
 136         return data->backdrop_id;
 137     else
 138         return -1;
 139 }
 140
 141 #endif
 142 void sb_skin_update(enum screen_type screen, bool force)
 143 {
 144     struct wps_data *data = skin_get_gwps(CUSTOM_STATUSBAR, screen)->data;
 145     static long next_update[NB_SCREENS] = {0};
 146     int i = screen;
 147     if (!data->wps_loaded)
 148         return;
 149     if (TIME_AFTER(current_tick, next_update[i]) || force)
 150     {
 151 #if defined(HAVE_LCD_ENABLE) || defined(HAVE_LCD_SLEEP)
 152         /* currently, all remotes are readable without backlight
 153          * so still update those */
 154         if (lcd_active() || (i != SCREEN_MAIN))
 155 #endif
 156         {
 157             bool full_update = skin_do_full_update(CUSTOM_STATUSBAR, screen);
 158             skin_update(CUSTOM_STATUSBAR, screen, force ||
 159                         full_update ? SKIN_REFRESH_ALL : SKIN_REFRESH_NON_STATIC);
 160         }
 161         next_update[i] = current_tick + update_delay; /* don't update too often */
 162     }
 163 }
 164
 165 void do_sbs_update_callback(void *param)
 166 {
 167     (void)param;
 168     /* the WPS handles changing the actual id3 data in the id3 pointers
 169      * we imported, we just want a full update */
 170     skin_request_full_update(CUSTOM_STATUSBAR);
 171     /* force timeout in wps main loop, so that the update is instantly */
 172     queue_post(&button_queue, BUTTON_NONE, 0);
 173 }
 174
 175 void sb_skin_set_update_delay(int delay)
 176 {
 177     update_delay = delay;
 178 }
 179
 180 /* This creates and loads a ".sbs" based on the user settings for:
 181  *  - regular statusbar
 182  *  - colours
 183  *  - ui viewport
 184  *  - backdrop
 185  */
 186 char* sb_create_from_settings(enum screen_type screen)
 187 {
 188     static char buf[128];
 189     char *ptr, *ptr2;
 190     int len, remaining = sizeof(buf);
 191     int bar_position = statusbar_position(screen);
 192     ptr = buf;
 193     ptr[0] = '\0';
 194
 195     /* setup the inbuilt statusbar */
 196     if (bar_position != STATUSBAR_OFF)
 197     {
 198         int y = 0, height = STATUSBAR_HEIGHT;
 199         if (bar_position == STATUSBAR_BOTTOM)
 200         {
 201             y = screens[screen].lcdheight - STATUSBAR_HEIGHT;
 202         }
 203         len = snprintf(ptr, remaining, "%%V(0,%d,-,%d,0)\n%%wi\n",
 204                        y, height);
 205         remaining -= len;
 206         ptr += len;
 207     }
 208     /* %Vi viewport, colours handled by the parser */
 209 #if NB_SCREENS > 1
 210     if (screen == SCREEN_REMOTE)
 211         ptr2 = global_settings.remote_ui_vp_config;
 212     else
 213 #endif
 214         ptr2 = global_settings.ui_vp_config;
 215
 216     if (ptr2[0] && ptr2[0] != '-') /* from ui viewport setting */
 217     {
 218         char *comma = ptr;
 219         int param_count = 0;
 220         len = snprintf(ptr, remaining, "%%ax%%Vi(-,%s)\n", ptr2);
 221         /* The config put the colours at the end of the viewport,
 222          * they need to be stripped for the skin code though */
 223         do {
 224             param_count++;
 225             comma = strchr(comma+1, ',');
 226
 227         } while (comma && param_count < 6);
 228         if (comma)
 229         {
 230             char *end = comma;
 231             char fg[8], bg[8];
 232             int i = 0;
 233             comma++;
 234             while (*comma != ',')
 235                 fg[i++] = *comma++;
 236             fg[i] = '\0'; comma++; i=0;
 237             while (*comma != ')')
 238                 bg[i++] = *comma++;
 239             bg[i] = '\0';
 240             len += snprintf(end, remaining-len, ") %%Vf(%s) %%Vb(%s)\n", fg, bg);
 241         }
 242     }
 243     else
 244     {
 245         int y = 0, height;
 246         switch (bar_position)
 247         {
 248             case STATUSBAR_TOP:
 249                 y = STATUSBAR_HEIGHT;
 250             case STATUSBAR_BOTTOM:
 251                 height = screens[screen].lcdheight - STATUSBAR_HEIGHT;
 252                 break;
 253             default:
 254                 height = screens[screen].lcdheight;
 255         }
 256         len = snprintf(ptr, remaining, "%%ax%%Vi(-,0,%d,-,%d,1)\n",
 257                        y, height);
 258     }
 259     return buf;
 260 }
 261
 262 void sb_skin_init(void)
 263 {
 264     int i;
 265     FOR_NB_SCREENS(i)
 266     {
 267         oldinfovp_label[i] = NULL;
 268     }
 269 }
 270
 271 #ifdef HAVE_TOUCHSCREEN
 272 static bool bypass_sb_touchregions = true;
 273 void sb_bypass_touchregions(bool enable)
 274 {
 275     bypass_sb_touchregions = enable;
 276 }
 277
 278 int sb_touch_to_button(int context)
 279 {
 280     struct touchregion *region;
 281     static int last_context = -1;
 282     int button, offset;
 283     if (bypass_sb_touchregions)
 284         return ACTION_TOUCHSCREEN;
 285
 286     if (last_context != context)
 287         skin_disarm_touchregions(skin_get_gwps(CUSTOM_STATUSBAR, SCREEN_MAIN)->data);
 288     last_context = context;
 289     button = skin_get_touchaction(skin_get_gwps(CUSTOM_STATUSBAR, SCREEN_MAIN)->data,
 290                                   &offset, &region);
 291
 292     switch (button)
 293     {
 294 #ifdef HAVE_VOLUME_IN_LIST
 295         case ACTION_WPS_VOLUP:
 296             return ACTION_LIST_VOLUP;
 297         case ACTION_WPS_VOLDOWN:
 298             return ACTION_LIST_VOLDOWN;
 299 #endif
 300         /* TODO */
 301     }
 302     return button;
 303 }
 304 #endif