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