Index: apps/lang/english.lang
===================================================================
--- apps/lang/english.lang	(revision 19998)
+++ apps/lang/english.lang	(working copy)
@@ -12166,19 +12166,19 @@
 </phrase>
 <phrase>
   id: LANG_ALBUMART
-  desc: Display the expected AA size
+  desc: deprecated
   user:
   <source>
     *: none
-    albumart: "Album Art:"
+    albumart: ""
   </source>
   <dest>
     *: none
-    albumart: "Album Art:"
+    albumart: ""
   </dest>
   <voice>
     *: none
-    albumart: "Album Art:"
+    albumart: ""
   </voice>
 </phrase>
 <phrase>
@@ -12359,3 +12359,17 @@
     *: "Credits"
   </voice>
 </phrase>
+<phrase>
+  id: LANG_WPS_RAM_USAGE
+  desc: in the info screen, display amount of bytes used by WPS
+  user:
+  <source>
+    *: "WPS RAM Usage:"
+  </source>
+  <dest>
+    *: "WPS RAM Usage:"
+  </dest>
+  <voice>
+    *: "WPS RAM Usage"
+  </voice>
+</phrase>
Index: apps/settings.c
===================================================================
--- apps/settings.c	(revision 19998)
+++ apps/settings.c	(working copy)
@@ -834,6 +834,11 @@
 #if defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1
         unload_remote_wps_backdrop();
 #endif
+        
+        wps_buffer_init(); /* reinitialise the wps buffer here instead of in
+                            * wps_data_load() to protect it when there is 
+                            * more than one screen... This does mean that there
+                            * will be waste if you just load a .wps file */
         if ( global_settings.wps_file[0] &&
             global_settings.wps_file[0] != 0xff ) {
             snprintf(buf, sizeof buf, WPS_DIR "/%s.wps",
Index: apps/gui/wps/wps_buffer.c
===================================================================
--- apps/gui/wps/wps_buffer.c	(revision 0)
+++ apps/gui/wps/wps_buffer.c	(revision 0)
@@ -0,0 +1,90 @@
+/***************************************************************************
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
+ * $Id: wps_parser.c 19880 2009-01-29 20:49:43Z mcuelenaere $
+ *
+ * Copyright (C) 2002 by Linus Nielsen Feltzing
+ * Copyright (C) 2009 Jonathan Gordon
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include "config.h"
+#include "buffer.h"
+#include "settings.h"
+
+/* WPS buffer management.
+ * This module is used to allocate space in a single global WPS buffer for
+ * tokens for both/all screens.
+ * 
+ * This is mostly just copy/paste from firmware/buffer.c
+ */
+
+static unsigned char *buffer_start = NULL, *buffer_pos = NULL;
+static size_t buf_size;
+#define IMG_BUFSIZE ((LCD_HEIGHT*LCD_WIDTH*LCD_DEPTH/8) \
+                  + (2*LCD_HEIGHT*LCD_WIDTH/8))
+void wps_buffer_init(void)
+{
+    if (buffer_start == NULL)
+    {
+        /* WAY more than needed but sensible untill configurable */
+        buf_size = IMG_BUFSIZE;/* global_settings.wps_buf_size */
+            
+        buffer_start = buffer_alloc(buf_size);
+        buffer_pos = buffer_start;
+    }
+    else
+    {
+        /* reset the buffer.... */
+        buffer_pos = buffer_start;
+    }
+}
+
+/* get the number of bytes currently being used */
+size_t wps_buffer_usage(void)
+{
+    return buffer_pos-buffer_start;
+}
+
+/* Allocate size bytes from the buffer */
+void* wps_buffer_alloc(size_t size)
+{
+    void* retval = buffer_pos;
+    if (wps_buffer_usage()+size >= buf_size)
+    {
+        return NULL;
+    }
+    buffer_pos += size;
+    /* 32-bit aligned */
+    buffer_pos = (void *)(((unsigned long)buffer_pos + 3) & ~3);
+    return retval;
+}
+
+void* wps_buffer_grab(size_t *freespace)
+{
+    *freespace = buf_size - wps_buffer_usage();
+    return buffer_pos;
+}
+
+void wps_buffer_increment(size_t used)
+{
+    buffer_pos += used;
+    /* 32-bit aligned */
+    buffer_pos = (void *)(((unsigned long)buffer_pos + 3) & ~3);
+}
+
Index: apps/gui/gwps-common.c
===================================================================
--- apps/gui/gwps-common.c	(revision 19998)
+++ apps/gui/gwps-common.c	(working copy)
@@ -331,8 +331,12 @@
 #if LCD_DEPTH > 1
             if (gui_wps[i].display->depth > 1)
             {
-                gui_wps[i].data->viewports[0].vp.fg_pattern = gui_wps[i].display->get_foreground();
-                gui_wps[i].data->viewports[0].vp.bg_pattern = gui_wps[i].display->get_background();
+                struct wps_viewport *vp = find_viewport(gui_wps[i].data, '\0');
+                if (vp)
+                {
+                    vp->vp.fg_pattern = gui_wps[i].display->get_foreground();
+                    vp->vp.bg_pattern = gui_wps[i].display->get_background();
+                }
             }
 #endif
 #endif
@@ -504,15 +508,40 @@
                          pb->x, pb->x + pb->width, pb->y+1, pb->height-2);
 }
 
+struct gui_img* find_img(struct wps_data *wps_data, char id)
+{
+    struct wpsll *llitem = wps_data->images;
+    struct gui_img *img;
+    for(llitem = wps_data->images; llitem; llitem = llitem->next)
+    {
+        img = (struct gui_img *)llitem->token->value.data;
+        if (img->id == id)
+            return img;
+    }
+    return NULL;
+} 
+struct wps_viewport* find_viewport(struct wps_data *wps_data, char id)
+{
+    struct wpsll *llitem = wps_data->viewports;
+    struct wps_viewport *vp;
+    for(llitem = wps_data->viewports; llitem; llitem = llitem->next)
+    {
+        vp = (struct wps_viewport *)llitem->token->value.data;
+        if (vp->label == id)
+            return vp;
+    }
+    return NULL;
+}
 /* clears the area where the image was shown */
 static void clear_image_pos(struct gui_wps *gwps, int n)
 {
     if(!gwps)
         return;
     struct wps_data *data = gwps->data;
+    struct gui_img *img = find_img(data, n);
     gwps->display->set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
-    gwps->display->fillrect(data->img[n].x, data->img[n].y,
-                            data->img[n].bm.width, data->img[n].subimage_height);
+    gwps->display->fillrect(img->x, img->y,
+                            img->bm.width, img->subimage_height);
     gwps->display->set_drawmode(DRMODE_SOLID);
 }
 
@@ -520,26 +549,27 @@
 {
     struct screen *display = gwps->display;
     struct wps_data *data = gwps->data;
-    if(data->img[n].always_display)
+    struct gui_img *img = find_img(data, n);
+    if(img->always_display)
         display->set_drawmode(DRMODE_FG);
     else
         display->set_drawmode(DRMODE_SOLID);
 
 #if LCD_DEPTH > 1
-    if(data->img[n].bm.format == FORMAT_MONO) {
+    if(img->bm.format == FORMAT_MONO) {
 #endif
-        display->mono_bitmap_part(data->img[n].bm.data, 
-                                  0, data->img[n].subimage_height * subimage,
-                                  data->img[n].bm.width, data->img[n].x,
-                                  data->img[n].y, data->img[n].bm.width,
-                                  data->img[n].subimage_height);
+        display->mono_bitmap_part(img->bm.data, 
+                                  0, img->subimage_height * subimage,
+                                  img->bm.width, img->x,
+                                  img->y, img->bm.width,
+                                  img->subimage_height);
 #if LCD_DEPTH > 1
     } else {
-        display->transparent_bitmap_part((fb_data *)data->img[n].bm.data,
-                                         0, data->img[n].subimage_height * subimage,
-                                         data->img[n].bm.width, data->img[n].x,
-                                         data->img[n].y, data->img[n].bm.width,
-                                         data->img[n].subimage_height);
+        display->transparent_bitmap_part((fb_data *)img->bm.data,
+                                         0, img->subimage_height * subimage,
+                                         img->bm.width, img->x,
+                                         img->y, img->bm.width,
+                                         img->subimage_height);
     }
 #endif
 }
@@ -549,20 +579,20 @@
     if(!gwps || !gwps->data || !gwps->display)
         return;
 
-    int n;
     struct wps_data *data = gwps->data;
     struct screen *display = gwps->display;
-
-    for (n = 0; n < MAX_IMAGES; n++)
+    struct wpsll *llitem;
+    for ( llitem = data->images; llitem; llitem = llitem->next)
     {
-        if (data->img[n].loaded)
+        struct gui_img *img = (struct gui_img*)llitem->token->value.data;
+        if (img->loaded)
         {
-            if (data->img[n].display >= 0)
+            if (img->display >= 0)
             {
-                wps_draw_image(gwps, n, data->img[n].display);
-            } else if (data->img[n].always_display && data->img[n].vp == vp)
+                wps_draw_image(gwps, img->id, img->display);
+            } else if (img->always_display && img->vp == vp)
             {
-                wps_draw_image(gwps, n, 0);
+                wps_draw_image(gwps, img->id, 0);
             }
         }
     }
@@ -804,7 +834,7 @@
             return &(token->value.c);
 
         case WPS_TOKEN_STRING:
-            return data->strings[token->value.i];
+            return token->value.data;
 
         case WPS_TOKEN_TRACK_TIME_ELAPSED:
             format_time(buf, buf_size,
@@ -1558,12 +1588,12 @@
 #ifdef HAVE_LCD_BITMAP
             case WPS_TOKEN_IMAGE_PRELOAD_DISPLAY:
             {
-                struct gui_img *img = data->img;
                 int n = data->tokens[i].value.i & 0xFF;
+                struct gui_img *img = find_img(data, n);
                 int subimage = data->tokens[i].value.i >> 8;
 
-                if (n >= 0 && n < MAX_IMAGES && img[n].loaded)
-                    img[n].display = subimage;
+                if (img->loaded)
+                    img->display = subimage;
                 break;
             }
 #endif
@@ -1606,20 +1636,11 @@
                 break;
             case WPS_VIEWPORT_ENABLE:
             {
-                char label = data->tokens[i].value.i;
-                int j;
+                struct wps_viewport *thisvp = data->tokens[i].value.data;
                 char temp = VP_DRAW_HIDEABLE;
-                for(j=0;j<data->num_viewports;j++)
-                {
-                    temp = VP_DRAW_HIDEABLE;
-                    if ((data->viewports[j].hidden_flags&VP_DRAW_HIDEABLE) &&
-                        (data->viewports[j].label == label))
-                    {
-                        if (data->viewports[j].hidden_flags&VP_DRAW_WASHIDDEN)
-                            temp |= VP_DRAW_WASHIDDEN;
-                        data->viewports[j].hidden_flags = temp;
-                    }
-                }
+                if (thisvp->hidden_flags&VP_DRAW_WASHIDDEN)
+                    temp |= VP_DRAW_WASHIDDEN;
+                thisvp->hidden_flags = temp;
             }
                 break;
             default:
@@ -1942,7 +1963,7 @@
     if(!gwps || !data || !state || !display)
         return false;
 
-    int v, line, i, subline_idx;
+    int line, i, subline_idx;
     unsigned char flags;
     char linebuf[MAX_PATH];
     unsigned char vp_refresh_mode;
@@ -1970,7 +1991,8 @@
     /* reset to first subline if refresh all flag is set */
     if (refresh_mode == WPS_REFRESH_ALL)
     {
-        display->set_viewport(&data->viewports[0].vp);
+        struct wps_viewport *wvp = find_viewport(data, '\0');
+        display->set_viewport(&wvp->vp);
         display->clear_viewport();
 
         for (i = 0; i <= data->num_lines; i++)
@@ -1996,50 +2018,55 @@
     state->ff_rewind_count = ffwd_offset;
 
     /* disable any viewports which are conditionally displayed */
-    for (v = 0; v < data->num_viewports; v++)
+    struct wpsll *viewportll;
+    for(viewportll=data->viewports; viewportll; viewportll = viewportll->next)
     {
-        if (data->viewports[v].hidden_flags&VP_DRAW_HIDEABLE)
+        struct wps_viewport *wvp = viewportll->token->value.data;
+        if (wvp->hidden_flags&VP_DRAW_HIDEABLE)
         {
-            if (data->viewports[v].hidden_flags&VP_DRAW_HIDDEN)
-                data->viewports[v].hidden_flags |= VP_DRAW_WASHIDDEN;
+            if (wvp->hidden_flags&VP_DRAW_HIDDEN)
+                wvp->hidden_flags |= VP_DRAW_WASHIDDEN;
             else
-                data->viewports[v].hidden_flags |= VP_DRAW_HIDDEN;
+                wvp->hidden_flags |= VP_DRAW_HIDDEN;
         }
     }
-    for (v = 0; v < data->num_viewports; v++)
+    for(viewportll=data->viewports; viewportll; viewportll = viewportll->next)
     {
-        display->set_viewport(&data->viewports[v].vp);
+        struct wps_viewport *wvp = viewportll->token->value.data;
+        display->set_viewport(&wvp->vp);
         vp_refresh_mode = refresh_mode;
 
 #ifdef HAVE_LCD_BITMAP
         /* Set images to not to be displayed */
-        for (i = 0; i < MAX_IMAGES; i++)
+        struct wpsll *llitem;
+        for ( llitem = data->images; llitem; llitem = llitem->next)
         {
-            data->img[i].display = -1;
+            struct gui_img *img = (struct gui_img*)llitem->token->value.data;
+            img->display = -1;
         }
 #endif
         /* dont redraw the viewport if its disabled */
-        if ((data->viewports[v].hidden_flags&VP_DRAW_HIDDEN))
+        if ((wvp->hidden_flags&VP_DRAW_HIDDEN))
         {
-            if (!(data->viewports[v].hidden_flags&VP_DRAW_WASHIDDEN))
-                display->scroll_stop(&data->viewports[v].vp);
-            data->viewports[v].hidden_flags |= VP_DRAW_WASHIDDEN;
+            if (!(wvp->hidden_flags&VP_DRAW_WASHIDDEN))
+                display->scroll_stop(&wvp->vp);
+            wvp->hidden_flags |= VP_DRAW_WASHIDDEN;
             continue;
         }
-        else if (((data->viewports[v].hidden_flags&
+        else if (((wvp->hidden_flags&
                    (VP_DRAW_WASHIDDEN|VP_DRAW_HIDEABLE))
                     == (VP_DRAW_WASHIDDEN|VP_DRAW_HIDEABLE)))
         {
             vp_refresh_mode = WPS_REFRESH_ALL;
-            data->viewports[v].hidden_flags = VP_DRAW_HIDEABLE;
+            wvp->hidden_flags = VP_DRAW_HIDEABLE;
         }
         if (vp_refresh_mode == WPS_REFRESH_ALL)
         {
             display->clear_viewport();
         }
             
-        for (line = data->viewports[v].first_line; 
-             line <= data->viewports[v].last_line; line++)
+        for (line = wvp->first_line; 
+             line <= wvp->last_line; line++)
         {
             memset(linebuf, 0, sizeof(linebuf));
             update_line = false;
@@ -2065,8 +2092,8 @@
                 /* the peakmeter should be alone on its line */
                 update_line = false;
 
-                int h = font_get(data->viewports[v].vp.font)->height;
-                int peak_meter_y = (line - data->viewports[v].first_line)* h;
+                int h = font_get(wvp->vp.font)->height;
+                int peak_meter_y = (line - wvp->first_line)* h;
 
                 /* The user might decide to have the peak meter in the last
                     line so that it is only displayed if no status bar is
@@ -2103,17 +2130,17 @@
                    viewport there will be a blank line.
                    To get around this we dont allow any actual drawing to happen in the
                    deault vp if other vp's are defined */
-                ((data->num_viewports>1 && v!=0) || data->num_viewports == 1))
+                ((viewportll->next && wvp->label!='\0') || !viewportll->next))
             {
                 if (flags & WPS_REFRESH_SCROLL)
                 {
                     /* if the line is a scrolling one we don't want to update
                        too often, so that it has the time to scroll */
                     if ((vp_refresh_mode & WPS_REFRESH_SCROLL) || new_subline_refresh)
-                        write_line(display, &align, line - data->viewports[v].first_line, true);
+                        write_line(display, &align, line - wvp->first_line, true);
                 }
                 else
-                    write_line(display, &align, line - data->viewports[v].first_line, false);
+                    write_line(display, &align, line - wvp->first_line, false);
             }
         }
 
@@ -2121,11 +2148,11 @@
         /* progressbar */
         if (vp_refresh_mode & WPS_REFRESH_PLAYER_PROGRESS)
         {
-            if (data->viewports[v].pb)
-                draw_progressbar(gwps, data->viewports[v].pb);
+            if (wvp->pb)
+                draw_progressbar(gwps, wvp->pb);
         }
         /* Now display any images in this viewport */
-        wps_display_images(gwps, &data->viewports[v].vp);
+        wps_display_images(gwps, &wvp->vp);
 #endif
     }
 
Index: apps/gui/wps_debug.c
===================================================================
--- apps/gui/wps_debug.c	(revision 19998)
+++ apps/gui/wps_debug.c	(working copy)
@@ -43,7 +43,7 @@
     return next ? "next " : "";
 }
 
-static char *get_token_desc(struct wps_token *token, struct wps_data *data,
+static char *get_token_desc(struct wps_token *token,
                             char *buf, int bufsize)
 {
     bool next = token->next;
@@ -65,7 +65,7 @@
 
         case WPS_TOKEN_STRING:
             snprintf(buf, bufsize, "String '%s'",
-                     data->strings[token->value.i]);
+                     token->value.data);
             break;
 
 #ifdef HAVE_LCD_BITMAP
@@ -456,7 +456,7 @@
     /* Dump parsed WPS */
     for (i = 0, token = data->tokens; i < data->num_tokens; i++, token++)
     {
-        get_token_desc(token, data, buf, sizeof(buf));
+        get_token_desc(token, buf, sizeof(buf));
 
         switch(token->type)
         {
@@ -502,26 +502,30 @@
 
     if (wps_verbose_level > 0)
     {
-        DEBUGF("Number of viewports : %d\n", data->num_viewports);
-        for (v = 0; v < data->num_viewports; v++)
+        struct wpsll *ll;
+        for (v=0, ll=data->viewports; ll; ll = ll->next, v++)
         {
-            DEBUGF("vp %d: First line: %d\n", v, data->viewports[v].first_line);
-            DEBUGF("vp %d: Last line: %d\n", v, data->viewports[v].last_line);
+            struct wps_viewport *vp = ll->token->value.data;
+            DEBUGF("vp %d: First line: %d\n", v, vp->first_line);
+            DEBUGF("vp %d: Last line: %d\n", v, vp->last_line);
         }
         DEBUGF("Number of sublines  : %d\n", data->num_sublines);
         DEBUGF("Number of tokens    : %d\n", data->num_tokens);
+        DEBUGF("Buffer Usage: %ld\n", wps_buffer_usage());
         DEBUGF("\n");
     }
 
     if (wps_verbose_level > 1)
     {
-        for (v = 0; v < data->num_viewports; v++)
+        struct wpsll *ll;
+        for (v=0, ll=data->viewports; ll; ll = ll->next, v++)
         {
-            DEBUGF("Viewport %d - +%d+%d (%dx%d)\n",v,data->viewports[v].vp.x, 
-                                                      data->viewports[v].vp.y,
-                                                      data->viewports[v].vp.width,
-                                                      data->viewports[v].vp.height);
-            for (i = data->viewports[v].first_line, line = &data->lines[data->viewports[v].first_line]; i <= data->viewports[v].last_line; i++,line++)
+            struct wps_viewport *vp = ll->token->value.data;
+            DEBUGF("Viewport %d - +%d+%d (%dx%d)\n",v,vp->vp.x, 
+                                                      vp->vp.y,
+                                                      vp->vp.width,
+                                                      vp->vp.height);
+            for (i = vp->first_line, line = &data->lines[vp->first_line]; i <= vp->last_line; i++,line++)
             {
                 DEBUGF("Line %2d (num_sublines=%d, first_subline=%d)\n",
                        i, line->num_sublines, line->first_subline_idx);
@@ -544,36 +548,12 @@
                 }
             }
         }
+        DEBUGF("Buffer Usage (pre image loading): %ld\n", wps_buffer_usage());
 
         DEBUGF("\n");
     }
 }
 
-static void print_wps_strings(struct wps_data *data)
-{
-    int i, len, total_len = 0, buf_used = 0;
-
-    if (wps_verbose_level > 1) DEBUGF("Strings:\n");
-    for (i = 0; i < data->num_strings; i++)
-    {
-        len = strlen(data->strings[i]);
-        total_len += len;
-        buf_used += len + 1;
-        if (wps_verbose_level > 1)
-            DEBUGF("%2d: (%2d) '%s'\n", i, len, data->strings[i]);
-    }
-    if (wps_verbose_level > 1) DEBUGF("\n");
-
-    if (wps_verbose_level > 0)
-    {
-        DEBUGF("Number of unique strings: %d (max: %d)\n",
-               data->num_strings, WPS_MAX_STRINGS);
-        DEBUGF("Total string length: %d\n", total_len);
-        DEBUGF("String buffer used: %d out of %d bytes\n",
-               buf_used, STRING_BUFFER_SIZE);
-        DEBUGF("\n");
-    }
-}
 #endif
 
 void print_debug_info(struct wps_data *data, enum wps_parse_error fail, int line)
@@ -582,7 +562,6 @@
     if (debug_wps && wps_verbose_level)
     {
         dump_wps_tokens(data);
-        print_wps_strings(data);
         print_line_info(data);
     }
 #endif /* SIMULATOR */
@@ -609,7 +588,7 @@
             case PARSE_FAIL_INVALID_CHAR:
                 DEBUGF("ERR: Unexpected conditional char after token %d: \"%s\"",
                        data->num_tokens-1,
-                       get_token_desc(&data->tokens[data->num_tokens-1], data,
+                       get_token_desc(&data->tokens[data->num_tokens-1],
                                       buf, sizeof(buf))
                       );
                 break;
@@ -617,7 +596,7 @@
             case PARSE_FAIL_COND_SYNTAX_ERROR:
                 DEBUGF("ERR: Conditional syntax error after token %d: \"%s\"",
                        data->num_tokens-1,
-                       get_token_desc(&data->tokens[data->num_tokens-1], data,
+                       get_token_desc(&data->tokens[data->num_tokens-1],
                                       buf, sizeof(buf))
                       );
                 break;
@@ -625,7 +604,7 @@
             case PARSE_FAIL_COND_INVALID_PARAM:
                 DEBUGF("ERR: Invalid parameter list for token %d: \"%s\"",
                        data->num_tokens,
-                       get_token_desc(&data->tokens[data->num_tokens], data,
+                       get_token_desc(&data->tokens[data->num_tokens],
                                       buf, sizeof(buf))
                       );
                 break;
Index: apps/gui/gwps.c
===================================================================
--- apps/gui/gwps.c	(revision 19998)
+++ apps/gui/gwps.c	(working copy)
@@ -758,7 +758,7 @@
 
     FOR_NB_SCREENS(i)
     {
-        struct wps_viewport *vp = &gui_wps[i].data->viewports[0];
+        struct wps_viewport *vp = find_viewport(gui_wps[i].data, '\0');
         if (gui_wps[i].data->wps_sb_tag)
             draw = gui_wps[i].data->show_sb_on_wps;
         if (!draw)
Index: apps/gui/gwps.h
===================================================================
--- apps/gui/gwps.h	(revision 19998)
+++ apps/gui/gwps.h	(working copy)
@@ -56,9 +56,28 @@
 #endif /* HAVE_ALBUMART */
 
 /* wps_data*/
+struct wps_token {
+    unsigned char type; /* enough to store the token type */
 
+    /* Whether the tag (e.g. track name or the album) refers the
+       current or the next song (false=current, true=next) */
+    bool next;
+
+    union {
+        char c;
+        unsigned int i;
+        void *data; /* pointer into global wps buffer */
+    } value;
+};
+
+struct wpsll {
+    struct wps_token *token;
+    struct wpsll *next;
+};
+
 #ifdef HAVE_LCD_BITMAP
 struct gui_img{
+    short id;
     struct bitmap bm;
     struct viewport* vp;    /* The viewport to display this image in */
     short int x;                  /* x-pos */
@@ -90,31 +109,16 @@
 
 #ifdef HAVE_LCD_BITMAP
 
-#define MAX_IMAGES (26*2) /* a-z and A-Z */
-#define MAX_PROGRESSBARS 3
-
-/* The image buffer is big enough to store one full-screen native bitmap,
-   plus two full-screen mono bitmaps. */
-
-#define IMG_BUFSIZE ((LCD_HEIGHT*LCD_WIDTH*LCD_DEPTH/8) \
-                   + (2*LCD_HEIGHT*LCD_WIDTH/8))
-
-#define WPS_MAX_VIEWPORTS   24
 #define WPS_MAX_LINES       ((LCD_HEIGHT/5+1) * 2)
 #define WPS_MAX_SUBLINES    (WPS_MAX_LINES*3)
 #define WPS_MAX_TOKENS      1024
-#define WPS_MAX_STRINGS     128
-#define STRING_BUFFER_SIZE  1024
 #define WPS_MAX_COND_LEVEL  10
 
 #else
 
-#define WPS_MAX_VIEWPORTS   2
 #define WPS_MAX_LINES       2
 #define WPS_MAX_SUBLINES    12
 #define WPS_MAX_TOKENS      64
-#define WPS_MAX_STRINGS     32
-#define STRING_BUFFER_SIZE  64
 #define WPS_MAX_COND_LEVEL  5
 
 #endif
@@ -296,19 +300,8 @@
     WPS_TOKEN_SETTING,
 };
 
-struct wps_token {
-    unsigned char type; /* enough to store the token type */
 
-    /* Whether the tag (e.g. track name or the album) refers the
-       current or the next song (false=current, true=next) */
-    bool next;
 
-    union {
-        char c;
-        unsigned short i;
-    } value;
-};
-
 /* Description of a subline on the WPS */
 struct wps_subline {
 
@@ -347,6 +340,8 @@
 #define VP_DRAW_HIDEABLE 0x1
 #define VP_DRAW_HIDDEN   0x2
 #define VP_DRAW_WASHIDDEN  0x4
+#define DEFAULT_VP_LBL  '\0'
+#define STATIC_VP_LBL  '|'
 struct wps_viewport {
     struct viewport vp;   /* The LCD viewport struct */
     struct progressbar *pb;
@@ -363,16 +358,14 @@
 struct wps_data
 {
 #ifdef HAVE_LCD_BITMAP
-    struct gui_img img[MAX_IMAGES];
-    unsigned char img_buf[IMG_BUFSIZE];
-    unsigned char* img_buf_ptr;
-    int img_buf_free;
     bool wps_sb_tag;
     bool show_sb_on_wps;
 
-    struct progressbar progressbar[MAX_PROGRESSBARS];
-    short progressbar_count;
+    struct wpsll *images;
+    struct wpsll *progressbars;
     
+    struct wps_token *backdrop;
+    
     bool peak_meter_enabled;
 
 #ifdef HAVE_ALBUMART
@@ -401,9 +394,7 @@
        the index of the line being parsed. */
     int num_lines;
 
-    /* Number of viewports in the WPS */
-    int num_viewports;
-    struct wps_viewport viewports[WPS_MAX_VIEWPORTS];
+    struct wpsll *viewports;
 
     struct wps_line lines[WPS_MAX_LINES];
 
@@ -417,10 +408,8 @@
     int num_tokens;
     struct wps_token tokens[WPS_MAX_TOKENS];
 
-    char string_buffer[STRING_BUFFER_SIZE];
-    char *strings[WPS_MAX_STRINGS];
-    int num_strings;
-
+    struct wpsll *strings;
+    
     bool wps_loaded;
     
     /* tick the volume button was last pressed */
@@ -507,4 +496,16 @@
 bool gui_sync_wps_uses_albumart(void);
 #endif
 
+
+struct gui_img* find_img(struct wps_data *wps_data, char id); /* in gwps-common.c */
+struct wps_viewport* find_viewport(struct wps_data *wps_data, char id);
+
+/* wps_buffer functions */
+
+void wps_buffer_init(void);
+void* wps_buffer_alloc(size_t size);
+void* wps_buffer_grab(size_t *freespace);
+void wps_buffer_increment(size_t used);
+size_t wps_buffer_usage(void);
+
 #endif
Index: apps/gui/wps_parser.c
===================================================================
--- apps/gui/wps_parser.c	(revision 19998)
+++ apps/gui/wps_parser.c	(working copy)
@@ -79,22 +79,9 @@
 /* the current line in the file */
 static int line;
 
-#ifdef HAVE_LCD_BITMAP
+/* the current viewport */
+static struct wps_viewport *curr_vp;
 
-#if LCD_DEPTH > 1
-#define MAX_BITMAPS (MAX_IMAGES+MAX_PROGRESSBARS+1) /* WPS images + pbar bitmap + backdrop */
-#else
-#define MAX_BITMAPS (MAX_IMAGES+MAX_PROGRESSBARS) /* WPS images + pbar bitmap */
-#endif
-
-#define PROGRESSBAR_BMP MAX_IMAGES
-#define BACKDROP_BMP    (MAX_BITMAPS-1)
-
-/* pointers to the bitmap filenames in the WPS source */
-static const char *bmp_names[MAX_BITMAPS];
-
-#endif /* HAVE_LCD_BITMAP */
-
 #if defined(DEBUG) || defined(SIMULATOR)
 /* debugging function */
 extern void print_debug_info(struct wps_data *data, int fail, int line);
@@ -342,6 +329,34 @@
     /* the array MUST end with an empty string (first char is \0) */
 };
 
+/* add a wpsll item to the list chain. ALWAYS appended because some of the 
+ * chains require the order to be kept.
+ */
+static void add_to_ll_chain(struct wpsll **list, struct wpsll *item)
+{
+    if (*list == NULL)
+        *list = item;
+    else
+    {
+        struct wpsll *t = *list;
+        while (t->next)
+            t = t->next;
+        t->next = item;    
+    }
+}     
+/* create and init a new wpsll item.
+ * passing NULL to token will alloc a new one.
+ */
+static struct wpsll *new_wpsll_item(struct wps_token *token)
+{
+    struct wpsll *llitem = wps_buffer_alloc(sizeof(struct wpsll));
+    if (!token)
+        token = wps_buffer_alloc(sizeof(struct wps_token));
+    llitem->next = NULL;
+    llitem->token = token;
+    return llitem;
+}    
+    
 /* Returns the number of chars that should be skipped to jump
    immediately after the first eol, i.e. to the start of the next line */
 static int skip_end_of_line(const char *wps_bufptr)
@@ -368,12 +383,13 @@
                                   struct wps_data *wps_data)
 {
     (void)token; /* Kill warnings */
+    struct wps_viewport *vp = find_viewport(wps_data, '\0');
     wps_data->wps_sb_tag = true;
     wps_data->show_sb_on_wps = true;
-    if (wps_data->viewports[0].vp.y == 0)
+    if (vp->vp.y == 0)
     {
-        wps_data->viewports[0].vp.y = STATUSBAR_HEIGHT;
-        wps_data->viewports[0].vp.height -= STATUSBAR_HEIGHT;
+        vp->vp.y = STATUSBAR_HEIGHT;
+        vp->vp.height -= STATUSBAR_HEIGHT;
     }
     return skip_end_of_line(wps_bufptr);
 }
@@ -383,12 +399,13 @@
                                    struct wps_data *wps_data)
 {
     (void)token; /* Kill warnings */
+    struct wps_viewport *vp = find_viewport(wps_data, '\0');
     wps_data->wps_sb_tag = true;
     wps_data->show_sb_on_wps = false;
-    if (wps_data->viewports[0].vp.y == STATUSBAR_HEIGHT)
+    if (vp->vp.y == STATUSBAR_HEIGHT)
     {
-        wps_data->viewports[0].vp.y = 0;
-        wps_data->viewports[0].vp.height += STATUSBAR_HEIGHT;
+        vp->vp.y = 0;
+        vp->vp.height += STATUSBAR_HEIGHT;
     }
     return skip_end_of_line(wps_bufptr);
 }
@@ -397,16 +414,19 @@
                         char* filename,
                         struct bitmap *bm)
 {
+    (void)wps_data;
     int format;
+    size_t bm_space_avilable;
 #ifdef HAVE_REMOTE_LCD
     if (wps_data->remote_wps)
         format = FORMAT_ANY|FORMAT_REMOTE;
     else
 #endif
         format = FORMAT_ANY|FORMAT_TRANSPARENT;
-
+    bm->data = wps_buffer_grab(&bm_space_avilable);
+    
     int ret = read_bmp_file(filename, bm,
-                            wps_data->img_buf_free,
+                            bm_space_avilable,
                             format,NULL);
 
     if (ret > 0)
@@ -415,8 +435,8 @@
         if (ret % 2) ret++;
         /* Always consume an even number of bytes */
 #endif
-        wps_data->img_buf_ptr += ret;
-        wps_data->img_buf_free -= ret;
+        /* let the buffer manager know how much we used */
+        wps_buffer_increment(ret);
 
         return true;
     }
@@ -459,11 +479,11 @@
                                struct wps_token *token,
                                struct wps_data *wps_data)
 {
-    (void)wps_data;
-    int n = get_image_id(wps_bufptr[0]);
+    int n = (wps_bufptr[0]);
+    struct gui_img *img = find_img(wps_data, n);
     int subimage;
 
-    if (n == -1)
+    if (n == -1 || !img)
     {
         /* invalid picture display tag */
         return WPS_ERROR_INVALID_PARAM;
@@ -472,7 +492,7 @@
     if ((subimage = get_image_id(wps_bufptr[1])) != -1)
     {
         /* Sanity check */
-        if (subimage >= wps_data->img[n].num_subimages)
+        if (subimage >= img->num_subimages)
             return WPS_ERROR_INVALID_PARAM;
 
         /* Store sub-image number to display in high bits */
@@ -488,19 +508,20 @@
                             struct wps_token *token,
                             struct wps_data *wps_data)
 {
-    int n;
     const char *ptr = wps_bufptr;
     const char *pos;
     const char* filename;
     const char* id;
     const char *newline;
     int x,y;
-    
+    /* tokens for image lod are not saved, so we need a new copy to be able to link them */
+    struct wpsll *llitem = new_wpsll_item((token->type == WPS_TOKEN_IMAGE_DISPLAY)?token:NULL);
+    struct gui_img *img = wps_buffer_alloc(sizeof(struct gui_img));
+    llitem->token->value.data = img;
     /* format: %x|n|filename.bmp|x|y|
        or %xl|n|filename.bmp|x|y| 
        or %xl|n|filename.bmp|x|y|num_subimages|
     */
-
     if (*ptr != '|')
         return WPS_ERROR_INVALID_PARAM;
 
@@ -513,28 +534,22 @@
     if (*ptr != '|')
         return WPS_ERROR_INVALID_PARAM;
 
-    /* get the image ID */
-    n = get_image_id(*id);
-
-    /* check the image number and load state */
-    if(n < 0 || n >= MAX_IMAGES || wps_data->img[n].loaded)
-    {
-        /* Invalid image ID */
-        return WPS_ERROR_INVALID_PARAM;
-    }
-
+    /* store the image ID */
+    img->id = (id[0]);
+    
     /* save a pointer to the filename */
-    bmp_names[n] = filename;
+    img->bm.data = (unsigned char*)filename;
 
-    wps_data->img[n].x = x;
-    wps_data->img[n].y = y;
+    img->x = x;
+    img->y = y;
+    img->num_subimages = 1;
 
     /* save current viewport */
-    wps_data->img[n].vp = &wps_data->viewports[wps_data->num_viewports].vp;
+    img->vp = &curr_vp->vp;
 
     if (token->type == WPS_TOKEN_IMAGE_DISPLAY)
     {
-        wps_data->img[n].always_display = true;
+        img->always_display = true;
     }
     else
     {
@@ -543,12 +558,13 @@
         newline = strchr(ptr, '\n');
         pos = strchr(ptr, '|');
         if (pos && pos < newline)
-            wps_data->img[n].num_subimages = atoi(ptr);
+            img->num_subimages = atoi(ptr);
 
-        if (wps_data->img[n].num_subimages <= 0)
+        if (img->num_subimages <= 0)
             return WPS_ERROR_INVALID_PARAM;
     }
-
+    add_to_ll_chain(&wps_data->images, llitem);
+            
     /* Skip the rest of the line */
     return skip_end_of_line(wps_bufptr);
 }
@@ -559,13 +575,22 @@
 {
     (void)wps_data;
     char letter = wps_bufptr[0];
-
-    if (letter < 'a' || letter > 'z')
+    struct wps_viewport *vp = find_viewport(wps_data, letter);
+    /* viewports are regularly mentioned before being setup.
+     * so if find_viewport() doesnt find one we need to create it first.
+     * this means in parse_viewport() we need to make sure it hasnt been created yet
+     * before allocating room on the buffer for one
+     */
+    if (vp == NULL)
     {
-        /* invalid viewport tag */
-        return WPS_ERROR_INVALID_PARAM;
+        struct wpsll *llitem = new_wpsll_item(token);
+        struct wps_viewport *wvp = wps_buffer_alloc(sizeof(struct wps_viewport));
+        token->value.data = wvp;
+        wvp->label = letter;
+        add_to_ll_chain(&wps_data->viewports, llitem);
+        return 1;
     }
-    token->value.i = letter;
+    token->value.data = vp;
     return 1;
 }
 
@@ -578,6 +603,10 @@
     struct viewport* vp;
     int depth;
     uint32_t set = 0;
+    struct wpsll *llitem = NULL;
+    struct wps_viewport *wvp = NULL, *prev_vp = curr_vp;
+    bool add_to_ll = true;
+    /* tokens for viewport load are not saved, so we need a new copy to be able to link them */
     enum {
         PL_X = 0,
         PL_Y,
@@ -595,15 +624,9 @@
         lcd_height = LCD_REMOTE_HEIGHT;
     }
 #endif
-
-    if (wps_data->num_viewports >= WPS_MAX_VIEWPORTS)
-        return WPS_ERROR_INVALID_PARAM;
     
-    wps_data->num_viewports++;
     /* check for the optional letter to signify its a hideable viewport */
     /* %Vl|<label>|<rest of tags>| */
-    wps_data->viewports[wps_data->num_viewports].hidden_flags = 0;
-    
     if (*ptr == 'l')
     {
         if (*(ptr+1) == '|')
@@ -611,19 +634,36 @@
             char label = *(ptr+2);
             if (label >= 'a' && label <= 'z')
             {
-                wps_data->viewports[wps_data->num_viewports].hidden_flags = VP_DRAW_HIDEABLE;
-                wps_data->viewports[wps_data->num_viewports].label = label;
+                wvp = find_viewport(wps_data, label);
+                add_to_ll = !wvp;
+                if (!wvp)
+                {
+                    wvp = wps_buffer_alloc(sizeof(struct wps_viewport));
+                }
+                wvp->hidden_flags = VP_DRAW_HIDEABLE;
+                wvp->label = label;
             }
             else
-                return WPS_ERROR_INVALID_PARAM; /* malformed token: e.g. %Cl7  */
+                return WPS_ERROR_INVALID_PARAM; /* malformed token: e.g. %Vl7  */
             ptr += 3;
         }
     }
     if (*ptr != '|')
         return WPS_ERROR_INVALID_PARAM;
+    if (wvp == NULL && add_to_ll)
+    {
+        llitem = new_wpsll_item(NULL);
+        wvp = wps_buffer_alloc(sizeof(struct wps_viewport));
+        llitem->token->value.data = wvp;
+        wvp->hidden_flags = 0;
+        wvp->label = '|'; /* impossible char in the wps, used to show this vp is static */
+    }
     
+    curr_vp = wvp;
+    wvp->pb = NULL;
+    
     ptr++;
-    vp = &wps_data->viewports[wps_data->num_viewports].vp;
+    vp = &wvp->vp;
     /* format: %V|x|y|width|height|font|fg_pattern|bg_pattern| */
 
     /* Set the defaults for fields not user-specified */
@@ -705,9 +745,9 @@
     }
 #endif
 
-    wps_data->viewports[wps_data->num_viewports-1].last_line = wps_data->num_lines - 1;
+    prev_vp->last_line = wps_data->num_lines - 1;
 
-    wps_data->viewports[wps_data->num_viewports].first_line = wps_data->num_lines;
+    wvp->first_line = wps_data->num_lines;
   
     if (wps_data->num_sublines < WPS_MAX_SUBLINES)
     {
@@ -717,7 +757,8 @@
         wps_data->sublines[wps_data->num_sublines].first_token_idx =
             wps_data->num_tokens;
     }
-
+    if (add_to_ll)
+        add_to_ll_chain(&wps_data->viewports, llitem);
     /* Skip the rest of the line */
     return skip_end_of_line(wps_bufptr);
 }
@@ -727,8 +768,6 @@
                                struct wps_token *token,
                                struct wps_data *wps_data)
 {
-    (void)wps_data; /* kill warning */
-    (void)token;
     const char *pos = NULL;
     const char *newline;
 
@@ -741,7 +780,13 @@
     if (token->type == WPS_TOKEN_IMAGE_BACKDROP)
     {
         /* format: %X|filename.bmp| */
-        bmp_names[BACKDROP_BMP] = wps_bufptr + 1;
+        /* get_image_filename() expects the filename to end with a |
+         * so make sure that gets copied also */
+        char* bar = strchr(wps_bufptr + 1, '|');
+        int len = bar-wps_bufptr;
+        token->value.data = (char*)wps_buffer_alloc(len);
+        strncpy(token->value.data, wps_bufptr + 1, len);
+        wps_data->backdrop = token;
     }
 #endif
 
@@ -853,7 +898,6 @@
                              struct wps_token *token,
                              struct wps_data *wps_data)
 {
-    (void)token; /* Kill warnings */
     /* %pb or %pb|filename|x|y|width|height|
     using - for any of the params uses "sane" values */
 #ifdef HAVE_LCD_BITMAP
@@ -868,21 +912,20 @@
     int x, y, height, width;
     uint32_t set = 0;
     const char *ptr = wps_bufptr;
-    struct progressbar *pb;
-    struct viewport *vp = &wps_data->viewports[wps_data->num_viewports].vp;
+    struct viewport *vp = &curr_vp->vp;
+    struct wpsll *llitem = new_wpsll_item(token);
+    struct progressbar *pb = wps_buffer_alloc(sizeof(struct progressbar));
+    
+    token->value.data = pb;
 #ifndef __PCTOOL__
     int font_height = font_get(vp->font)->height;
 #else 
     int font_height = 8;
 #endif
-    int line_y_pos = font_height*(wps_data->num_lines - 
-            wps_data->viewports[wps_data->num_viewports].first_line);
+    int line_y_pos = font_height*(wps_data->num_lines - curr_vp->first_line);
     
-    if (wps_data->progressbar_count >= MAX_PROGRESSBARS)
-        return WPS_ERROR_INVALID_PARAM;
-    
-    pb = &wps_data->progressbar[wps_data->progressbar_count];
     pb->have_bitmap_pb = false;
+    add_to_ll_chain(&wps_data->progressbars, llitem);
     
     if (*wps_bufptr != '|') /* regular old style */
     {
@@ -890,11 +933,12 @@
         pb->width = vp->width;
         pb->height = SYSFONT_HEIGHT-2;
         pb->y = line_y_pos + (font_height-pb->height)/2;
+        pb->bm.data = NULL;
 
-        wps_data->viewports[wps_data->num_viewports].pb = pb;
-        wps_data->progressbar_count++;
+        curr_vp->pb = pb;
         return 0;
     }
+    
     ptr = wps_bufptr + 1;
     
     if (!(ptr = parse_list("sdddd", &set, '|', ptr, &filename,
@@ -902,7 +946,9 @@
         return WPS_ERROR_INVALID_PARAM;
 
     if (LIST_VALUE_PARSED(set, PB_FILENAME)) /* filename */
-        bmp_names[PROGRESSBAR_BMP+wps_data->progressbar_count] = filename;
+        pb->bm.data = (unsigned char*)filename;
+    else
+        pb->bm.data = NULL;
 
     if (LIST_VALUE_PARSED(set, PB_X)) /* x */
         pb->x = x;
@@ -936,8 +982,7 @@
     else
         pb->y = line_y_pos + (font_height-pb->height)/2;
 
-    wps_data->viewports[wps_data->num_viewports].pb = pb;
-    wps_data->progressbar_count++;
+    curr_vp->pb = pb;
 
     /* Skip the rest of the line */
     return skip_end_of_line(wps_bufptr)-1;
@@ -1222,15 +1267,12 @@
     if (!data || !wps_bufptr || !*wps_bufptr)
         return false;
 
-    char *stringbuf = data->string_buffer;
-    int stringbuf_used = 0;
     enum wps_parse_error fail = PARSE_OK;
     int ret;
     line = 1;
     level = -1;
 
-    while(*wps_bufptr && !fail && data->num_tokens < WPS_MAX_TOKENS - 1
-          && data->num_viewports < WPS_MAX_VIEWPORTS 
+    while(*wps_bufptr && !fail && data->num_tokens < WPS_MAX_TOKENS - 1 
           && data->num_lines < WPS_MAX_LINES)
     {
         switch(*wps_bufptr++)
@@ -1375,45 +1417,35 @@
                     }
 
                     /* look if we already have that string */
-                    char **str;
-                    int i;
-                    bool found;
-                    for (i = 0, str = data->strings, found = false;
-                         i < data->num_strings &&
-                         !(found = (strlen(*str) == len &&
-                                    strncmp(string_start, *str, len) == 0));
-                         i++, str++);
-                    /* If a matching string is found, found is true and i is
-                       the index of the string. If not, found is false */
-
+                    
+                    bool found = false;
+                    char *str;
+                    struct wpsll *ll;
+                    for(ll = data->strings; ll; ll = ll->next)
+                    {
+                        str = ll->token->value.data;
+                        found = (strlen(str) == len &&
+                                    strncmp(string_start, str, len) == 0);
+                        if (found)
+                            break;
+                    }
+                    
                     if (!found)
                     {
                         /* new string */
-
-                        if (stringbuf_used + len > STRING_BUFFER_SIZE - 1
-                            || data->num_strings >= WPS_MAX_STRINGS)
-                        {
-                            /* too many strings or characters */
-                            fail = PARSE_FAIL_LIMITS_EXCEEDED;
-                            break;
-                        }
-
-                        strncpy(stringbuf, string_start, len);
-                        *(stringbuf + len) = '\0';
-
-                        data->strings[data->num_strings] = stringbuf;
-                        stringbuf += len + 1;
-                        stringbuf_used += len + 1;
-                        data->tokens[data->num_tokens].value.i =
-                            data->num_strings;
-                        data->num_strings++;
+                        str = wps_buffer_alloc(len+1);
+                        strncpy(str, string_start, len);  
+                        *(str + len) = '\0';
+                        data->tokens[data->num_tokens].value.data = str;
                     }
                     else
                     {
                         /* another occurrence of an existing string */
-                        data->tokens[data->num_tokens].value.i = i;
+                        data->tokens[data->num_tokens].value.data = ll->token->value.data;
                     }
                     data->tokens[data->num_tokens].type = WPS_TOKEN_STRING;
+                    ll = new_wpsll_item(&data->tokens[data->num_tokens]);
+                    add_to_ll_chain(&data->strings, ll);
                     data->num_tokens++;
                 }
                 break;
@@ -1427,11 +1459,8 @@
         /* one of the limits of the while loop was exceeded */
         fail = PARSE_FAIL_LIMITS_EXCEEDED;
 
-    data->viewports[data->num_viewports].last_line = data->num_lines - 1;
+    curr_vp->last_line = data->num_lines - 1;
 
-    /* We have finished with the last viewport, so increment count */
-    data->num_viewports++;
-
 #if defined(DEBUG) || defined(SIMULATOR)
     print_debug_info(data, fail, line);
 #endif
@@ -1439,34 +1468,25 @@
     return (fail == 0);
 }
 
-#ifdef HAVE_LCD_BITMAP
-/* Clear the WPS image cache */
-static void wps_images_clear(struct wps_data *data)
-{
-    int i;
-    /* set images to unloaded and not displayed */
-    for (i = 0; i < MAX_IMAGES; i++)
-    {
-       data->img[i].loaded = false;
-       data->img[i].display = -1;
-       data->img[i].always_display = false;
-       data->img[i].num_subimages = 1;
-    }
-}
-#endif
 
 /* initial setup of wps_data */
 void wps_data_init(struct wps_data *wps_data)
 {
+#if NB_SCREENS == 1
+    /* if there is more than one display this call isnt safe here. It must be done
+     * in settings_apply() or else it will happen on both screens which is VERY BAD!
+     * this is here for single screens because otherwise it wont get called if a .wps
+     * is "run" (which is going to be a problem for multi-screen targets */
+    wps_buffer_init();
+#endif    
 #ifdef HAVE_LCD_BITMAP
-    wps_images_clear(wps_data);
+    wps_data->backdrop = NULL;
+    wps_data->images = NULL;
     wps_data->wps_sb_tag = false;
     wps_data->show_sb_on_wps = false;
-    wps_data->img_buf_ptr = wps_data->img_buf; /* where in image buffer */
-    wps_data->img_buf_free = IMG_BUFSIZE; /* free space in image buffer */
     wps_data->peak_meter_enabled = false;
     /* progress bars */
-    wps_data->progressbar_count = 0;
+    wps_data->progressbars = NULL;
 #else /* HAVE_LCD_CHARCELLS */
     int i;
     for (i = 0; i < 8; i++)
@@ -1495,37 +1515,51 @@
 
 static bool load_wps_bitmaps(struct wps_data *wps_data, char *bmpdir)
 {
+    /* NOTE: image filenames get put in the images bm->data member,
+     * so copy before use */
     char img_path[MAX_PATH];
     struct bitmap *bitmap;
     bool *loaded;
     int n;
-    for (n = 0; n < BACKDROP_BMP; n++)
+    struct wpsll *llitem;
+    
+    /* load the progressbar images */
+    for ( llitem = wps_data->progressbars; llitem; llitem = llitem->next)
     {
-        if (bmp_names[n])
+        struct progressbar *pb = (struct progressbar *)llitem->token->value.data;
+        if (pb->bm.data)
         {
-            get_image_filename(bmp_names[n], bmpdir,
+            get_image_filename(pb->bm.data, bmpdir, 
                                img_path, sizeof(img_path));
-
-            if (n >= PROGRESSBAR_BMP ) {
-                /* progressbar bitmap */
-                bitmap = &wps_data->progressbar[n-PROGRESSBAR_BMP].bm;
-                loaded = &wps_data->progressbar[n-PROGRESSBAR_BMP].have_bitmap_pb;
-            } else {
-                /* regular bitmap */
-                bitmap = &wps_data->img[n].bm;
-                loaded = &wps_data->img[n].loaded;
+            bitmap = &pb->bm;
+            loaded = &pb->have_bitmap_pb;
+            if (load_bitmap(wps_data, img_path, bitmap))
+            {
+                *loaded = true;
             }
-
-            /* load the image */
-            bitmap->data = wps_data->img_buf_ptr;
+            else
+            {
+                /* Abort if we can't load an image */
+                DEBUGF("ERR: Failed to load image %d - %s\n",n,img_path);
+                return false;
+            }
+        }
+    }
+    /* load regular images */         
+    for ( llitem = wps_data->images; llitem; llitem = llitem->next)
+    {
+        struct gui_img *img = (struct gui_img*)llitem->token->value.data;
+        if (img->bm.data)
+        {
+            get_image_filename(img->bm.data, bmpdir, 
+                               img_path, sizeof(img_path));
+            bitmap = &img->bm;
+            loaded = &img->loaded;
             if (load_bitmap(wps_data, img_path, bitmap))
             {
                 *loaded = true;
-
                 /* Calculate and store height if this image has sub-images */
-                if (n < MAX_IMAGES)
-                    wps_data->img[n].subimage_height = wps_data->img[n].bm.height /
-                                                       wps_data->img[n].num_subimages;
+                img->subimage_height = img->bm.height / img->num_subimages;
             }
             else
             {
@@ -1536,12 +1570,13 @@
         }
     }
 
+    /* special cases */
 #if (LCD_DEPTH > 1) || (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1))
-    if (bmp_names[BACKDROP_BMP])
+    if (wps_data->backdrop)
     {
-        get_image_filename(bmp_names[BACKDROP_BMP], bmpdir,
-                            img_path, sizeof(img_path));
-
+        char* filename = (char*)wps_data->backdrop->value.data;
+        get_image_filename(filename, 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)
@@ -1587,32 +1622,41 @@
         return false;
 
     wps_reset(wps_data);
+    
+    struct wpsll *ll = new_wpsll_item(NULL);
+    struct wps_viewport *vp = wps_buffer_alloc(sizeof(struct wps_viewport));
+    curr_vp = vp;
 
     /* Initialise the first (default) viewport */
-    wps_data->viewports[0].vp.x          = 0;
-    wps_data->viewports[0].vp.width      = display->getwidth();
+    vp->label         = '\0';
+    vp->vp.x          = 0;
+    vp->vp.width      = display->getwidth();
+    vp->pb = NULL;
     if (!global_settings.statusbar)
     {
-        wps_data->viewports[0].vp.y      = 0;
-        wps_data->viewports[0].vp.height = display->getheight();
+        vp->vp.y      = 0;
+        vp->vp.height = display->getheight();
     }
     else
     {
-        wps_data->viewports[0].vp.y      = STATUSBAR_HEIGHT;
-        wps_data->viewports[0].vp.height = display->getheight() -
-                                            STATUSBAR_HEIGHT;
+        vp->vp.y      = STATUSBAR_HEIGHT;
+        vp->vp.height = display->getheight() - STATUSBAR_HEIGHT;
     }
 #ifdef HAVE_LCD_BITMAP
-    wps_data->viewports[0].vp.font       = FONT_UI;
-    wps_data->viewports[0].vp.drawmode   = DRMODE_SOLID;
+    vp->vp.font       = FONT_UI;
+    vp->vp.drawmode   = DRMODE_SOLID;
 #endif
 #if LCD_DEPTH > 1
     if (display->depth > 1)
     {
-        wps_data->viewports[0].vp.fg_pattern = display->get_foreground();
-        wps_data->viewports[0].vp.bg_pattern = display->get_background();
+        vp->vp.fg_pattern = display->get_foreground();
+        vp->vp.bg_pattern = display->get_background();
     }
 #endif
+    ll->token->type = WPS_NO_TOKEN; /* should be safe */
+    ll->token->value.data = vp;
+    add_to_ll_chain(&wps_data->viewports, ll);
+    
     if (!isfile)
     {
         return wps_parse(wps_data, buf);
@@ -1670,11 +1714,6 @@
         if (start <= 0)
             return false;
 
-#ifdef HAVE_LCD_BITMAP
-        /* Set all filename pointers to NULL */
-        memset(bmp_names, 0, sizeof(bmp_names));
-#endif
-
         /* parse the WPS source */
         if (!wps_parse(wps_data, wps_buffer)) {
             wps_reset(wps_data);
Index: apps/menus/main_menu.c
===================================================================
--- apps/menus/main_menu.c	(revision 19998)
+++ apps/menus/main_menu.c	(working copy)
@@ -145,9 +145,7 @@
     INFO_DISK1, /* capacity or internal capacity/free on hotswap */
     INFO_DISK2, /* free space or external capacity/free on hotswap */
     INFO_BUFFER,
-#ifdef HAVE_ALBUMART
-    INFO_ALBUMART,
-#endif
+    INFO_WPSUSAGE,
     INFO_VERSION,
     INFO_COUNT
 };
@@ -158,6 +156,11 @@
     ID2P(LANG_MEGABYTE),
     ID2P(LANG_GIGABYTE)
 };
+static const unsigned char *byte_units[] =
+{
+    ID2P(LANG_BYTE),
+    ID2P(LANG_KILOBYTE)
+};
 
 static char* info_getname(int selected_item, void *data,
                           char *buffer, size_t buffer_len)
@@ -251,20 +254,10 @@
             snprintf(buffer, buffer_len, SIZE_FMT, str(LANG_DISK_SIZE_INFO), s1);
 #endif
             break;
-#ifdef HAVE_ALBUMART
-        case INFO_ALBUMART: /* album art dimenstions */
-            if (gui_sync_wps_uses_albumart())
-            {
-                snprintf(buffer, buffer_len, "%s %dx%d", str(LANG_ALBUMART),
-                         gui_wps[0].data->albumart_max_width, 
-                         gui_wps[0].data->albumart_max_height);
-            }
-            else
-            {
-                snprintf(buffer, buffer_len, "%s %s", str(LANG_ALBUMART),
-                         str(LANG_SET_BOOL_NO));
-            }
-#endif
+        case INFO_WPSUSAGE:
+            output_dyn_value(s1, sizeof s1, wps_buffer_usage(), byte_units, true);
+            snprintf(buffer, buffer_len, "%s %s", str(LANG_WPS_RAM_USAGE), s1);
+            break;         
     }
     return buffer;
 }
@@ -346,20 +339,10 @@
             output_dyn_value(NULL, 0, info->size, kbyte_units, true);
 #endif
             break;
-#ifdef HAVE_ALBUMART
-            case INFO_ALBUMART: /* album art dimenstions */
-                if (gui_sync_wps_uses_albumart())
-                {
-                    talk_id(LANG_ALBUMART, false);
-                    talk_value(gui_wps[0].data->albumart_max_width, UNIT_PIXEL, true);
-                    talk_value(gui_wps[0].data->albumart_max_height, UNIT_PIXEL, true);
-                }
-                else
-                {
-                    talk_id(LANG_ALBUMART, false);
-                    talk_id(LANG_SET_BOOL_NO, true);
-                }
-#endif
+            case INFO_WPSUSAGE:
+                talk_id(LANG_WPS_RAM_USAGE, false);
+                talk_value(wps_buffer_usage(), UNIT_INT, true);
+                break;
     }
     return 0;
 }
Index: apps/SOURCES
===================================================================
--- apps/SOURCES	(revision 19998)
+++ apps/SOURCES	(working copy)
@@ -60,6 +60,7 @@
 #ifdef HAVE_BUTTONBAR
 gui/buttonbar.c
 #endif
+gui/wps/wps_buffer.c
 gui/gwps.c
 gui/gwps-common.c
 #ifdef HAVE_LCD_BITMAP