Index: apps/misc.h
===================================================================
--- apps/misc.h	(revision 17675)
+++ apps/misc.h	(working copy)
@@ -129,6 +129,7 @@
 char *strip_extension(char* buffer, int buffer_size, const char *filename);
 
 /* A simplified scanf */
-const char* parse_list(const char *fmt, const char sep, const char* str, ...);
+const char* parse_list(const char *fmt, unsigned int *valid_vals,
+                       const char sep, const char* str, ...);
 
 #endif /* MISC_H */
Index: apps/gui/gwps-common.c
===================================================================
--- apps/gui/gwps-common.c	(revision 17675)
+++ apps/gui/gwps-common.c	(working copy)
@@ -494,53 +494,33 @@
 
 #ifdef HAVE_LCD_BITMAP
 
-static void draw_progressbar(struct gui_wps *gwps, int line)
+static void draw_progressbar(struct gui_wps *gwps,
+                             struct progressbar *pb)
 {
-    struct wps_data *data = gwps->data;
     struct screen *display = gwps->display;
     struct wps_state *state = gwps->state;
-    int h = font_get(display->getfont())->height;
-
-    int sb_y;
-    if (data->progress_top < 0)
-        sb_y = line*h + display->getymargin() +
-               ((h > data->progress_height + 1)
-                ? (h - data->progress_height) / 2 : 1);
-    else
-        sb_y = data->progress_top;
-
-    if (!data->progress_end)
-        data->progress_end=display->getwidth();
-
-    if (gwps->data->progressbar.have_bitmap_pb)
-        gui_bitmap_scrollbar_draw(display, data->progressbar.bm,
-                                  data->progress_start, sb_y,
-                                  data->progress_end-data->progress_start,
-                                  data->progressbar.bm.height,
+    if (pb->have_bitmap_pb)
+        gui_bitmap_scrollbar_draw(display, pb->bm,
+                                  pb->x, pb->y, pb->width, pb->bm.height,
                                   state->id3->length ? state->id3->length : 1, 0,
                                   state->id3->length ? state->id3->elapsed
-                                                       + state->ff_rewind_count : 0,
-                                  HORIZONTAL);
+                                          + state->ff_rewind_count : 0,
+                                          HORIZONTAL);
     else
-        gui_scrollbar_draw(display, data->progress_start, sb_y,
-                           data->progress_end-data->progress_start,
-                           data->progress_height,
+        gui_scrollbar_draw(display, pb->x, pb->y, pb->width, pb->height,
                            state->id3->length ? state->id3->length : 1, 0,
                            state->id3->length ? state->id3->elapsed
-                                                + state->ff_rewind_count : 0,
-                           HORIZONTAL);
-
+                                   + state->ff_rewind_count : 0,
+                                   HORIZONTAL);
 #ifdef AB_REPEAT_ENABLE
     if ( ab_repeat_mode_enabled() && state->id3->length != 0 )
         ab_draw_markers(display, state->id3->length,
-                        data->progress_start, data->progress_end, sb_y,
-                        data->progress_height);
+                        pb->x, pb->x + pb->width, pb->y, pb->height);
 #endif
 
     if ( cuesheet_is_enabled() && state->id3->cuesheet_type )
         cue_draw_markers(display, state->id3->length,
-                         data->progress_start, data->progress_end,
-                         sb_y+1, data->progress_height-2);
+                         pb->x, pb->x + pb->width, pb->y+1, pb->height-2);
 }
 
 /* clears the area where the image was shown */
@@ -1608,7 +1588,24 @@
                 *buf++ = 0;
                 cur_align_start = buf;
                 break;
-
+            case WPS_VIEWPORT_ENABLE:
+            {
+                char label = data->tokens[i].value.i;
+                int j;
+                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;
+                    }
+                }
+            }
+                break;
             default:
             {
                 /* get the value of the tag and copy it to the buffer */
@@ -1932,6 +1929,7 @@
     int v, line, i, subline_idx;
     unsigned char flags;
     char linebuf[MAX_PATH];
+    unsigned char vp_refresh_mode;
 
     struct align_pos align;
     align.left = NULL;
@@ -1981,14 +1979,21 @@
 
     state->ff_rewind_count = ffwd_offset;
 
+    /* disable any viewports which are conditionally displayed */
     for (v = 0; v < data->num_viewports; v++)
     {
-        display->set_viewport(&data->viewports[v].vp);
-
-        if (refresh_mode == WPS_REFRESH_ALL)
+        if (data->viewports[v].hidden_flags&VP_DRAW_HIDEABLE)
         {
-            display->clear_viewport();
+            if (data->viewports[v].hidden_flags&VP_DRAW_HIDDEN)
+                data->viewports[v].hidden_flags |= VP_DRAW_WASHIDDEN;
+            else
+                data->viewports[v].hidden_flags |= VP_DRAW_HIDDEN;
         }
+    }
+    for (v = 0; v < data->num_viewports; v++)
+    {
+        display->set_viewport(&data->viewports[v].vp);
+        vp_refresh_mode = refresh_mode;
 
 #ifdef HAVE_LCD_BITMAP
         /* Set images to not to be displayed */
@@ -1997,7 +2002,26 @@
             data->img[i].display = -1;
         }
 #endif
-
+        /* dont redraw the viewport if its disabled */
+        if ((data->viewports[v].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;
+            continue;
+        }
+        else if (((data->viewports[v].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;
+        }
+        if (vp_refresh_mode == WPS_REFRESH_ALL)
+        {
+            display->clear_viewport();
+        }
+            
         for (line = data->viewports[v].first_line; 
              line <= data->viewports[v].last_line; line++)
         {
@@ -2011,30 +2035,21 @@
                                             data->lines[line].curr_subline);
             flags = data->sublines[subline_idx].line_type;
 
-            if (refresh_mode == WPS_REFRESH_ALL || (flags & refresh_mode)
+            if (vp_refresh_mode == WPS_REFRESH_ALL || (flags & vp_refresh_mode)
                 || new_subline_refresh)
             {
                 /* get_line tells us if we need to update the line */
                 update_line = get_line(gwps, line, data->lines[line].curr_subline,
                                        &align, linebuf, sizeof(linebuf));
             }
-
 #ifdef HAVE_LCD_BITMAP
-            /* progressbar */
-            if (flags & refresh_mode & WPS_REFRESH_PLAYER_PROGRESS)
-            {
-                /* the progressbar should be alone on its line */
-                update_line = false;
-                draw_progressbar(gwps, line - data->viewports[v].first_line);
-            }
-
             /* peakmeter */
-            if (flags & refresh_mode & WPS_REFRESH_PEAK_METER)
+            if (flags & vp_refresh_mode & WPS_REFRESH_PEAK_METER)
             {
                 /* the peakmeter should be alone on its line */
                 update_line = false;
 
-                int h = font_get(display->getfont())->height;
+                int h = font_get(data->viewports[v].vp.font)->height;
                 int peak_meter_y = display->getymargin() + (line - data->viewports[v].first_line)* h;
 
                 /* The user might decide to have the peak meter in the last
@@ -2053,7 +2068,7 @@
 #else /* HAVE_LCD_CHARCELL */
 
             /* progressbar */
-            if (flags & refresh_mode & WPS_REFRESH_PLAYER_PROGRESS)
+            if (flags & vp_refresh_mode & WPS_REFRESH_PLAYER_PROGRESS)
             {
                 if (data->full_line_progressbar)
                     draw_player_fullbar(gwps, linebuf, sizeof(linebuf));
@@ -2068,16 +2083,21 @@
                 {
                     /* if the line is a scrolling one we don't want to update
                        too often, so that it has the time to scroll */
-                    if ((refresh_mode & WPS_REFRESH_SCROLL) || new_subline_refresh)
+                    if ((vp_refresh_mode & WPS_REFRESH_SCROLL) || new_subline_refresh)
                         write_line(display, &align, line - data->viewports[v].first_line, true);
                 }
                 else
                     write_line(display, &align, line - data->viewports[v].first_line, false);
             }
-
         }
 
 #ifdef HAVE_LCD_BITMAP
+        /* progressbar */
+        if (vp_refresh_mode & WPS_REFRESH_PLAYER_PROGRESS)
+        {
+            if (data->viewports[v].pb)
+                draw_progressbar(gwps, data->viewports[v].pb);
+        }
         /* Now display any images in this viewport */
         wps_display_images(gwps, &data->viewports[v].vp);
 #endif
Index: apps/gui/wps_debug.c
===================================================================
--- apps/gui/wps_debug.c	(revision 17675)
+++ apps/gui/wps_debug.c	(working copy)
@@ -431,6 +431,10 @@
             snprintf(buf, bufsize, "pitch value");
             break;
 #endif
+        case WPS_VIEWPORT_ENABLE:
+            snprintf(buf, bufsize, "enable VP:%d",
+                     token->value.i);
+            break;
 
         default:
             snprintf(buf, bufsize, "FIXME (code: %d)",
Index: apps/gui/gwps.h
===================================================================
--- apps/gui/gwps.h	(revision 17675)
+++ apps/gui/gwps.h	(working copy)
@@ -70,7 +70,13 @@
     bool always_display;    /* not using the preload/display mechanism */
 };
 
-struct prog_img{ /*progressbar image*/
+struct progressbar {
+    /* regular pb */
+    short x;
+    short y;
+    short width;
+    short height;
+    /*progressbar image*/
     struct bitmap bm;
     bool have_bitmap_pb;
 };
@@ -85,6 +91,7 @@
 #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. */
@@ -271,8 +278,11 @@
 
 #if (CONFIG_LED == LED_VIRTUAL) || defined(HAVE_REMOTE_LCD)
     /* Virtual LED */
-    WPS_TOKEN_VLED_HDD
+    WPS_TOKEN_VLED_HDD,
 #endif
+
+    /* Viewport display */
+    WPS_VIEWPORT_ENABLE
 };
 
 struct wps_token {
@@ -323,12 +333,17 @@
     long subline_expire_time;
 };
 
+#define VP_DRAW_HIDEABLE 0x1
+#define VP_DRAW_HIDDEN   0x2
+#define VP_DRAW_WASHIDDEN  0x4
 struct wps_viewport {
     struct viewport vp;   /* The LCD viewport struct */
-
+    struct progressbar *pb;
     /* Indexes of the first and last lines belonging to this viewport in the 
        lines[] array */
     int first_line, last_line;
+    char hidden_flags;
+    char label;
 };
 
 /* wps_data
@@ -338,17 +353,15 @@
 {
 #ifdef HAVE_LCD_BITMAP
     struct gui_img img[MAX_IMAGES];
-    struct prog_img progressbar;
     unsigned char img_buf[IMG_BUFSIZE];
     unsigned char* img_buf_ptr;
     int img_buf_free;
     bool wps_sb_tag;
     bool show_sb_on_wps;
 
-    short progress_top;
-    short progress_height;
-    short progress_start;
-    short progress_end;
+    struct progressbar progressbar[MAX_PROGRESSBARS];
+    short progressbar_count;
+    
     bool peak_meter_enabled;
 
 #ifdef HAVE_ALBUMART
Index: apps/gui/wps_parser.c
===================================================================
--- apps/gui/wps_parser.c	(revision 17675)
+++ apps/gui/wps_parser.c	(working copy)
@@ -80,13 +80,13 @@
 #ifdef HAVE_LCD_BITMAP
 
 #if LCD_DEPTH > 1
-#define MAX_BITMAPS (MAX_IMAGES+2) /* WPS images + pbar bitmap + backdrop */
+#define MAX_BITMAPS (MAX_IMAGES+MAX_PROGRESSBARS+1) /* WPS images + pbar bitmap + backdrop */
 #else
-#define MAX_BITMAPS (MAX_IMAGES+1) /* WPS images + pbar bitmap */
+#define MAX_BITMAPS (MAX_IMAGES+MAX_PROGRESSBARS) /* WPS images + pbar bitmap */
 #endif
 
 #define PROGRESSBAR_BMP MAX_IMAGES
-#define BACKDROP_BMP    (MAX_IMAGES+1)
+#define BACKDROP_BMP    (MAX_BITMAPS-1)
 
 /* pointers to the bitmap filenames in the WPS source */
 static const char *bmp_names[MAX_BITMAPS];
@@ -129,6 +129,8 @@
         struct wps_token *token, struct wps_data *wps_data);
 
 #ifdef HAVE_LCD_BITMAP
+static int parse_viewport_display(const char *wps_bufptr,
+        struct wps_token *token, struct wps_data *wps_data);
 static int parse_viewport(const char *wps_bufptr,
         struct wps_token *token, struct wps_data *wps_data);
 static int parse_leftmargin(const char *wps_bufptr,
@@ -317,13 +319,14 @@
                                                        parse_image_display },
 
     { WPS_TOKEN_IMAGE_DISPLAY,            "x",   0,       parse_image_load },
-    { WPS_TOKEN_IMAGE_PROGRESS_BAR,       "P",   0,    parse_image_special },
 #ifdef HAVE_ALBUMART
     { WPS_NO_TOKEN,                       "Cl",  0,    parse_albumart_load },
     { WPS_TOKEN_ALBUMART_DISPLAY,         "C",   WPS_REFRESH_STATIC,
                                                 parse_albumart_conditional },
 #endif
 
+    { WPS_VIEWPORT_ENABLE,                "Vd",  WPS_REFRESH_STATIC, 
+                                                    parse_viewport_display },
     { WPS_NO_TOKEN,                       "V",   0,    parse_viewport      },
 
 #if (LCD_DEPTH > 1) || (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1))
@@ -489,7 +492,7 @@
 
     ptr++;
 
-    if (!(ptr = parse_list("ssdd", '|', ptr, &id, &filename, &x, &y)))
+    if (!(ptr = parse_list("ssdd", NULL, '|', ptr, &id, &filename, &x, &y)))
         return WPS_ERROR_INVALID_PARAM;
 
     /* Check there is a terminating | */
@@ -536,6 +539,26 @@
     return skip_end_of_line(wps_bufptr);
 }
 
+static int parse_viewport_display(const char *wps_bufptr,
+                                  struct wps_token *token,
+                                  struct wps_data *wps_data)
+{
+    (void)wps_data;
+    char letter = wps_bufptr[0];
+
+    if (letter < 'a' || letter > ('a' + WPS_MAX_VIEWPORTS))
+    {
+        /* invalid viewport tag */
+        return WPS_ERROR_INVALID_PARAM;
+    }
+
+    /* for these to work, this tag needs to be before %V
+        so set token->value.i to the letter and change that 
+        to the viewports index when its loaded */
+    token->value.i = letter;
+    return 1;
+}
+
 static int parse_viewport(const char *wps_bufptr,
                           struct wps_token *token,
                           struct wps_data *wps_data)
@@ -545,17 +568,34 @@
     int depth;
 
     (void)token; /* Kill warnings */
+    
+    if (wps_data->num_viewports >= WPS_MAX_VIEWPORTS)
+        return WPS_ERROR_INVALID_PARAM;
 
-    if (*wps_bufptr != '|')
+    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' && *(ptr+1) == '|')
+    {
+        char label = *(ptr+2);
+        if (label >= 'a' && label < 'a' + WPS_MAX_VIEWPORTS)
+        {
+            wps_data->viewports[wps_data->num_viewports].hidden_flags = VP_DRAW_HIDEABLE;
+            wps_data->viewports[wps_data->num_viewports].label = label;
+        }
+        else
+            return WPS_ERROR_INVALID_PARAM; /* malformed token: e.g. %Cl7  */
+        ptr += 3;
+    }
+    
+    if (*ptr != '|')
         return WPS_ERROR_INVALID_PARAM; /* malformed token: e.g. %Cl7  */
 
-    ptr = wps_bufptr + 1;
-    /* format: %V|x|y|width|height|fg_pattern|bg_pattern| */
+    ptr++;
+    /* format: %V|x|y|width|height|fg_pattern|bg_pattern|<identifier|> */
 
-    if (wps_data->num_viewports >= WPS_MAX_VIEWPORTS)
-        return WPS_ERROR_INVALID_PARAM;
-
-    wps_data->num_viewports++;
     vp = &wps_data->viewports[wps_data->num_viewports].vp;
 
     /* Set the defaults for fields not user-specified */
@@ -573,7 +613,7 @@
 #ifdef HAVE_LCD_COLOR
     if (depth == 16)
     {
-        if (!(ptr = parse_list("dddddcc", '|', ptr, &vp->x, &vp->y, &vp->width,
+        if (!(ptr = parse_list("dddddcc", NULL, '|', ptr, &vp->x, &vp->y, &vp->width,
                     &vp->height, &vp->font, &vp->fg_pattern,&vp->bg_pattern)))
             return WPS_ERROR_INVALID_PARAM;
     }
@@ -581,7 +621,7 @@
 #endif
 #if (LCD_DEPTH == 2) || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH == 2)
     if (depth == 2) {
-        if (!(ptr = parse_list("dddddgg", '|', ptr, &vp->x, &vp->y, &vp->width,
+        if (!(ptr = parse_list("dddddgg", NULL, '|', ptr, &vp->x, &vp->y, &vp->width,
                     &vp->height, &vp->font, &vp->fg_pattern, &vp->bg_pattern)))
             return WPS_ERROR_INVALID_PARAM;
     }
@@ -590,7 +630,7 @@
 #if (LCD_DEPTH == 1) || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH == 1)
     if (depth == 1)
     {
-        if (!(ptr = parse_list("ddddd", '|', ptr, &vp->x, &vp->y, &vp->width,
+        if (!(ptr = parse_list("ddddd", NULL, '|', ptr, &vp->x, &vp->y, &vp->width,
                                                   &vp->height, &vp->font)))
             return WPS_ERROR_INVALID_PARAM;
     }
@@ -662,14 +702,8 @@
 
     if (pos > newline)
         return WPS_ERROR_INVALID_PARAM;
-
-    if (token->type == WPS_TOKEN_IMAGE_PROGRESS_BAR)
-    {
-        /* format: %P|filename.bmp| */
-        bmp_names[PROGRESSBAR_BMP] = wps_bufptr + 1;
-    }
 #if LCD_DEPTH > 1
-    else if (token->type == WPS_TOKEN_IMAGE_BACKDROP)
+    if (token->type == WPS_TOKEN_IMAGE_BACKDROP)
     {
         /* format: %X|filename.bmp| */
         bmp_names[BACKDROP_BMP] = wps_bufptr + 1;
@@ -737,40 +771,52 @@
                              struct wps_data *wps_data)
 {
     (void)token; /* Kill warnings */
+    /* %pb|filename|x|y|width|height|
+       using <blank> for any of the params uses "sane" values */
 #ifdef HAVE_LCD_BITMAP
+    const char *filename;
+    int x, y, height, width, valid = 0;
+    const char *ptr = wps_bufptr;
+    struct progressbar *pb;
+    struct viewport *vp = &wps_data->viewports[wps_data->num_viewports].vp;
+    
+    if (wps_data->progressbar_count +1 >= MAX_PROGRESSBARS)
+        return WPS_ERROR_INVALID_PARAM;
+    
+    pb = &wps_data->progressbar[wps_data->progressbar_count];
+    
+    if (*wps_bufptr != '|')
+        return WPS_ERROR_INVALID_PARAM; /* malformed token: e.g. %Cl7  */
 
-    short *vals[] = {
-        &wps_data->progress_height,
-        &wps_data->progress_start,
-        &wps_data->progress_end,
-        &wps_data->progress_top };
-
-    /* default values : */
-    wps_data->progress_height = 6;
-    wps_data->progress_start = 0;
-    wps_data->progress_end = 0;
-    wps_data->progress_top = -1;
-
-    int i = 0;
-    char *newline = strchr(wps_bufptr, '\n');
-    char *prev = strchr(wps_bufptr, '|');
-    if (prev && prev < newline) {
-        char *next = strchr(prev+1, '|');
-        while (i < 4 && next && next < newline)
-        {
-            *(vals[i++]) = atoi(++prev);
-            prev = strchr(prev, '|');
-            next = strchr(++next, '|');
-        }
-
-        if (wps_data->progress_height < 3)
-            wps_data->progress_height = 3;
-        if (wps_data->progress_end < wps_data->progress_start + 3)
-            wps_data->progress_end = 0;
-    }
-
-    return newline - wps_bufptr;
-
+    ptr = wps_bufptr + 1;
+    
+    if (!(ptr = parse_list("sdddd", &valid, '|', ptr, &filename,
+                                                 &x, &y, &width, &height)))
+        return WPS_ERROR_INVALID_PARAM;
+    if (valid&(1<<0) && filename[0] != '|') /* filename */
+        bmp_names[PROGRESSBAR_BMP+wps_data->progressbar_count] = filename;
+    if (valid&(1<<1)) /* x */
+        pb->x = x;
+    else
+        pb->x = vp->x;
+    if (valid&(1<<2)) /* y */
+        pb->y = y;
+    else
+        pb->y = vp->y;
+    if (valid&(1<<3)) /* width */
+        pb->width = width;
+    else
+        pb->width = vp->width;
+    if (valid&(1<<4)) /* height, default to font height */
+        pb->height = height;
+    else
+        pb->height = font_get(vp->font)->height;
+    wps_data->progressbar[wps_data->progressbar_count].have_bitmap_pb = false;
+    wps_data->viewports[wps_data->num_viewports].pb =
+            &wps_data->progressbar[wps_data->progressbar_count];
+    wps_data->progressbar_count++;
+    /* Skip the rest of the line */
+    return skip_end_of_line(wps_bufptr);
 #else
 
     if (*(wps_bufptr-1) == 'f')
@@ -1334,7 +1380,6 @@
        data->img[i].always_display = false;
        data->img[i].num_subimages = 1;
     }
-    data->progressbar.have_bitmap_pb = false;
 }
 #endif
 
@@ -1348,6 +1393,8 @@
     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;
 #else /* HAVE_LCD_CHARCELLS */
     int i;
     for (i = 0; i < 8; i++)
@@ -1389,10 +1436,10 @@
             get_image_filename(bmp_names[n], bmpdir,
                                img_path, sizeof(img_path));
 
-            if (n == PROGRESSBAR_BMP) {
+            if (n >= PROGRESSBAR_BMP ) {
                 /* progressbar bitmap */
-                bitmap = &wps_data->progressbar.bm;
-                loaded = &wps_data->progressbar.have_bitmap_pb;
+                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;
Index: apps/misc.c
===================================================================
--- apps/misc.c	(revision 17675)
+++ apps/misc.c	(working copy)
@@ -1217,7 +1217,9 @@
                s - string (sets pointer to string, without copying)
                c - hex colour (RGB888 - e.g. ff00ff)
                g - greyscale "colour" (0-3)
-
+   valid_vals - if not NULL 1 is set in the bitplace if the item was read OK
+                0 if not read.
+                first item is LSB, (max 32 items! )
    sep - list separator (e.g. ',' or '|')
    str  - string to parse, must be terminated by 0 or sep
    ... - pointers to store the parsed values
@@ -1229,25 +1231,29 @@
 /* '0'-'3' are ASCII 0x30 to 0x33 */
 #define is0123(x) (((x) & 0xfc) == 0x30)
 
-const char* parse_list(const char *fmt, const char sep, const char* str, ...)
+const char* parse_list(const char *fmt, unsigned int *valid_vals,
+                       const char sep, const char* str, ...)
 {
     va_list ap;
-    const char* p = str;
+    const char* p = str, *f = fmt;
     const char** s;
     int* d;
+    bool valid;
+    int i=0;
 
     va_start(ap, str);
-
+    if (valid_vals)
+        *valid_vals = 0;
     while (*fmt)
     {
         /* Check for separator, if we're not at the start */
-        if (p != str)
+        if (f != fmt)
         {
             if (*p != sep)
                 goto err;
             p++;
         }
-
+        valid = false;
         switch (*fmt++) 
         {
             case 's': /* string - return a pointer to it (not a copy) */
@@ -1256,19 +1262,26 @@
                 *s = p;
                 while (*p && *p != sep)
                    p++;
-
+                valid = (*s[0]!=sep);
                 break;
 
             case 'd': /* int */
                 d = va_arg(ap, int*);
                 if (!isdigit(*p))
-                   goto err;
+                {
+                    if (!valid_vals)
+                        goto err;
+                    while (*p && *p != sep)
+                        p++;
+                }
+                else
+                {
+                   *d = *p++ - '0';
+                    while (isdigit(*p))
+                       *d = (*d * 10) + (*p++ - '0');
+                    valid = true;
+                }
 
-                *d = *p++ - '0';
-
-                while (isdigit(*p))
-                   *d = (*d * 10) + (*p++ - '0');
-
                 break;
 
 #ifdef HAVE_LCD_COLOR
@@ -1276,10 +1289,18 @@
                 d = va_arg(ap, int*);
 
                 if (hex_to_rgb(p, d) < 0)
-                    goto err;
+                {
+                    if (!valid_vals)
+                        goto err;
+                    while (*p && *p != sep)
+                        p++;
+                }
+                else
+                {
+                    p += 6;
+                    valid = true;
+                }
 
-                p += 6;
-
                 break;
 #endif
 
@@ -1288,9 +1309,17 @@
                 d = va_arg(ap, int*);
 
                 if (is0123(*p))
+                {
                     *d = *p++ - '0';
+                    valid = true;
+                }
+                else if (!valid_vals)
+                    goto err;
                 else
-                    goto err;
+                {
+                    while (*p && *p != sep)
+                        p++;
+                }
 
                 break;
 #endif
@@ -1299,6 +1328,9 @@
                 goto err;
                 break;
         }
+        if (valid_vals && valid)
+            *valid_vals |= (1<<i);
+        i++;
     }
 
     va_end(ap);