7 files changed, 187 insertions, 113 deletions

diff --git a/apps/gui/skin_engine/skin_backdrops.c b/apps/gui/skin_engine/skin_backdrops.c
index 9ceee0cd05..f5b72a9652 100644
--- a/apps/gui/skin_engine/skin_backdrops.c
+++ b/apps/gui/skin_engine/skin_backdrops.c
@@ -30,88 +30,164 @@
 
 #if (LCD_DEPTH > 1) || (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1))
 
+#define NB_BDROPS SKINNABLE_SCREENS_COUNT*NB_SCREENS
 static struct skin_backdrop {
     char name[MAX_PATH];
     char *buffer;
     enum screen_type screen;
-} backdrops[SKINNABLE_SCREENS_COUNT*NB_SCREENS];
+} backdrops[NB_BDROPS];
+
+#define NB_BDROPS SKINNABLE_SCREENS_COUNT*NB_SCREENS
 
 void skin_backdrop_init(void)
 {
     int i;
-    for(i=0;i<SKINNABLE_SCREENS_COUNT*NB_SCREENS;i++)
+    for (i=0; i<NB_BDROPS; i++)
     {
         backdrops[i].name[0] = '\0';
         backdrops[i].buffer = NULL;
     }
 }
 
-/* load a backdrop into the skin buffer.
- * reuse buffers if the file is already loaded */
-char* skin_backdrop_load(char* backdrop, char *bmpdir, enum screen_type screen)
+int skin_backdrop_assign(char* backdrop, char *bmpdir,
+                         enum screen_type screen)
 {
-    int i;
-    struct skin_backdrop *bdrop = NULL;
     char dir[MAX_PATH];
     char filename[MAX_PATH];
-    size_t buf_size;
-    bool loaded = false;
-#if defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1)
-    if (screen == SCREEN_REMOTE)
-        buf_size = REMOTE_LCD_BACKDROP_BYTES;
-    else
-#endif
-        buf_size = LCD_BACKDROP_BYTES;
-
+    int i, free = -1;
+    if (!backdrop)
+        return -1;
     if (backdrop[0] == '-')
     {
+        filename[0] = '-';
+        filename[1] = '\0';
+        filename[2] = '\0'; /* we check this later to see if we actually have an
+                               image to load. != '\0' means display the image */
 #if NB_SCREENS > 1
         if (screen == SCREEN_REMOTE)
         {
-            return NULL; /* remotes don't have a backdrop setting (yet!) */
+            filename[0] = '\0';
         }
-        else
 #endif
-        {
-            char settings_bdrop = global_settings.backdrop_file[0];
-            if (settings_bdrop == '\0' || settings_bdrop == '-')
-            {
-                return NULL; /* backdrop setting not set */
-            }
-            snprintf(filename, sizeof(filename), "%s/%s.bmp",
-                     get_user_file_path(BACKDROP_DIR, 0, dir, sizeof(dir)),
-                     global_settings.backdrop_file);
-        }
     }
     else
     {
         const char *bd_dir = get_user_file_path(bmpdir, 0, dir, sizeof(dir));
         get_image_filename(backdrop, bd_dir, filename, sizeof(filename));
     }
-    
-    for(i=0;i<SKINNABLE_SCREENS_COUNT*NB_SCREENS;i++)
+    for (i=0; i<NB_BDROPS; i++)
     {
+        if (!backdrops[i].name[0] && free < 0)
+            free = i;
         if (!strcmp(backdrops[i].name, filename) && backdrops[i].screen == screen)
         {
-            return backdrops[i].buffer;
+            break;
+        }
+    }
+    if (i < NB_BDROPS)
+        return i;
+    else if (free >= 0)
+    {
+        strlcpy(backdrops[free].name, filename,
+                sizeof (backdrops[free].name));
+        backdrops[free].buffer = NULL;
+        backdrops[free].screen = screen;
+        return free;
+    }
+    return -1;
+}
+
+bool skin_backdrops_preload(void)
+{
+    bool retval = true;
+    int i;
+    char *filename;
+    for (i=0; i<NB_BDROPS; i++)
+    {
+        if (backdrops[i].name[0] && !backdrops[i].buffer)
+        {
+            size_t buf_size;
+            bool loaded = false;
+            enum screen_type screen = backdrops[i].screen;
+#if defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1)
+            if (screen == SCREEN_REMOTE)
+                buf_size = REMOTE_LCD_BACKDROP_BYTES;
+            else
+#endif
+                buf_size = LCD_BACKDROP_BYTES;
+
+            filename = backdrops[i].name;
+            if (screen == SCREEN_MAIN && global_settings.backdrop_file[0] &&
+                global_settings.backdrop_file[0] != '-' && filename[0] == '-')
+            {
+                char dir[MAX_PATH];
+                char* temp = filename+2; /* slightly hacky to get a buffer */
+                size_t size = sizeof(backdrops[i].name) - 2;
+                snprintf(temp, size, "%s/%s.bmp",
+                         get_user_file_path(BACKDROP_DIR, 0, dir, sizeof(dir)),
+                         global_settings.backdrop_file);
+                filename = temp;
+            }
+            if (*filename && *filename != '-')
+            {
+                backdrops[i].buffer = (char*)skin_buffer_alloc(buf_size);
+                loaded = backdrops[i].buffer && 
+                         screens[screen].backdrop_load(filename, backdrops[i].buffer);
+                if (!loaded)
+                    retval = false;
+            }
+            if (backdrops[i].name[0] == '-' && loaded)
+                backdrops[i].name[2] = '.';
         }
-        else if (!bdrop && backdrops[i].buffer == NULL)
+    }
+    return retval;
+}
+
+void skin_backdrop_show(int backdrop_id)
+{
+    if (backdrop_id < 0)
+        return;
+    enum screen_type screen = backdrops[backdrop_id].screen;
+    if (backdrops[backdrop_id].name[0] == '-' &&
+        backdrops[backdrop_id].name[2] == '\0')
+        return;
+    if (backdrops[backdrop_id].buffer)
+        screens[screen].backdrop_show(backdrops[backdrop_id].buffer);
+}
+
+void skin_backdrop_unload(int backdrop_id)
+{
+    backdrops[backdrop_id].buffer = NULL;
+}
+
+void skin_backdrop_load_setting(void)
+{
+    int i;
+    char filename[MAX_PATH], dir[MAX_PATH];
+    for(i=0;i<SKINNABLE_SCREENS_COUNT*NB_SCREENS;i++)
+    {
+        if (backdrops[i].name[0] == '-' && backdrops[i].screen == SCREEN_MAIN)
         {
-            bdrop = &backdrops[i];
+            if (global_settings.backdrop_file[0] &&
+                global_settings.backdrop_file[0] != '-')
+            {
+                if (!backdrops[i].buffer)
+                    backdrops[i].buffer = (char*)skin_buffer_alloc(LCD_BACKDROP_BYTES);
+                snprintf(filename, sizeof filename, "%s/%s.bmp",
+                         get_user_file_path(BACKDROP_DIR, 0, dir, sizeof(dir)),
+                         global_settings.backdrop_file);
+                bool loaded = backdrops[i].buffer && 
+                              screens[SCREEN_MAIN].backdrop_load(filename,
+                                                            backdrops[i].buffer);
+                backdrops[i].name[2] = loaded ? '.' : '\0';
+                return;
+            }
+            else
+                backdrops[i].name[2] = '\0';
         }
     }
-    if (!bdrop)
-        return NULL; /* too many backdrops loaded */
-    
-    bdrop->buffer = (char*)skin_buffer_alloc(buf_size);
-    if (!bdrop->buffer)
-        return NULL;
-    loaded = screens[screen].backdrop_load(filename, bdrop->buffer);
-    bdrop->screen = screen;
-    strlcpy(bdrop->name, filename, sizeof(bdrop->name));
-    
-    return loaded ? bdrop->buffer : NULL;
 }
+    
 #else
 
 void skin_backdrop_init(void)
diff --git a/apps/gui/skin_engine/skin_display.c b/apps/gui/skin_engine/skin_display.c
index d76b57976d..f001640cde 100644
--- a/apps/gui/skin_engine/skin_display.c
+++ b/apps/gui/skin_engine/skin_display.c
@@ -74,18 +74,21 @@ void skin_render(struct gui_wps *gwps, unsigned refresh_mode);
 
 /* update a skinned screen, update_type is WPS_REFRESH_* values.
  * Usually it should only be WPS_REFRESH_NON_STATIC
- * A full update will be done if required (state.do_full_update == true)
+ * A full update will be done if required (skin_do_full_update() == true)
  */
-void skin_update(struct gui_wps *gwps, unsigned int update_type)
+void skin_update(enum skinnable_screens skin, enum screen_type screen,
+                 unsigned int update_type)
 {
+    struct gui_wps *gwps = skin_get_gwps(skin, screen);
     /* This maybe shouldnt be here, 
      * This is also safe for skined screen which dont use the id3 */
-    struct mp3entry *id3 = gwps->state->id3;
+    struct mp3entry *id3 = skin_get_global_state()->id3;
     bool cuesheet_update = (id3 != NULL ? cuesheet_subtrack_changed(id3) : false);
-    gwps->sync_data->do_full_update |= cuesheet_update;
+    if (cuesheet_update)
+        skin_request_full_update(skin);
  
-    skin_render(gwps, gwps->sync_data->do_full_update ?
-                                        SKIN_REFRESH_ALL : update_type);
+    skin_render(gwps, skin_do_full_update(skin, screen) ? 
+                        SKIN_REFRESH_ALL : update_type);
 }
 
 #ifdef HAVE_LCD_BITMAP
@@ -126,7 +129,7 @@ void draw_progressbar(struct gui_wps *gwps, int line, struct progressbar *pb)
 {
     struct screen *display = gwps->display;
     struct viewport *vp = pb->vp;
-    struct wps_state *state = gwps->state;
+    struct wps_state *state = skin_get_global_state();
     struct mp3entry *id3 = state->id3;
     int y = pb->y, height = pb->height;
     unsigned long length, end;
@@ -729,11 +732,10 @@ bool skin_has_sbs(enum screen_type screen, struct wps_data *data)
 
 /* do the button loop as often as required for the peak meters to update
  * with a good refresh rate. 
- * gwps is really gwps[NB_SCREENS]! don't wrap this if FOR_NB_SCREENS()
  */
-int skin_wait_for_action(struct gui_wps *gwps, int context, int timeout)
+int skin_wait_for_action(enum skinnable_screens skin, int context, int timeout)
 {
-    (void)gwps; /* silence charcell warning */
+    (void)skin; /* silence charcell warning */
     int button = ACTION_NONE;
 #ifdef HAVE_LCD_BITMAP
     int i;
@@ -744,7 +746,7 @@ int skin_wait_for_action(struct gui_wps *gwps, int context, int timeout)
     bool pm=false;
     FOR_NB_SCREENS(i)
     {
-       if(gwps[i].data->peak_meter_enabled)
+       if(skin_get_gwps(skin, i)->data->peak_meter_enabled)
            pm = true;
     }
 
@@ -763,8 +765,8 @@ int skin_wait_for_action(struct gui_wps *gwps, int context, int timeout)
             if (TIME_AFTER(current_tick, next_refresh)) {
                 FOR_NB_SCREENS(i)
                 {
-                    if(gwps[i].data->peak_meter_enabled)
-                        skin_update(&gwps[i], SKIN_REFRESH_PEAK_METER);
+                    if(skin_get_gwps(skin, i)->data->peak_meter_enabled)
+                        skin_update(skin, i, SKIN_REFRESH_PEAK_METER);
                     next_refresh += HZ / PEAK_METER_FPS;
                 }
             }
@@ -781,3 +783,6 @@ int skin_wait_for_action(struct gui_wps *gwps, int context, int timeout)
     }
     return button;
 }
+
+
+
diff --git a/apps/gui/skin_engine/skin_engine.h b/apps/gui/skin_engine/skin_engine.h
index 6beedd90a2..ef4297d0ce 100644
--- a/apps/gui/skin_engine/skin_engine.h
+++ b/apps/gui/skin_engine/skin_engine.h
@@ -73,7 +73,8 @@ void skin_disarm_touchregions(struct wps_data *data);
 #endif
 
 /* Do a update_type update of the skinned screen */
-void skin_update(struct gui_wps *gwps, unsigned int update_type);
+void skin_update(enum skinnable_screens skin, enum screen_type screen,
+                 unsigned int update_type);
 
 /*
  * setup up the skin-data from a format-buffer (isfile = false)
@@ -92,13 +93,28 @@ bool skin_has_sbs(enum screen_type screen, struct wps_data *data);
  * reuse buffers if the file is already loaded */
 char* skin_backdrop_load(char* backdrop, char *bmpdir, enum screen_type screen);
 void skin_backdrop_init(void);
-
+int skin_backdrop_assign(char* backdrop, char *bmpdir,
+                          enum screen_type screen);
+bool skin_backdrops_preload(void);
+void skin_backdrop_show(int backdrop_id);
+void skin_backdrop_load_setting(void);
+void skin_backdrop_unload(int backdrop_id);
 
 /* do the button loop as often as required for the peak meters to update
  * with a good refresh rate. 
  * gwps is really gwps[NB_SCREENS]! don't wrap this in FOR_NB_SCREENS()
  */
-int skin_wait_for_action(struct gui_wps *gwps, int context, int timeout);
-#endif
+int skin_wait_for_action(enum skinnable_screens skin, int context, int timeout);
+
+void skin_load(enum skinnable_screens skin, enum screen_type screen,
+               const char *buf, bool isfile);
+struct gui_wps *skin_get_gwps(enum skinnable_screens skin, enum screen_type screen);
+struct wps_state *skin_get_global_state(void);
+void gui_sync_skin_init(void);
+
+
+bool skin_do_full_update(enum skinnable_screens skin, enum screen_type screen);
+void skin_request_full_update(enum skinnable_screens skin);
 
+#endif /* !PLUGIN */
 #endif
diff --git a/apps/gui/skin_engine/skin_parser.c b/apps/gui/skin_engine/skin_parser.c
index a6d4c798dc..2534bf9104 100644
--- a/apps/gui/skin_engine/skin_parser.c
+++ b/apps/gui/skin_engine/skin_parser.c
@@ -447,26 +447,27 @@ static int parse_image_special(struct skin_element *element,
 {
     (void)wps_data; /* kill warning */
     (void)token;
-    bool error = false;
 
 #if LCD_DEPTH > 1
+    char *filename;
     if (token->type == SKIN_TOKEN_IMAGE_BACKDROP)
     {
-        char *filename = element->params[0].data.text;
-        /* format: %X|filename.bmp| or %Xd */
-        if (!strcmp(filename, "d"))
+        if (isdefault(&element->params[0]))
         {
-            wps_data->backdrop = NULL;
-            return 0;
+            filename = "-";
         }
-        else if (!error)
+        else
         {
-            wps_data->backdrop = filename;
+            filename = element->params[0].data.text;
+            /* format: %X(filename.bmp) or %X(d) */
+            if (!strcmp(filename, "d"))
+                filename = NULL;
         }
+        wps_data->backdrop = filename;
     }
 #endif
-    /* Skip the rest of the line */
-    return error ? WPS_ERROR_INVALID_PARAM : 0;
+
+    return 0;
 }
 #endif
 
@@ -1010,6 +1011,8 @@ static void skin_data_reset(struct wps_data *wps_data)
     wps_data->progressbars = NULL;
 #endif
 #if LCD_DEPTH > 1 || defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1
+    if (wps_data->backdrop_id >= 0)
+        skin_backdrop_unload(wps_data->backdrop_id);
     wps_data->backdrop = NULL;
 #endif
 #ifdef HAVE_TOUCHSCREEN
@@ -1128,23 +1131,7 @@ static bool load_skin_bitmaps(struct wps_data *wps_data, char *bmpdir)
     }
 
 #if (LCD_DEPTH > 1) || (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1))
-    /* Backdrop load scheme:
-     * 1) %X|filename|
-     * 2) load the backdrop from settings
-     */
-    if (wps_data->backdrop)
-    {
-        if (screens[curr_screen].depth == 1)
-        {
-            wps_data->backdrop = NULL;
-            return retval;
-        }
-        bool needed = wps_data->backdrop[0] != '-';
-        wps_data->backdrop = skin_backdrop_load(wps_data->backdrop,
-                                                bmpdir, curr_screen);
-        if (!wps_data->backdrop && needed)
-            retval = false;
-    }
+    wps_data->backdrop_id = skin_backdrop_assign(wps_data->backdrop, bmpdir, curr_screen);
 #endif /* has backdrop support */
     return retval;
 }
@@ -1575,6 +1562,7 @@ bool skin_data_load(enum screen_type screen, struct wps_data *wps_data,
     }
 #if LCD_DEPTH > 1 || defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1
     wps_data->backdrop = "-";
+    wps_data->backdrop_id = -1;
 #endif
     /* parse the skin source */
     skin_buffer_save_position();
diff --git a/apps/gui/skin_engine/skin_render.c b/apps/gui/skin_engine/skin_render.c
index 9f392f144f..4fbd550c72 100644
--- a/apps/gui/skin_engine/skin_render.c
+++ b/apps/gui/skin_engine/skin_render.c
@@ -749,7 +749,8 @@ static void skin_render_playlistviewer(struct playlistviewer* viewer,
     else
 #endif
     {
-        struct cuesheet *cue = gwps->state->id3 ? gwps->state->id3->cuesheet:NULL;
+        struct cuesheet *cue = skin_get_global_state()->id3 ? 
+                               skin_get_global_state()->id3->cuesheet : NULL;
         cur_pos = playlist_get_display_index();
         max = playlist_amount()+1;
         if (cue)
diff --git a/apps/gui/skin_engine/skin_tokens.c b/apps/gui/skin_engine/skin_tokens.c
index 3de6630a51..0e98c2d42f 100644
--- a/apps/gui/skin_engine/skin_tokens.c
+++ b/apps/gui/skin_engine/skin_tokens.c
@@ -515,18 +515,18 @@ const char *get_radio_token(struct wps_token *token, int preset_offset,
 }
 #endif
 
-static struct mp3entry* get_mp3entry_from_offset(struct gui_wps *gwps,
-                                                 int offset, char **filename)
+static struct mp3entry* get_mp3entry_from_offset(int offset, char **filename)
 {
     struct mp3entry* pid3 = NULL;
-    struct cuesheet *cue = gwps->state->id3 ? gwps->state->id3->cuesheet:NULL;
+    struct wps_state *state = skin_get_global_state();
+    struct cuesheet *cue = state->id3 ? state->id3->cuesheet : NULL;
     const char *fname = NULL;
     if (cue && cue->curr_track_idx + offset < cue->track_count)
-        pid3 = gwps->state->id3;
+        pid3 = state->id3;
     else if (offset == 0)
-        pid3 = gwps->state->id3;
+        pid3 = state->id3;
     else if (offset == 1)
-        pid3 = gwps->state->nid3;
+        pid3 = state->nid3;
     else
     {
         static char filename_buf[MAX_PATH + 1];
@@ -568,7 +568,7 @@ const char *get_token_value(struct gui_wps *gwps,
         return NULL;
 
     struct wps_data *data = gwps->data;
-    struct wps_state *state = gwps->state;
+    struct wps_state *state = skin_get_global_state();
     struct mp3entry *id3; /* Think very carefully about using this. 
                              maybe get_id3_token() is the better place? */
     const char *out_text = NULL;
@@ -577,7 +577,7 @@ const char *get_token_value(struct gui_wps *gwps,
     if (!data || !state)
         return NULL;
 
-    id3 = get_mp3entry_from_offset(gwps, token->next? 1: offset, &filename);
+    id3 = get_mp3entry_from_offset(token->next? 1: offset, &filename);
     if (id3)
         filename = id3->path;
         
diff --git a/apps/gui/skin_engine/wps_internals.h b/apps/gui/skin_engine/wps_internals.h
index 0767f50279..5c3d953fdb 100644
--- a/apps/gui/skin_engine/wps_internals.h
+++ b/apps/gui/skin_engine/wps_internals.h
@@ -266,7 +266,10 @@ struct wps_data
     struct skin_token_list *progressbars;
 #endif
 #if LCD_DEPTH > 1 || defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1
-    char *backdrop;
+    struct {
+        char *backdrop;
+        int backdrop_id;
+    };
 #endif
 
 #ifdef HAVE_TOUCHSCREEN
@@ -305,18 +308,6 @@ struct wps_state
     bool is_fading;
 };
 
-/* Holds data for all screens in a skin. */
-struct wps_sync_data
-{
-    /* suitable for the viewportmanager, possibly only temporary here
-     * needs to be same for all screens! can't be split up for screens
-     * due to what viewportmanager_set_statusbar() accepts
-     * (FIXME?) */
-    int statusbars;
-    /* indicates whether the skin needs a full update for all screens */
-    bool do_full_update;
-};
-
 /* change the ff/rew-status
    if ff_rew = true then we are in skipping mode
    else we are in normal mode */
@@ -334,9 +325,6 @@ struct gui_wps
 {
     struct screen *display;
     struct wps_data *data;
-    struct wps_state *state;
-    /* must point to the same struct for all screens */
-    struct wps_sync_data *sync_data;
 };
 
 /* gui_wps end */