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 #include "lcd-remote.h"
  26 #include "font.h"
  27 #include "viewport.h"
  28 #include "screen_access.h"
  29 #include "settings.h"
  30 #include "misc.h"
  31
  32 /*some short cuts for fg/bg/line selector handling */
  33 #ifdef HAVE_LCD_COLOR
  34 #define FG_FALLBACK global_settings.fg_color
  35 #define BG_FALLBACK global_settings.bg_color
  36 #else
  37 #define FG_FALLBACK LCD_DEFAULT_FG
  38 #define BG_FALLBACK LCD_DEFAULT_BG
  39 #endif
  40 #ifdef HAVE_REMOTE_LCD
  41 #define REMOTE_FG_FALLBACK LCD_REMOTE_DEFAULT_FG
  42 #define REMOTE_BG_FALLBACK LCD_REMOTE_DEFAULT_BG
  43 #endif
  44
  45
  46 /* all below isn't needed for pc tools (i.e. checkwps/wps editor)
  47  * only viewport_parse_viewport() is */
  48 #ifndef __PCTOOL__
  49 #include "string.h"
  50 #include "kernel.h"
  51 #include "system.h"
  52 #include "statusbar.h"
  53 #include "appevents.h"
  54 #include "panic.h"
  55 #ifdef HAVE_LCD_BITMAP
  56 #include "language.h"
  57 #endif
  58 #include "statusbar-skinned.h"
  59 #include "debug.h"
  60
  61 #define VPSTACK_DEPTH 16
  62 struct viewport_stack_item
  63 {
  64     struct  viewport* vp;
  65     bool   enabled;
  66 };
  67
  68 #ifdef HAVE_LCD_BITMAP
  69 static void viewportmanager_redraw(void* data);
  70
  71 static int theme_stack_top[NB_SCREENS]; /* the last item added */
  72 static struct viewport_stack_item theme_stack[NB_SCREENS][VPSTACK_DEPTH];
  73 static bool is_theme_enabled(enum screen_type screen);
  74
  75
  76 static void toggle_events(bool enable)
  77 {
  78     if (enable)
  79     {
  80         add_event(GUI_EVENT_ACTIONUPDATE, false, viewportmanager_redraw);
  81 #if defined(HAVE_LCD_ENABLE) || defined(HAVE_LCD_SLEEP)
  82         add_event(LCD_EVENT_ACTIVATION, false, do_sbs_update_callback);
  83 #endif
  84         add_event(PLAYBACK_EVENT_TRACK_CHANGE, false,
  85                                                 do_sbs_update_callback);
  86         add_event(PLAYBACK_EVENT_NEXTTRACKID3_AVAILABLE, false,
  87                                                 do_sbs_update_callback);
  88     }
  89     else
  90     {
  91 #if defined(HAVE_LCD_ENABLE) || defined(HAVE_LCD_SLEEP)
  92         remove_event(LCD_EVENT_ACTIVATION, do_sbs_update_callback);
  93 #endif
  94         remove_event(PLAYBACK_EVENT_TRACK_CHANGE, do_sbs_update_callback);
  95         remove_event(PLAYBACK_EVENT_NEXTTRACKID3_AVAILABLE, do_sbs_update_callback);
  96         remove_event(GUI_EVENT_ACTIONUPDATE, viewportmanager_redraw);
  97     }
  98 }
  99
 100
 101 static void toggle_theme(enum screen_type screen, bool force)
 102 {
 103     bool enable_event = false;
 104     static bool was_enabled[NB_SCREENS] = {false};
 105     static bool after_boot[NB_SCREENS] = {false};
 106     int i;
 107
 108     FOR_NB_SCREENS(i)
 109     {
 110         enable_event = enable_event || is_theme_enabled(i);
 111         sb_set_title_text(NULL, Icon_NOICON, i);
 112     }
 113     toggle_events(enable_event);
 114
 115     if (is_theme_enabled(screen))
 116     {
 117         bool first_boot = theme_stack_top[screen] == 0;
 118         /* remove the left overs from the previous screen.
 119          * could cause a tiny flicker. Redo your screen code if that happens */
 120 #if LCD_DEPTH > 1 || defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1
 121         screens[screen].backdrop_show(sb_get_backdrop(screen));
 122 #endif
 123         if (LIKELY(after_boot[screen]) && (!was_enabled[screen] || force))
 124         {
 125             struct viewport deadspace, user;
 126             viewport_set_defaults(&user, screen);
 127             deadspace = user; /* get colours and everything */
 128             /* above */
 129             deadspace.x = 0;
 130             deadspace.y = 0;
 131             deadspace.width = screens[screen].lcdwidth;
 132             deadspace.height = user.y;
 133             if (deadspace.width && deadspace.height)
 134             {
 135                 screens[screen].set_viewport(&deadspace);
 136                 screens[screen].clear_viewport();
 137                 screens[screen].update_viewport();
 138             }
 139             /* below */
 140             deadspace.y = user.y + user.height;
 141             deadspace.height = screens[screen].lcdheight - deadspace.y;
 142             if (deadspace.width && deadspace.height)
 143             {
 144                 screens[screen].set_viewport(&deadspace);
 145                 screens[screen].clear_viewport();
 146                 screens[screen].update_viewport();
 147             }
 148             /* left */
 149             deadspace.x = 0;
 150             deadspace.y = 0;
 151             deadspace.width = user.x;
 152             deadspace.height = screens[screen].lcdheight;
 153             if (deadspace.width && deadspace.height)
 154             {
 155                 screens[screen].set_viewport(&deadspace);
 156                 screens[screen].clear_viewport();
 157                 screens[screen].update_viewport();
 158             }
 159             /* below */
 160             deadspace.x = user.x + user.width;
 161             deadspace.width = screens[screen].lcdwidth - deadspace.x;
 162             if (deadspace.width && deadspace.height)
 163             {
 164                 screens[screen].set_viewport(&deadspace);
 165                 screens[screen].clear_viewport();
 166                 screens[screen].update_viewport();
 167             }
 168             screens[screen].set_viewport(NULL);
 169         }
 170         intptr_t force = first_boot?0:1;
 171
 172         send_event(GUI_EVENT_ACTIONUPDATE, (void*)force);
 173     }
 174     else
 175     {
 176 #if LCD_DEPTH > 1 || (defined(LCD_REMOTE_DEPTH) && LCD_REMOTE_DEPTH > 1)
 177         screens[screen].backdrop_show(NULL);
 178 #endif
 179         screens[screen].stop_scroll();
 180     }
 181     /* let list initialize viewport in case viewport dimensions is changed. */
 182     send_event(GUI_EVENT_THEME_CHANGED, NULL);
 183     FOR_NB_SCREENS(i)
 184         was_enabled[i] = is_theme_enabled(i);
 185 #ifdef HAVE_TOUCHSCREEN
 186     sb_bypass_touchregions(!is_theme_enabled(SCREEN_MAIN));
 187 #endif
 188     after_boot[screen] = true;
 189 }
 190
 191 void viewportmanager_theme_enable(enum screen_type screen, bool enable,
 192                                  struct viewport *viewport)
 193 {
 194     int top = ++theme_stack_top[screen];
 195     if (top >= VPSTACK_DEPTH-1)
 196         panicf("Stack overflow... viewportmanager");
 197     theme_stack[screen][top].enabled = enable;
 198     theme_stack[screen][top].vp = viewport;
 199     toggle_theme(screen, false);
 200     /* then be nice and set the viewport up */
 201     if (viewport)
 202         viewport_set_defaults(viewport, screen);
 203 }
 204
 205 void viewportmanager_theme_undo(enum screen_type screen, bool force_redraw)
 206 {
 207     int top = --theme_stack_top[screen];
 208     if (top < 0)
 209         panicf("Stack underflow... viewportmanager");
 210
 211     toggle_theme(screen, force_redraw);
 212 }
 213
 214
 215 static bool is_theme_enabled(enum screen_type screen)
 216 {
 217     int top = theme_stack_top[screen];
 218     return theme_stack[screen][top].enabled;
 219 }
 220 #endif /* HAVE_LCD_BITMAP */
 221
 222 int viewport_get_nb_lines(const struct viewport *vp)
 223 {
 224 #ifdef HAVE_LCD_BITMAP
 225     return vp->height/font_get(vp->font)->height;
 226 #else
 227     (void)vp;
 228     return 2;
 229 #endif
 230 }
 231
 232 static void viewportmanager_redraw(void* data)
 233 {
 234     int i;
 235     FOR_NB_SCREENS(i)
 236     {
 237 #ifdef HAVE_LCD_BITMAP
 238         if (is_theme_enabled(i))
 239             sb_skin_update(i, NULL != data);
 240 #else
 241         (void)data;
 242         gui_statusbar_draw(&statusbars.statusbars[i], NULL, NULL);
 243 #endif
 244     }
 245 }
 246
 247 void viewportmanager_init()
 248 {
 249 #ifdef HAVE_LCD_BITMAP
 250     int i;
 251     FOR_NB_SCREENS(i)
 252     {
 253         theme_stack_top[i] = -1; /* the next call fixes this to 0 */
 254         /* We always want the theme enabled by default... */
 255         viewportmanager_theme_enable(i, true, NULL);
 256     }
 257 #else
 258     add_event(GUI_EVENT_ACTIONUPDATE, false, viewportmanager_redraw);
 259 #endif
 260 }
 261
 262 #ifdef HAVE_LCD_BITMAP
 263 void viewportmanager_theme_changed(const int which)
 264 {
 265     int i;
 266 #ifdef HAVE_BUTTONBAR
 267     if (which & THEME_BUTTONBAR)
 268     {   /* don't handle further, the custom ui viewport ignores the buttonbar,
 269          * as does viewport_set_defaults(), since only lists use it*/
 270         screens[SCREEN_MAIN].has_buttonbar = global_settings.buttonbar;
 271     }
 272 #endif
 273     if (which & THEME_UI_VIEWPORT)
 274     {
 275     }
 276     if (which & THEME_LANGUAGE)
 277     {
 278     }
 279     if (which & THEME_STATUSBAR)
 280     {
 281         FOR_NB_SCREENS(i)
 282         {
 283             /* This can probably be done better...
 284              * disable the theme so it's forced to do a full redraw  */
 285             viewportmanager_theme_enable(i, false, NULL);
 286             viewportmanager_theme_undo(i, true);
 287         }
 288     }
 289     send_event(GUI_EVENT_THEME_CHANGED, NULL);
 290 }
 291
 292 #ifdef HAVE_TOUCHSCREEN
 293 /* check if a point (x and y coordinates) are within a viewport */
 294 bool viewport_point_within_vp(const struct viewport *vp,
 295                                const int x, const int y)
 296 {
 297     bool is_x = (x >= vp->x && x < (vp->x + vp->width));
 298     bool is_y = (y >= vp->y && y < (vp->y + vp->height));
 299     return (is_x && is_y);
 300 }
 301 #endif /* HAVE_TOUCHSCREEN */
 302
 303 static void set_default_align_flags(struct viewport *vp)
 304 {
 305     vp->flags &= ~VP_FLAG_ALIGNMENT_MASK;
 306     if (UNLIKELY(lang_is_rtl()))
 307         vp->flags |= VP_FLAG_ALIGN_RIGHT;
 308 }
 309
 310 #endif /* HAVE_LCD_BITMAP */
 311 #endif /* __PCTOOL__ */
 312
 313 void viewport_set_fullscreen(struct viewport *vp,
 314                               const enum screen_type screen)
 315 {
 316     vp->x = 0;
 317     vp->y = 0;
 318     vp->width = screens[screen].lcdwidth;
 319     vp->height = screens[screen].lcdheight;
 320
 321 #ifdef HAVE_LCD_BITMAP
 322 #ifndef __PCTOOL__
 323     set_default_align_flags(vp);
 324 #endif
 325     vp->font = FONT_UI + screen; /* default to UI to discourage SYSFONT use */
 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