apps/gui/viewport.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2008 by 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 "config.h"
  24 #include "lcd.h"
  25 #ifdef HAVE_REMOTE_LCD
  26 #include "lcd-remote.h"
  27 #endif
  28 #include "font.h"
  29 #include "viewport.h"
  30 #include "screen_access.h"
  31 #include "settings.h"
  32 #include "misc.h"
  33 #include "list.h"
  34 /*some short cuts for fg/bg/line selector handling */
  35 #ifdef HAVE_LCD_COLOR
  36 #define FG_FALLBACK global_settings.fg_color
  37 #define BG_FALLBACK global_settings.bg_color
  38 #else
  39 #define FG_FALLBACK LCD_DEFAULT_FG
  40 #define BG_FALLBACK LCD_DEFAULT_BG
  41 #endif
  42 #ifdef HAVE_REMOTE_LCD
  43 #define REMOTE_FG_FALLBACK LCD_REMOTE_DEFAULT_FG
  44 #define REMOTE_BG_FALLBACK LCD_REMOTE_DEFAULT_BG
  45 #endif
  46
  47
  48 /* all below isn't needed for pc tools (i.e. checkwps/wps editor)
  49  * only viewport_parse_viewport() is */
  50 #ifndef __PCTOOL__
  51 #include "string.h"
  52 #include "kernel.h"
  53 #include "system.h"
  54 #include "statusbar.h"
  55 #include "appevents.h"
  56 #include "panic.h"
  57 #ifdef HAVE_LCD_BITMAP
  58 #include "language.h"
  59 #endif
  60 #include "statusbar-skinned.h"
  61 #include "skin_engine/skin_engine.h"
  62 #include "debug.h"
  63
  64 #define VPSTACK_DEPTH 16
  65 struct viewport_stack_item
  66 {
  67     struct  viewport* vp;
  68     bool   enabled;
  69 };
  70
  71 #ifdef HAVE_LCD_BITMAP
  72 static void viewportmanager_redraw(void* data);
  73
  74 static int theme_stack_top[NB_SCREENS]; /* the last item added */
  75 static struct viewport_stack_item theme_stack[NB_SCREENS][VPSTACK_DEPTH];
  76 static bool is_theme_enabled(enum screen_type screen);
  77
  78
  79 static void toggle_events(bool enable)
  80 {
  81     if (enable)
  82     {
  83         add_event(GUI_EVENT_ACTIONUPDATE, false, viewportmanager_redraw);
  84 #if defined(HAVE_LCD_ENABLE) || defined(HAVE_LCD_SLEEP)
  85         add_event(LCD_EVENT_ACTIVATION, false, do_sbs_update_callback);
  86 #endif
  87         add_event(PLAYBACK_EVENT_TRACK_CHANGE, false,
  88                                                 do_sbs_update_callback);
  89         add_event(PLAYBACK_EVENT_NEXTTRACKID3_AVAILABLE, false,
  90                                                 do_sbs_update_callback);
  91     }
  92     else
  93     {
  94 #if defined(HAVE_LCD_ENABLE) || defined(HAVE_LCD_SLEEP)
  95         remove_event(LCD_EVENT_ACTIVATION, do_sbs_update_callback);
  96 #endif
  97         remove_event(PLAYBACK_EVENT_TRACK_CHANGE, do_sbs_update_callback);
  98         remove_event(PLAYBACK_EVENT_NEXTTRACKID3_AVAILABLE, do_sbs_update_callback);
  99         remove_event(GUI_EVENT_ACTIONUPDATE, viewportmanager_redraw);
 100     }
 101 }
 102
 103
 104 static void toggle_theme(enum screen_type screen, bool force)
 105 {
 106     bool enable_event = false;
 107     static bool was_enabled[NB_SCREENS] = {false};
 108     static bool after_boot[NB_SCREENS] = {false};
 109
 110     FOR_NB_SCREENS(i)
 111     {
 112         enable_event = enable_event || is_theme_enabled(i);
 113         sb_set_title_text(NULL, Icon_NOICON, i);
 114     }
 115     toggle_events(enable_event);
 116
 117     if (is_theme_enabled(screen))
 118     {
 119         bool first_boot = theme_stack_top[screen] == 0;
 120         /* remove the left overs from the previous screen.
 121          * could cause a tiny flicker. Redo your screen code if that happens */
 122 #ifdef HAVE_BACKDROP_IMAGE
 123         skin_backdrop_show(sb_get_backdrop(screen));
 124 #endif
 125         if (LIKELY(after_boot[screen]) && (!was_enabled[screen] || force))
 126         {
 127             struct viewport deadspace, user;
 128             viewport_set_defaults(&user, screen);
 129             deadspace = user; /* get colours and everything */
 130             /* above */
 131             deadspace.x = 0;
 132             deadspace.y = 0;
 133             deadspace.width = screens[screen].lcdwidth;
 134             deadspace.height = user.y;
 135             if (deadspace.width && deadspace.height)
 136             {
 137                 screens[screen].set_viewport(&deadspace);
 138                 screens[screen].clear_viewport();
 139                 screens[screen].update_viewport();
 140             }
 141             /* below */
 142             deadspace.y = user.y + user.height;
 143             deadspace.height = screens[screen].lcdheight - deadspace.y;
 144             if (deadspace.width && deadspace.height)
 145             {
 146                 screens[screen].set_viewport(&deadspace);
 147                 screens[screen].clear_viewport();
 148                 screens[screen].update_viewport();
 149             }
 150             /* left */
 151             deadspace.x = 0;
 152             deadspace.y = 0;
 153             deadspace.width = user.x;
 154             deadspace.height = screens[screen].lcdheight;
 155             if (deadspace.width && deadspace.height)
 156             {
 157                 screens[screen].set_viewport(&deadspace);
 158                 screens[screen].clear_viewport();
 159                 screens[screen].update_viewport();
 160             }
 161             /* below */
 162             deadspace.x = user.x + user.width;
 163             deadspace.width = screens[screen].lcdwidth - deadspace.x;
 164             if (deadspace.width && deadspace.height)
 165             {
 166                 screens[screen].set_viewport(&deadspace);
 167                 screens[screen].clear_viewport();
 168                 screens[screen].update_viewport();
 169             }
 170             screens[screen].set_viewport(NULL);
 171         }
 172         intptr_t force = first_boot?0:1;
 173
 174         send_event(GUI_EVENT_ACTIONUPDATE, (void*)force);
 175     }
 176     else
 177     {
 178 #if LCD_DEPTH > 1 || (defined(LCD_REMOTE_DEPTH) && LCD_REMOTE_DEPTH > 1)
 179         screens[screen].backdrop_show(NULL);
 180 #endif
 181         screens[screen].stop_scroll();
 182         skinlist_set_cfg(screen, NULL);
 183     }
 184     /* let list initialize viewport in case viewport dimensions is changed. */
 185     send_event(GUI_EVENT_THEME_CHANGED, NULL);
 186     FOR_NB_SCREENS(i)
 187         was_enabled[i] = is_theme_enabled(i);
 188 #ifdef HAVE_TOUCHSCREEN
 189     sb_bypass_touchregions(!is_theme_enabled(SCREEN_MAIN));
 190 #endif
 191     after_boot[screen] = true;
 192 }
 193
 194 void viewportmanager_theme_enable(enum screen_type screen, bool enable,
 195                                  struct viewport *viewport)
 196 {
 197     int top = ++theme_stack_top[screen];
 198     if (top >= VPSTACK_DEPTH-1)
 199         panicf("Stack overflow... viewportmanager");
 200     theme_stack[screen][top].enabled = enable;
 201     theme_stack[screen][top].vp = viewport;
 202     toggle_theme(screen, false);
 203     /* then be nice and set the viewport up */
 204     if (viewport)
 205         viewport_set_defaults(viewport, screen);
 206 }
 207
 208 void viewportmanager_theme_undo(enum screen_type screen, bool force_redraw)
 209 {
 210     int top = --theme_stack_top[screen];
 211     if (top < 0)
 212         panicf("Stack underflow... viewportmanager");
 213
 214     toggle_theme(screen, force_redraw);
 215 }
 216
 217
 218 static bool is_theme_enabled(enum screen_type screen)
 219 {
 220     int top = theme_stack_top[screen];
 221     return theme_stack[screen][top].enabled;
 222 }
 223 #endif /* HAVE_LCD_BITMAP */
 224
 225 int viewport_get_nb_lines(const struct viewport *vp)
 226 {
 227 #ifdef HAVE_LCD_BITMAP
 228     if (!vp->line_height)
 229         return vp->height/font_get(vp->font)->height;
 230     return vp->height/vp->line_height;
 231 #else
 232     (void)vp;
 233     return 2;
 234 #endif
 235 }
 236
 237 static void viewportmanager_redraw(void* data)
 238 {
 239     FOR_NB_SCREENS(i)
 240     {
 241 #ifdef HAVE_LCD_BITMAP
 242         if (is_theme_enabled(i))
 243             sb_skin_update(i, NULL != data);
 244 #else
 245         (void)data;
 246         gui_statusbar_draw(&statusbars.statusbars[i], NULL, NULL);
 247 #endif
 248     }
 249 }
 250
 251 void viewportmanager_init()
 252 {
 253 #ifdef HAVE_LCD_BITMAP
 254     FOR_NB_SCREENS(i)
 255     {
 256         theme_stack_top[i] = -1; /* the next call fixes this to 0 */
 257         /* We always want the theme enabled by default... */
 258         viewportmanager_theme_enable(i, true, NULL);
 259     }
 260 #else
 261     add_event(GUI_EVENT_ACTIONUPDATE, false, viewportmanager_redraw);
 262 #endif
 263 }
 264
 265 #ifdef HAVE_LCD_BITMAP
 266 void viewportmanager_theme_changed(const int which)
 267 {
 268 #ifdef HAVE_BUTTONBAR
 269     if (which & THEME_BUTTONBAR)
 270     {   /* don't handle further, the custom ui viewport ignores the buttonbar,
 271          * as does viewport_set_defaults(), since only lists use it*/
 272         screens[SCREEN_MAIN].has_buttonbar = global_settings.buttonbar;
 273     }
 274 #endif
 275     if (which & THEME_LANGUAGE)
 276     {
 277     }
 278     if (which & (THEME_STATUSBAR|THEME_UI_VIEWPORT))
 279     {
 280         FOR_NB_SCREENS(i)
 281         {
 282             /* This can probably be done better...
 283              * disable the theme so it's forced to do a full redraw  */
 284             viewportmanager_theme_enable(i, false, NULL);
 285             viewportmanager_theme_undo(i, true);
 286         }
 287     }
 288     send_event(GUI_EVENT_THEME_CHANGED, NULL);
 289 }
 290
 291 #ifdef HAVE_TOUCHSCREEN
 292 /* check if a point (x and y coordinates) are within a viewport */
 293 bool viewport_point_within_vp(const struct viewport *vp,
 294                                const int x, const int y)
 295 {
 296     bool is_x = (x >= vp->x && x < (vp->x + vp->width));
 297     bool is_y = (y >= vp->y && y < (vp->y + vp->height));
 298     return (is_x && is_y);
 299 }
 300 #endif /* HAVE_TOUCHSCREEN */
 301
 302 static void set_default_align_flags(struct viewport *vp)
 303 {
 304     vp->flags &= ~VP_FLAG_ALIGNMENT_MASK;
 305     if (UNLIKELY(lang_is_rtl()))
 306         vp->flags |= VP_FLAG_ALIGN_RIGHT;
 307 }
 308
 309 #endif /* HAVE_LCD_BITMAP */
 310 #endif /* __PCTOOL__ */
 311
 312 void viewport_set_fullscreen(struct viewport *vp,
 313                               const enum screen_type screen)
 314 {
 315     vp->x = 0;
 316     vp->y = 0;
 317     vp->width = screens[screen].lcdwidth;
 318     vp->height = screens[screen].lcdheight;
 319
 320 #ifdef HAVE_LCD_BITMAP
 321 #ifndef __PCTOOL__
 322     set_default_align_flags(vp);
 323 #endif
 324     vp->font = screens[screen].getuifont();
 325     vp->line_height = 0; /* calculate from font height */
 326     vp->drawmode = DRMODE_SOLID;
 327 #if LCD_DEPTH > 1
 328 #ifdef HAVE_REMOTE_LCD
 329     /* We only need this test if there is a remote LCD */
 330     if (screen == SCREEN_MAIN)
 331 #endif
 332     {
 333         vp->fg_pattern = FG_FALLBACK;
 334         vp->bg_pattern = BG_FALLBACK;
 335 #ifdef HAVE_LCD_COLOR
 336         vp->lss_pattern = global_settings.lss_color;
 337         vp->lse_pattern = global_settings.lse_color;
 338         vp->lst_pattern = global_settings.lst_color;
 339 #endif
 340     }
 341 #endif
 342
 343 #if defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1
 344     if (screen == SCREEN_REMOTE)
 345     {
 346         vp->fg_pattern = LCD_REMOTE_DEFAULT_FG;
 347         vp->bg_pattern = LCD_REMOTE_DEFAULT_BG;
 348     }
 349 #endif
 350 #endif
 351 }
 352
 353 void viewport_set_defaults(struct viewport *vp,
 354                             const enum screen_type screen)
 355 {
 356 #if defined(HAVE_LCD_BITMAP) && !defined(__PCTOOL__)
 357     struct viewport *sbs_area = NULL;
 358     if (!is_theme_enabled(screen))
 359     {
 360         viewport_set_fullscreen(vp, screen);
 361         return;
 362     }
 363     sbs_area = sb_skin_get_info_vp(screen);
 364
 365     if (sbs_area)
 366         *vp = *sbs_area;
 367     else
 368 #endif /* HAVE_LCD_BITMAP */
 369         viewport_set_fullscreen(vp, screen);
 370 }
 371
 372
 373 #ifdef HAVE_LCD_BITMAP
 374
 375 int get_viewport_default_colour(enum screen_type screen, bool fgcolour)
 376 {
 377     (void)screen; (void)fgcolour;
 378 #if (LCD_DEPTH > 1) || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)
 379     int colour;
 380     if (fgcolour)
 381     {
 382 #if (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)
 383         if (screen == SCREEN_REMOTE)
 384             colour = REMOTE_FG_FALLBACK;
 385         else
 386 #endif
 387 #if defined(HAVE_LCD_COLOR)
 388             colour = global_settings.fg_color;
 389 #else
 390             colour = FG_FALLBACK;
 391 #endif
 392     }
 393     else
 394     {
 395 #if (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)
 396         if (screen == SCREEN_REMOTE)
 397             colour = REMOTE_BG_FALLBACK;
 398         else
 399 #endif
 400 #if defined(HAVE_LCD_COLOR)
 401             colour = global_settings.bg_color;
 402 #else
 403             colour = BG_FALLBACK;
 404 #endif
 405     }
 406     return colour;
 407 #else
 408     return 0;
 409 #endif /* LCD_DEPTH > 1 || LCD_REMOTE_DEPTH > 1 */
 410 }
 411
 412 #endif