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
  41 /* all below isn't needed for pc tools (i.e. checkwps/wps editor)
  42  * only viewport_parse_viewport() is */
  43 #ifndef __PCTOOL__
  44 #include "sprintf.h"
  45 #include "string.h"
  46 #include "kernel.h"
  47 #include "system.h"
  48 #include "statusbar.h"
  49 #include "appevents.h"
  50 #include "panic.h"
  51 #ifdef HAVE_LCD_BITMAP
  52 #include "language.h"
  53 #endif
  54 #include "statusbar-skinned.h"
  55 #include "debug.h"
  56 #include "viewport.h"
  57
  58 #define VPSTACK_DEPTH 16
  59 struct viewport_stack_item
  60 {
  61     struct  viewport* vp;
  62     bool   enabled;
  63 };
  64
  65 #ifdef HAVE_LCD_BITMAP
  66 static void viewportmanager_redraw(void* data);
  67
  68 static int theme_stack_top[NB_SCREENS]; /* the last item added */
  69 static struct viewport_stack_item theme_stack[NB_SCREENS][VPSTACK_DEPTH];
  70 static bool is_theme_enabled(enum screen_type screen);
  71
  72
  73 static void toggle_events(bool enable)
  74 {
  75     if (enable)
  76     {
  77         add_event(GUI_EVENT_ACTIONUPDATE, false, viewportmanager_redraw);
  78 #if defined(HAVE_LCD_ENABLE) || defined(HAVE_LCD_SLEEP)
  79         add_event(LCD_EVENT_ACTIVATION, false, do_sbs_update_callback);
  80 #endif
  81         add_event(PLAYBACK_EVENT_TRACK_CHANGE, false,
  82                                                 do_sbs_update_callback);
  83         add_event(PLAYBACK_EVENT_NEXTTRACKID3_AVAILABLE, false,
  84                                                 do_sbs_update_callback);
  85     }
  86     else
  87     {
  88 #if defined(HAVE_LCD_ENABLE) || defined(HAVE_LCD_SLEEP)
  89         remove_event(LCD_EVENT_ACTIVATION, do_sbs_update_callback);
  90 #endif
  91         remove_event(PLAYBACK_EVENT_TRACK_CHANGE, do_sbs_update_callback);
  92         remove_event(PLAYBACK_EVENT_NEXTTRACKID3_AVAILABLE, do_sbs_update_callback);
  93         remove_event(GUI_EVENT_ACTIONUPDATE, viewportmanager_redraw);
  94     }
  95 }
  96
  97
  98 static void toggle_theme(enum screen_type screen, bool force)
  99 {
 100     bool enable_event = false;
 101     static bool was_enabled[NB_SCREENS] = {false};
 102     int i;
 103
 104     FOR_NB_SCREENS(i)
 105     {
 106         enable_event = enable_event || is_theme_enabled(i);
 107     }
 108     toggle_events(enable_event);
 109
 110     if (is_theme_enabled(screen))
 111     {
 112 #if LCD_DEPTH > 1 || LCD_REMOTE_DEPTH > 1
 113         screens[screen].backdrop_show(BACKDROP_MAIN);
 114 #endif
 115         /* remove the left overs from the previous screen.
 116          * could cause a tiny flicker. Redo your screen code if that happens */
 117         if (!was_enabled[screen] || force)
 118         {
 119             struct viewport deadspace, user;
 120             viewport_set_defaults(&user, screen);
 121             deadspace = user; /* get colours and everything */
 122             /* above */
 123             deadspace.x = 0;
 124             deadspace.y = 0;
 125             deadspace.width = screens[screen].lcdwidth;
 126             deadspace.height = user.y;
 127             if (deadspace.width && deadspace.height)
 128             {
 129                 screens[screen].set_viewport(&deadspace);
 130                 screens[screen].clear_viewport();
 131                 screens[screen].update_viewport();
 132             }
 133             /* below */
 134             deadspace.y = user.y + user.height;
 135             deadspace.height = screens[screen].lcdheight - deadspace.y;
 136             if (deadspace.width && deadspace.height)
 137             {
 138                 screens[screen].set_viewport(&deadspace);
 139                 screens[screen].clear_viewport();
 140                 screens[screen].update_viewport();
 141             }
 142             /* left */
 143             deadspace.x = 0;
 144             deadspace.y = 0;
 145             deadspace.width = user.x;
 146             deadspace.height = screens[screen].lcdheight;
 147             if (deadspace.width && deadspace.height)
 148             {
 149                 screens[screen].set_viewport(&deadspace);
 150                 screens[screen].clear_viewport();
 151                 screens[screen].update_viewport();
 152             }
 153             /* below */
 154             deadspace.x = user.x + user.width;
 155             deadspace.width = screens[screen].lcdwidth - deadspace.x;
 156             if (deadspace.width && deadspace.height)
 157             {
 158                 screens[screen].set_viewport(&deadspace);
 159                 screens[screen].clear_viewport();
 160                 screens[screen].update_viewport();
 161             }
 162         }
 163         send_event(GUI_EVENT_ACTIONUPDATE, (void*)1); /* force a redraw */
 164     }
 165     else
 166     {
 167 #if LCD_DEPTH > 1 || LCD_REMOTE_DEPTH > 1
 168         screens[screen].backdrop_hide();
 169 #endif
 170         screens[screen].stop_scroll();
 171     }
 172     /* let list initialize viewport in case viewport dimensions is changed. */
 173     send_event(GUI_EVENT_THEME_CHANGED, NULL);
 174     FOR_NB_SCREENS(i)
 175         was_enabled[i] = is_theme_enabled(i);
 176 }
 177
 178 void viewportmanager_theme_enable(enum screen_type screen, bool enable,
 179                                  struct viewport *viewport)
 180 {
 181     int top = ++theme_stack_top[screen];
 182     if (top >= VPSTACK_DEPTH-1)
 183         panicf("Stack overflow... viewportmanager");
 184     theme_stack[screen][top].enabled = enable;
 185     theme_stack[screen][top].vp = viewport;
 186     toggle_theme(screen, false);
 187     /* then be nice and set the viewport up */
 188     if (viewport)
 189         viewport_set_defaults(viewport, screen);
 190 }
 191
 192 void viewportmanager_theme_undo(enum screen_type screen, bool force_redraw)
 193 {
 194     int top = --theme_stack_top[screen];
 195     if (top < 0)
 196         panicf("Stack underflow... viewportmanager");
 197
 198     toggle_theme(screen, force_redraw);
 199 }
 200
 201
 202 static bool is_theme_enabled(enum screen_type screen)
 203 {
 204     int top = theme_stack_top[screen];
 205     return theme_stack[screen][top].enabled;
 206 }
 207
 208 static bool custom_vp_loaded_ok[NB_SCREENS];
 209 static struct viewport custom_vp[NB_SCREENS];
 210
 211 static unsigned viewport_init_ui_vp(void);
 212 #endif /* HAVE_LCD_BITMAP */
 213
 214 int viewport_get_nb_lines(const struct viewport *vp)
 215 {
 216 #ifdef HAVE_LCD_BITMAP
 217     return vp->height/font_get(vp->font)->height;
 218 #else
 219     (void)vp;
 220     return 2;
 221 #endif
 222 }
 223
 224 static void viewportmanager_redraw(void* data)
 225 {
 226     int i;
 227     FOR_NB_SCREENS(i)
 228     {
 229 #ifdef HAVE_LCD_BITMAP
 230        if (statusbar_position(i) == STATUSBAR_CUSTOM)
 231            sb_skin_update(i, NULL != data);
 232         else if (statusbar_position(i) != STATUSBAR_OFF)
 233 #endif
 234             gui_statusbar_draw(&statusbars.statusbars[i], NULL != data);
 235     }
 236 }
 237
 238 void viewportmanager_init()
 239 {
 240 #ifdef HAVE_LCD_BITMAP
 241     int i;
 242     FOR_NB_SCREENS(i)
 243     {
 244         theme_stack_top[i] = -1; /* the next call fixes this to 0 */
 245         /* We always want the theme enabled by default... */
 246         viewportmanager_theme_enable(i, true, NULL);
 247     }
 248 #else
 249     add_event(GUI_EVENT_ACTIONUPDATE, false, viewportmanager_redraw);
 250 #endif
 251 }
 252
 253 #ifdef HAVE_LCD_BITMAP
 254 void viewportmanager_theme_changed(const int which)
 255 {
 256     int i;
 257 #ifdef HAVE_BUTTONBAR
 258     if (which & THEME_BUTTONBAR)
 259     {   /* don't handle further, the custom ui viewport ignores the buttonbar,
 260          * as does viewport_set_defaults(), since only lists use it*/
 261         screens[SCREEN_MAIN].has_buttonbar = global_settings.buttonbar;
 262     }
 263 #endif
 264     if (which & THEME_UI_VIEWPORT)
 265     {
 266         viewport_init_ui_vp();
 267     }
 268     if (which & THEME_LANGUAGE)
 269     {
 270     }
 271     if (which & THEME_STATUSBAR)
 272     {
 273         FOR_NB_SCREENS(i)
 274         {
 275             /* This can probably be done better...
 276              * disable the theme so it's forced to do a full redraw  */
 277             viewportmanager_theme_enable(i, false, NULL);
 278             viewportmanager_theme_undo(i, true);
 279         }
 280     }
 281     send_event(GUI_EVENT_THEME_CHANGED, NULL);
 282 }
 283
 284 /*
 285  * (re)parse the UI vp from the settings
 286  *  - Returns
 287  *          0 if no UI vp is used at all
 288  *          else the bit for the screen (1<<screen) is set
 289  */
 290 static unsigned viewport_init_ui_vp(void)
 291 {
 292     int screen;
 293     const char *ret = NULL;
 294     char *setting;
 295     FOR_NB_SCREENS(screen)
 296     {
 297 #ifdef HAVE_REMOTE_LCD
 298         if ((screen == SCREEN_REMOTE))
 299             setting = global_settings.remote_ui_vp_config;
 300         else
 301 #endif
 302             setting = global_settings.ui_vp_config;
 303
 304         ret = viewport_parse_viewport(&custom_vp[screen], screen,
 305                                      setting, ',');
 306
 307         custom_vp_loaded_ok[screen] = (ret != NULL);
 308     }
 309     return true; /* meh fixme */
 310 }
 311
 312 #ifdef HAVE_TOUCHSCREEN
 313 /* check if a point (x and y coordinates) are within a viewport */
 314 bool viewport_point_within_vp(const struct viewport *vp,
 315                                const int x, const int y)
 316 {
 317     bool is_x = (x >= vp->x && x < (vp->x + vp->width));
 318     bool is_y = (y >= vp->y && y < (vp->y + vp->height));
 319     return (is_x && is_y);
 320 }
 321 #endif /* HAVE_TOUCHSCREEN */
 322
 323 static void set_default_align_flags(struct viewport *vp)
 324 {
 325     vp->flags &= ~VP_FLAG_ALIGNMENT_MASK;
 326     if (UNLIKELY(lang_is_rtl()))
 327         vp->flags |= VP_FLAG_ALIGN_RIGHT;
 328 }
 329
 330 #endif /* HAVE_LCD_BITMAP */
 331 #endif /* __PCTOOL__ */
 332
 333 #ifdef HAVE_LCD_COLOR
 334 #define ARG_STRING(_depth) ((_depth) == 2 ? "dddddgg":"dddddcc")
 335 #else
 336 #define ARG_STRING(_depth) "dddddgg"
 337 #endif
 338
 339
 340 void viewport_set_fullscreen(struct viewport *vp,
 341                               const enum screen_type screen)
 342 {
 343     vp->x = 0;
 344     vp->y = 0;
 345     vp->width = screens[screen].lcdwidth;
 346     vp->height = screens[screen].lcdheight;
 347
 348 #ifdef HAVE_LCD_BITMAP
 349 #ifndef __PCTOOL__
 350     set_default_align_flags(vp);
 351 #endif
 352     vp->font = FONT_UI; /* default to UI to discourage SYSFONT use */
 353     vp->drawmode = DRMODE_SOLID;
 354 #if LCD_DEPTH > 1
 355 #ifdef HAVE_REMOTE_LCD
 356     /* We only need this test if there is a remote LCD */
 357     if (screen == SCREEN_MAIN)
 358 #endif
 359     {
 360         vp->fg_pattern = FG_FALLBACK;
 361         vp->bg_pattern = BG_FALLBACK;
 362 #ifdef HAVE_LCD_COLOR
 363         vp->lss_pattern = global_settings.lss_color;
 364         vp->lse_pattern = global_settings.lse_color;
 365         vp->lst_pattern = global_settings.lst_color;
 366 #endif
 367     }
 368 #endif
 369
 370 #if defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1
 371     if (screen == SCREEN_REMOTE)
 372     {
 373         vp->fg_pattern = LCD_REMOTE_DEFAULT_FG;
 374         vp->bg_pattern = LCD_REMOTE_DEFAULT_BG;
 375     }
 376 #endif
 377 #endif
 378 }
 379
 380 void viewport_set_defaults(struct viewport *vp,
 381                             const enum screen_type screen)
 382 {
 383     /* Reposition:
 384        1) If the "ui viewport" setting is set, and a sbs is loaded which specifies a %Vi
 385             return the intersection of those two viewports
 386        2) If only one of the "ui viewport" setting, or sbs %Vi is set
 387             return it
 388        3) No user viewports set
 389             return the full display
 390      */
 391 #if defined(HAVE_LCD_BITMAP) && !defined(__PCTOOL__)
 392
 393     struct viewport *sbs_area = NULL, *user_setting = NULL;
 394     if (!is_theme_enabled(screen))
 395    {
 396        viewport_set_fullscreen(vp, screen);
 397        return;
 398    }
 399     /* get the two viewports */
 400     if (custom_vp_loaded_ok[screen])
 401         user_setting = &custom_vp[screen];
 402     if (sb_skin_get_state(screen))
 403         sbs_area = sb_skin_get_info_vp(screen);
 404
 405     /* have both? get their intersection */
 406     if (sbs_area && user_setting)
 407     {
 408         struct viewport *a = sbs_area, *b = user_setting;
 409         /* if ui vp and info vp overlap, intersect */
 410         if (a->x             < b->x + b->width   &&
 411             a->x + a->width  > b->x              &&
 412             a->y             < b->y + b->height  &&
 413             a->y + a->height > b->y)
 414         {
 415             /* copy from ui vp first (for other field),fix coordinates after */
 416             *vp = *user_setting;
 417             set_default_align_flags(vp);
 418             vp->x = MAX(a->x, b->x);
 419             vp->y = MAX(a->y, b->y);
 420             vp->width = MIN(a->x + a->width, b->x + b->width) - vp->x;
 421             vp->height = MIN(a->y + a->height, b->y + b->height) - vp->y;
 422             return;
 423         }
 424         /* else (no overlap at all) fall back to info vp from sbs, that
 425          * has no redraw problems */
 426     }
 427
 428     /* if only one is active use it
 429      * or if the above check for overlapping failed, use info vp then, because
 430      * that doesn't give redraw problems */
 431     if (sbs_area)
 432         *vp = *sbs_area;
 433     else if (user_setting)
 434         *vp = *user_setting;
 435     /* have neither so its fullscreen which was fixed at the beginning */
 436     else
 437 #endif /* HAVE_LCD_BITMAP */
 438         viewport_set_fullscreen(vp, screen);
 439 }
 440
 441
 442 #ifdef HAVE_LCD_BITMAP
 443 const char* viewport_parse_viewport(struct viewport *vp,
 444                                     enum screen_type screen,
 445                                     const char *bufptr,
 446                                     const char separator)
 447 {
 448     /* parse the list to the viewport struct */
 449     const char *ptr = bufptr;
 450     int depth;
 451     uint32_t set = 0;
 452
 453     enum {
 454         PL_X = 0,
 455         PL_Y,
 456         PL_WIDTH,
 457         PL_HEIGHT,
 458         PL_FONT,
 459         PL_FG,
 460         PL_BG,
 461     };
 462
 463     /* Work out the depth of this display */
 464     depth = screens[screen].depth;
 465 #if (LCD_DEPTH == 1) || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH == 1)
 466     if (depth == 1)
 467     {
 468         if (!(ptr = parse_list("ddddd", &set, separator, ptr,
 469                     &vp->x, &vp->y, &vp->width, &vp->height, &vp->font)))
 470             return NULL;
 471     }
 472     else
 473 #endif
 474 #if (LCD_DEPTH > 1) || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)
 475     if (depth >= 2)
 476     {
 477         if (!(ptr = parse_list(ARG_STRING(depth), &set, separator, ptr,
 478                     &vp->x, &vp->y, &vp->width, &vp->height, &vp->font,
 479                     &vp->fg_pattern,&vp->bg_pattern)))
 480             return NULL;
 481     }
 482     else
 483 #endif
 484     {}
 485 #undef ARG_STRING
 486
 487     /* X and Y *must* be set */
 488     if (!LIST_VALUE_PARSED(set, PL_X) || !LIST_VALUE_PARSED(set, PL_Y))
 489         return NULL;
 490     /* check for negative values */
 491     if (vp->x < 0)
 492         vp->x += screens[screen].lcdwidth;
 493     if (vp->y < 0)
 494         vp->y += screens[screen].lcdheight;
 495
 496     /* fix defaults,
 497      * and negative width/height which means "extend to edge minus value */
 498     if (!LIST_VALUE_PARSED(set, PL_WIDTH))
 499         vp->width = screens[screen].lcdwidth - vp->x;
 500     else if (vp->width < 0)
 501         vp->width = (vp->width + screens[screen].lcdwidth) - vp->x;
 502     if (!LIST_VALUE_PARSED(set, PL_HEIGHT))
 503         vp->height = screens[screen].lcdheight - vp->y;
 504     else if (vp->height < 0)
 505         vp->height = (vp->height + screens[screen].lcdheight) - vp->y;
 506
 507 #if (LCD_DEPTH > 1) || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)
 508     if (!LIST_VALUE_PARSED(set, PL_FG))
 509         vp->fg_pattern = FG_FALLBACK;
 510     if (!LIST_VALUE_PARSED(set, PL_BG))
 511         vp->bg_pattern = BG_FALLBACK;
 512 #endif /* LCD_DEPTH > 1 || LCD_REMOTE_DEPTH > 1 */
 513
 514 #ifdef HAVE_LCD_COLOR
 515     vp->lss_pattern = global_settings.lss_color;
 516     vp->lse_pattern = global_settings.lse_color;
 517     vp->lst_pattern = global_settings.lst_color;
 518 #endif
 519
 520     /* Validate the viewport dimensions - we know that the numbers are
 521        non-negative integers, ignore bars and assume the viewport takes them
 522        * into account */
 523     if ((vp->x >= screens[screen].lcdwidth) ||
 524         ((vp->x + vp->width) > screens[screen].lcdwidth) ||
 525         (vp->y >= screens[screen].lcdheight) ||
 526         ((vp->y + vp->height) > screens[screen].lcdheight))
 527     {
 528         return NULL;
 529     }
 530
 531     /* Default to using the user font if the font was an invalid number or '-'*/
 532     if (((vp->font != FONT_SYSFIXED) && (vp->font != FONT_UI))
 533             || !LIST_VALUE_PARSED(set, PL_FONT)
 534             )
 535         vp->font = FONT_UI;
 536
 537     /* Set the defaults for fields not user-specified */
 538     vp->drawmode = DRMODE_SOLID;
 539 #ifndef __PCTOOL__
 540     set_default_align_flags(vp);
 541 #endif
 542
 543     return ptr;
 544 }
 545 #endif