apps/gui/skin_engine/skin_backdrops.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2010 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 "config.h"
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include "core_alloc.h"
  26 #include "string-extra.h"
  27 #include "settings.h"
  28 #include "wps_internals.h"
  29 #include "skin_engine.h"
  30
  31 #if !defined(__PCTOOL__) && defined(HAVE_BACKDROP_IMAGE)
  32
  33 #define NB_BDROPS SKINNABLE_SCREENS_COUNT*NB_SCREENS
  34 static struct skin_backdrop {
  35     char name[MAX_PATH];
  36     char *buffer;
  37     enum screen_type screen;
  38     bool loaded;
  39     int buflib_handle;
  40     int ref_count;
  41 } backdrops[NB_BDROPS];
  42
  43 #define NB_BDROPS SKINNABLE_SCREENS_COUNT*NB_SCREENS
  44 static int handle_being_loaded;
  45 static int current_lcd_backdrop[NB_SCREENS];
  46
  47 static int buflib_move_callback(int handle, void* current, void* new)
  48 {
  49     if (handle == handle_being_loaded)
  50         return BUFLIB_CB_CANNOT_MOVE;
  51     for (int i=0; i<NB_BDROPS; i++)
  52     {
  53         if (backdrops[i].buffer == current)
  54         {
  55             backdrops[i].buffer = new;
  56             break;
  57         }
  58     }
  59     FOR_NB_SCREENS(i)
  60         skin_backdrop_show(current_lcd_backdrop[i]);
  61     return BUFLIB_CB_OK;
  62 }
  63 static struct buflib_callbacks buflib_ops = {buflib_move_callback, NULL, NULL};
  64 static bool first_go = true;
  65 void skin_backdrop_init(void)
  66 {
  67     if (first_go)
  68     {
  69         for (int i=0; i<NB_BDROPS; i++)
  70         {
  71             backdrops[i].buflib_handle = -1;
  72             backdrops[i].name[0] = '\0';
  73             backdrops[i].buffer = NULL;
  74             backdrops[i].loaded = false;
  75             backdrops[i].ref_count = 0;
  76         }
  77         FOR_NB_SCREENS(i)
  78             current_lcd_backdrop[i] = -1;
  79         handle_being_loaded = -1;
  80         first_go = false;
  81     }
  82 }
  83
  84 int skin_backdrop_assign(char* backdrop, char *bmpdir,
  85                          enum screen_type screen)
  86 {
  87     char filename[MAX_PATH];
  88     int i, free = -1;
  89     if (!backdrop)
  90         return -1;
  91     if (backdrop[0] == '-')
  92     {
  93         filename[0] = '-';
  94         filename[1] = '\0';
  95         filename[2] = '\0'; /* we check this later to see if we actually have an
  96                                image to load. != '\0' means display the image */
  97     }
  98     else if (!strcmp(backdrop, BACKDROP_BUFFERNAME))
  99     {
 100         strcpy(filename, backdrop);
 101     }
 102     else
 103     {
 104         get_image_filename(backdrop, bmpdir, filename, sizeof(filename));
 105     }
 106     for (i=0; i<NB_BDROPS; i++)
 107     {
 108         if (!backdrops[i].name[0] && free < 0)
 109         {
 110             free = i;
 111             break;
 112         }
 113         else if (!strcmp(backdrops[i].name, filename) && backdrops[i].screen == screen)
 114         {
 115             backdrops[i].ref_count++;
 116             break;
 117         }
 118     }
 119     if (free >= 0)
 120     {
 121         strlcpy(backdrops[free].name, filename, MAX_PATH);
 122         backdrops[free].buffer = NULL;
 123         backdrops[free].screen = screen;
 124         backdrops[free].ref_count = 1;
 125         return free;
 126     }
 127     else if (i < NB_BDROPS)
 128         return i;
 129     return -1;
 130 }
 131
 132 bool skin_backdrops_preload(void)
 133 {
 134     bool retval = true;
 135     int i;
 136     char *filename;
 137     for (i=0; i<NB_BDROPS; i++)
 138     {
 139         if (backdrops[i].name[0] && !backdrops[i].buffer)
 140         {
 141             size_t buf_size;
 142             enum screen_type screen = backdrops[i].screen;
 143 #if defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1)
 144             if (screen == SCREEN_REMOTE)
 145                 buf_size = REMOTE_LCD_BACKDROP_BYTES;
 146             else
 147 #endif
 148                 buf_size = LCD_BACKDROP_BYTES;
 149
 150             filename = backdrops[i].name;
 151             if (screen == SCREEN_MAIN && global_settings.backdrop_file[0] &&
 152                 global_settings.backdrop_file[0] != '-' && filename[0] == '-')
 153             {
 154                 filename = global_settings.backdrop_file;
 155             }
 156             if (*filename && *filename != '-')
 157             {
 158                 backdrops[i].buflib_handle = core_alloc_ex(filename, buf_size, &buflib_ops);
 159                 if (backdrops[i].buflib_handle > 0)
 160                 {
 161                     backdrops[i].buffer = core_get_data(backdrops[i].buflib_handle);
 162                     handle_being_loaded = backdrops[i].buflib_handle;
 163                     if (strcmp(filename, BACKDROP_BUFFERNAME))
 164                     {
 165                         backdrops[i].loaded =
 166                                 screens[screen].backdrop_load(filename, backdrops[i].buffer);
 167                         handle_being_loaded = -1;
 168                         if (!backdrops[i].loaded)
 169                         {
 170                             core_free(backdrops[i].buflib_handle);
 171                             backdrops[i].buflib_handle = -1;
 172                             retval = false;
 173                         }
 174                     }
 175                     else
 176                         backdrops[i].loaded = true;
 177                 }
 178                 else
 179                     retval = false;
 180             }
 181             if (backdrops[i].name[0] == '-' && backdrops[i].loaded)
 182                 backdrops[i].name[2] = '.';
 183         }
 184     }
 185     return retval;
 186 }
 187
 188 void* skin_backdrop_get_buffer(int backdrop_id)
 189 {
 190     if (backdrop_id < 0)
 191         return NULL;
 192     return backdrops[backdrop_id].buffer;
 193 }
 194
 195 void skin_backdrop_show(int backdrop_id)
 196 {
 197     if (backdrop_id < 0)
 198     {
 199         screens[0].backdrop_show(NULL);
 200         current_lcd_backdrop[0] = -1;
 201         return;
 202     }
 203     enum screen_type screen = backdrops[backdrop_id].screen;
 204     if ((backdrops[backdrop_id].loaded == false) ||
 205         (backdrops[backdrop_id].name[0] == '-' &&
 206         backdrops[backdrop_id].name[2] == '\0'))
 207     {
 208         screens[screen].backdrop_show(NULL);
 209         current_lcd_backdrop[screen] = -1;
 210     }
 211     else if (backdrops[backdrop_id].buffer)
 212     {
 213         screens[screen].backdrop_show(backdrops[backdrop_id].buffer);
 214         current_lcd_backdrop[screen] = backdrop_id;
 215     }
 216 }
 217
 218 void skin_backdrop_unload(int backdrop_id)
 219 {
 220     backdrops[backdrop_id].ref_count--;
 221     if (backdrops[backdrop_id].ref_count <= 0)
 222     {
 223         if (backdrops[backdrop_id].buflib_handle > 0)
 224             core_free(backdrops[backdrop_id].buflib_handle);
 225         backdrops[backdrop_id].buffer = NULL;
 226         backdrops[backdrop_id].buflib_handle = -1;
 227         backdrops[backdrop_id].loaded = false;
 228         backdrops[backdrop_id].name[0] = '\0';
 229         backdrops[backdrop_id].ref_count = 0;
 230     }
 231 }
 232
 233 void skin_backdrop_load_setting(void)
 234 {
 235     int i;
 236     for(i=0;i<SKINNABLE_SCREENS_COUNT*NB_SCREENS;i++)
 237     {
 238         if (backdrops[i].name[0] == '-' && backdrops[i].screen == SCREEN_MAIN)
 239         {
 240             if (global_settings.backdrop_file[0] &&
 241                 global_settings.backdrop_file[0] != '-')
 242             {
 243                 if (!backdrops[i].buflib_handle <= 0)
 244                 {
 245                     backdrops[i].buflib_handle =
 246                             core_alloc_ex(global_settings.backdrop_file,
 247                                         LCD_BACKDROP_BYTES, &buflib_ops);
 248                     if (backdrops[i].buflib_handle <= 0)
 249                         return;
 250                 }
 251                 bool loaded;
 252                 backdrops[i].buffer = core_get_data(backdrops[i].buflib_handle);
 253                 handle_being_loaded = backdrops[i].buflib_handle;
 254                 loaded = screens[SCREEN_MAIN].backdrop_load(
 255                                                    global_settings.backdrop_file,
 256                                                    backdrops[i].buffer);
 257                 handle_being_loaded = -1;
 258                 backdrops[i].name[2] = loaded ? '.' : '\0';
 259                 backdrops[i].loaded = loaded;
 260                 return;
 261             }
 262             else
 263                 backdrops[i].name[2] = '\0';
 264         }
 265 #if NB_SCREENS > 1
 266         else if (backdrops[i].name[0] == '-')
 267         {
 268             backdrops[i].name[2] = '\0';
 269             return;
 270         }
 271 #endif
 272     }
 273 }
 274 #elif defined(__PCTOOL__)
 275
 276 int skin_backdrop_assign(char* backdrop, char *bmpdir,
 277                          enum screen_type screen)
 278 {
 279     (void)backdrop;
 280     (void)bmpdir;
 281     (void)screen;
 282     return 0;
 283 }
 284 void skin_backdrop_unload(int backdrop_id)
 285 {
 286     (void)backdrop_id;
 287 }
 288 #else
 289
 290 void skin_backdrop_init(void)
 291 {
 292 }
 293 #endif