5 files changed, 154 insertions, 112 deletions

diff --git a/apps/gui/backdrop.c b/apps/gui/backdrop.c
index c95fda9022..28216da4e0 100644
--- a/apps/gui/backdrop.c
+++ b/apps/gui/backdrop.c
@@ -27,21 +27,19 @@
 #endif
 #include "backdrop.h"
 
-#if LCD_DEPTH >= 8
-static fb_data main_backdrop[LCD_HEIGHT][LCD_WIDTH]  __attribute__ ((aligned (16)));
-static fb_data wps_backdrop[LCD_HEIGHT][LCD_WIDTH]  __attribute__ ((aligned (16)));
-#elif LCD_DEPTH == 2
-static fb_data main_backdrop[LCD_FBHEIGHT][LCD_FBWIDTH];
-static fb_data wps_backdrop[LCD_FBHEIGHT][LCD_FBWIDTH];
-#endif
+static fb_data main_backdrop[LCD_FBHEIGHT][LCD_FBHEIGHT]
+                __attribute__ ((aligned (16)));
+static fb_data skin_backdrop[LCD_FBHEIGHT][LCD_FBHEIGHT]
+                __attribute__ ((aligned (16)));
 
 #if defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1
-static fb_remote_data remote_wps_backdrop[LCD_REMOTE_FBHEIGHT][LCD_REMOTE_FBWIDTH];
-static bool remote_wps_backdrop_valid = false;
+static fb_remote_data
+remote_skin_backdrop[LCD_REMOTE_FBHEIGHT][LCD_REMOTE_FBWIDTH];
+static bool remote_skin_backdrop_valid = false;
 #endif
 
 static bool main_backdrop_valid = false;
-static bool wps_backdrop_valid = false;
+static bool skin_backdrop_valid = false;
 
 /* load a backdrop into a buffer */
 static bool load_backdrop(const char* filename, fb_data* backdrop_buffer)
@@ -54,49 +52,43 @@ static bool load_backdrop(const char* filename, fb_data* backdrop_buffer)
     ret = read_bmp_file(filename, &bm, sizeof(main_backdrop),
                         FORMAT_NATIVE | FORMAT_DITHER, NULL);
 
-    if ((ret > 0) && (bm.width == LCD_WIDTH) && (bm.height == LCD_HEIGHT))
-    {
-        return true;
-    }
-    else
-    {
-        return false;
-    }
+    return ((ret > 0)
+            && (bm.width == LCD_WIDTH) && (bm.height == LCD_HEIGHT));
 }
 
-bool load_main_backdrop(const char* filename)
+static bool load_main_backdrop(const char* filename)
 {
     main_backdrop_valid = load_backdrop(filename, &main_backdrop[0][0]);
     return main_backdrop_valid;
 }
 
-bool load_wps_backdrop(const char* filename)
+static inline bool load_skin_backdrop(const char* filename)
 {
-    wps_backdrop_valid = load_backdrop(filename, &wps_backdrop[0][0]);
-    return wps_backdrop_valid;
+    skin_backdrop_valid = load_backdrop(filename, &skin_backdrop[0][0]);
+    return skin_backdrop_valid;
 }
 
-void unload_main_backdrop(void)
+static inline void unload_main_backdrop(void)
 {
     main_backdrop_valid = false;
 }
 
-void unload_wps_backdrop(void)
+static inline void unload_skin_backdrop(void)
 {
-    wps_backdrop_valid = false;
+    skin_backdrop_valid = false;
 }
 
-void show_main_backdrop(void)
+static inline void show_main_backdrop(void)
 {
     lcd_set_backdrop(main_backdrop_valid ? &main_backdrop[0][0] : NULL);
 }
 
-void show_wps_backdrop(void)
+static void show_skin_backdrop(void)
 {
     /* if no wps backdrop, fall back to main backdrop */
-    if(wps_backdrop_valid)
+    if(skin_backdrop_valid)
     {
-        lcd_set_backdrop(&wps_backdrop[0][0]);
+        lcd_set_backdrop(&skin_backdrop[0][0]);
     }
     else
     {
@@ -104,9 +96,39 @@ void show_wps_backdrop(void)
     }
 }
 
+/* api functions */
+
+bool backdrop_load(enum backdrop_type bdrop, const char* filename)
+{
+    if (bdrop == BACKDROP_MAIN)
+        return load_main_backdrop(filename);
+    else if (bdrop == BACKDROP_SKIN_WPS)
+        return load_skin_backdrop(filename);
+    else
+        return false;
+}
+
+void backdrop_unload(enum backdrop_type bdrop)
+{
+    if (bdrop == BACKDROP_MAIN)
+        unload_main_backdrop();
+    else if (bdrop == BACKDROP_SKIN_WPS)
+        unload_skin_backdrop();
+}
+
+void backdrop_show(enum backdrop_type bdrop)
+{
+    if (bdrop == BACKDROP_MAIN)
+        show_main_backdrop();
+    else if (bdrop == BACKDROP_SKIN_WPS)
+        show_skin_backdrop();
+}
+
+
 #if defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1
 
-static bool load_remote_backdrop(const char* filename, fb_remote_data* backdrop_buffer)
+static bool load_remote_backdrop(const char* filename,
+            fb_remote_data* backdrop_buffer)
 {
     struct bitmap bm;
     int ret;
@@ -116,33 +138,29 @@ static bool load_remote_backdrop(const char* filename, fb_remote_data* backdrop_
     ret = read_bmp_file(filename, &bm, sizeof(main_backdrop),
                         FORMAT_NATIVE | FORMAT_DITHER | FORMAT_REMOTE, NULL);
 
-    if ((ret > 0) && (bm.width == LCD_REMOTE_WIDTH) && (bm.height == LCD_REMOTE_HEIGHT))
-    {
-        return true;
-    }
-    else
-    {
-        return false;
-    }
+    return ((ret > 0)
+            && (bm.width == LCD_REMOTE_WIDTH)
+            && (bm.height == LCD_REMOTE_HEIGHT));
 }
 
-bool load_remote_wps_backdrop(const char* filename)
+static inline bool load_remote_skin_backdrop(const char* filename)
 {
-    remote_wps_backdrop_valid = load_remote_backdrop(filename, &remote_wps_backdrop[0][0]);
-    return remote_wps_backdrop_valid;
+    remote_skin_backdrop_valid =
+            load_remote_backdrop(filename, &remote_skin_backdrop[0][0]);
+    return remote_skin_backdrop_valid;
 }
 
-void unload_remote_wps_backdrop(void)
+static inline void unload_remote_skin_backdrop(void)
 {
-    remote_wps_backdrop_valid = false;
+    remote_skin_backdrop_valid = false;
 }
 
-void show_remote_wps_backdrop(void)
+static inline void show_remote_skin_backdrop(void)
 {
     /* if no wps backdrop, fall back to main backdrop */
-    if(remote_wps_backdrop_valid)
+    if(remote_skin_backdrop_valid)
     {
-        lcd_remote_set_backdrop(&remote_wps_backdrop[0][0]);
+        lcd_remote_set_backdrop(&remote_skin_backdrop[0][0]);
     }
     else
     {
@@ -150,8 +168,37 @@ void show_remote_wps_backdrop(void)
     }
 }
 
-void show_remote_main_backdrop(void)
+static line void show_remote_main_backdrop(void)
 {
     lcd_remote_set_backdrop(NULL);
 }
+
+
+/* api functions */
+bool remote_backdrop_load(enum backdrop_type bdrop,
+                                const char *filename)
+{
+    if (bdrop == BACKDROP_SKIN_WPS)
+        return load_remote_skin_backdrop(filename);
+    else if (bdrop == BACKDROP_MAIN)
+        return true;
+    else
+        return false;
+}
+
+void remote_backrop_show(enum backdrop_type bdrop)
+{
+    if (bdrop == BACKDROP_MAIN)
+        show_remote_main_backdrop();
+    else if (bdrop == BACKDROP_SKIN_WPS)
+        show_remote_skin_backdrop();
+}
+
+void remote_backdrop_unload(enum backdrop_type bdrop)
+{
+    if (bdrop != BACKDROP_MAIN)
+        unload_remote_skin_backdrop();
+}
+
+
 #endif
diff --git a/apps/gui/backdrop.h b/apps/gui/backdrop.h
index dc9805f07b..f3ef1d7686 100644
--- a/apps/gui/backdrop.h
+++ b/apps/gui/backdrop.h
@@ -22,27 +22,62 @@
 #ifndef _BACKDROP_H
 #define _BACKDROP_H
 
+enum backdrop_type {
+    BACKDROP_MAIN,
+    BACKDROP_SKIN_WPS,
+};
+
 #if LCD_DEPTH > 1
 
 #include "lcd.h"
 #include "bmp.h"
 
-bool load_main_backdrop(const char* filename);
-bool load_wps_backdrop(const char* filename);
+bool backdrop_load(enum backdrop_type bdrop, const char*);
+void backdrop_unload(enum backdrop_type bdrop);
+void backdrop_show(enum backdrop_type bdrop);
+
+#else /* LCD_DEPTH > 1 */
+
+static inline
+bool backdrop_load(enum backdrop_type bdrop, const char* filename)
+{
+    (void)filename; (void)bdrop; return true;
+}
 
-void unload_main_backdrop(void);
-void unload_wps_backdrop(void);
+static inline void backdrop_unload(enum backdrop_type bdrop)
+{
+    (void)bdrop;
+}
+static inline void backdrop_show(enum backdrop_type bdrop)
+{
+    (void)bdrop;
+}
 
-void show_main_backdrop(void);
-void show_wps_backdrop(void);
+#endif
+
+#if defined(HAVE_REMOTE_LCD)
+/* no main backdrop, stubs! */
+#if LCD_REMOTE_DEPTH > 1
+bool remote_backdrop_load(enum backdrop_type bdrop,const char* filename);
+void remote_backdropunload(enum backdrop_type bdrop);
+void remote_backdrop_show(enum backdrop_type bdrop);
+#else
+static inline
+bool remote_backdrop_load(enum backdrop_type bdrop,const char* filename)
+{
+    (void)filename; (void)bdrop; return true;
+}
 
-#endif /* LCD_DEPTH > 1 */
+static inline void remote_backdrop_unload(enum backdrop_type bdrop)
+{
+    (void)bdrop;
+}
 
-#if defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1
-bool load_remote_wps_backdrop(const char* filename);
-void unload_remote_wps_backdrop(void);
-void show_remote_wps_backdrop(void);
-void show_remote_main_backdrop(void); /* only clears the wps backdrop */
+static inline void remote_backdrop_show(enum backdrop_type bdrop)
+{
+    (void)bdrop;
+}
+#endif
 #endif
 
 #endif /* _BACKDROP_H */
diff --git a/apps/gui/skin_engine/wps_display.c b/apps/gui/skin_engine/wps_display.c
index 98050093c4..6a94c6a946 100644
--- a/apps/gui/skin_engine/wps_display.c
+++ b/apps/gui/skin_engine/wps_display.c
@@ -82,14 +82,7 @@ bool gui_wps_display(struct gui_wps *gwps)
     }
 #endif
     display->clear_display();
-#if defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1
-    if (display->screen_type == SCREEN_REMOTE)
-        show_remote_wps_backdrop();
-    else if (display->screen_type == SCREEN_MAIN)
-#endif
-#if LCD_DEPTH > 1
-        show_wps_backdrop();
-#endif
+    display->backdrop_show(BACKDROP_SKIN_WPS);
     return gui_wps_redraw(gwps, WPS_REFRESH_ALL);
 }
 
diff --git a/apps/gui/skin_engine/wps_parser.c b/apps/gui/skin_engine/wps_parser.c
index 1a903c98ec..c37cd786ec 100644
--- a/apps/gui/skin_engine/wps_parser.c
+++ b/apps/gui/skin_engine/wps_parser.c
@@ -1635,26 +1635,15 @@ static bool load_wps_bitmaps(struct wps_data *wps_data, char *bmpdir)
 #if (LCD_DEPTH > 1) || (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1))
     if (bmp_names[BACKDROP_BMP])
     {
+        int screen = SCREEN_MAIN;
         get_image_filename(bmp_names[BACKDROP_BMP], bmpdir,
                             img_path, sizeof(img_path));
-
 #if defined(HAVE_REMOTE_LCD)
         /* We only need to check LCD type if there is a remote LCD */
-        if (!wps_data->remote_wps)
-#endif
-        {
-            /* Load backdrop for the main LCD */
-            if (!load_wps_backdrop(img_path))
-                return false;
-        }
-#if defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1
-        else 
-        {      
-            /* Load backdrop for the remote LCD */
-            if (!load_remote_wps_backdrop(img_path))
-                return false;
-        }
+        if (wps_data->remote_wps)
+            screen = SCREEN_REMOTE;
 #endif
+        screens[screen].backdrop_load(BACKDROP_SKIN_WPS, img_path);
     }
 #endif /* has backdrop support */
 
diff --git a/apps/gui/wps.c b/apps/gui/wps.c
index bce4db2b8a..bbf169ff96 100644
--- a/apps/gui/wps.c
+++ b/apps/gui/wps.c
@@ -92,7 +92,8 @@ static void nextid3available_callback(void* param);
 
 void wps_data_load(enum screen_type screen, const char *buf, bool isfile)
 {
-    bool loaded_ok = buf && skin_data_load(gui_wps[screen].data, &screens[screen], buf, isfile);
+    bool loaded_ok = buf && skin_data_load(gui_wps[screen].data,
+                                            &screens[screen], buf, isfile);
     if (!loaded_ok) /* load the hardcoded default */
     {
         char *skin_buf[NB_SCREENS] = {
@@ -115,24 +116,9 @@ void wps_data_load(enum screen_type screen, const char *buf, bool isfile)
             "%pb\n",
 #endif
         };
+        screens[screen].backdrop_unload(BACKDROP_SKIN_WPS);
         skin_data_load(gui_wps[screen].data, &screens[screen],
                         skin_buf[screen], false);
-        /* set the default wps for the main-screen */
-        if(screen == SCREEN_MAIN)
-        {
-#if LCD_DEPTH > 1
-            unload_wps_backdrop();
-#endif
-        }
-#ifdef HAVE_REMOTE_LCD
-        /* set the default wps for the remote-screen */
-        else if(screen == SCREEN_REMOTE)
-        {
-#if LCD_REMOTE_DEPTH > 1
-            unload_remote_wps_backdrop();
-#endif
-        }
-#endif
     }
 #ifdef HAVE_REMOVE_LCD
     gui_wps[screen].data->remote_wps = !(screen == SCREEN_MAIN);
@@ -564,16 +550,13 @@ static void gwps_leave_wps(void)
     int i, oldbars = VP_SB_HIDE_ALL;
 
     FOR_NB_SCREENS(i)
+    {
         gui_wps[i].display->stop_scroll();
+        gui_wps[i].display->backdrop_show(BACKDROP_MAIN);
+    }
     if (global_settings.statusbar)
         oldbars = VP_SB_ALLSCREENS;
 
-#if LCD_DEPTH > 1
-    show_main_backdrop();
-#endif
-#if defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1
-    show_remote_main_backdrop();
-#endif
     viewportmanager_set_statusbar(oldbars);
 #if defined(HAVE_LCD_ENABLE) || defined(HAVE_LCD_SLEEP)
     /* Play safe and unregister the hook */
@@ -1237,23 +1220,18 @@ void gui_sync_wps_init(void)
         wps_datas[i].wps_uses_albumart = 0;
 #endif
 #ifdef HAVE_REMOTE_LCD
-        wps_datas[i].remote_wps = (i != 0);
+        wps_datas[i].remote_wps = (i == SCREEN_REMOTE);
 #endif
         gui_wps[i].data = &wps_datas[i];
         gui_wps[i].display = &screens[i];
         /* Currently no seperate wps_state needed/possible
            so use the only available ( "global" ) one */
         gui_wps[i].state = &wps_state;
+        gui_wps[i].display->backdrop_unload(BACKDROP_SKIN_WPS);
     }
 #ifdef HAVE_LCD_BITMAP
     add_event(GUI_EVENT_STATUSBAR_TOGGLE, false, statusbar_toggle_handler);
 #endif
-#if LCD_DEPTH > 1
-    unload_wps_backdrop();
-#endif
-#if defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1
-    unload_remote_wps_backdrop();
-#endif
 }
 
 #ifdef HAVE_ALBUMART