2007-04-04 14:41:40 +00:00
|
|
|
/***************************************************************************
|
|
|
|
* __________ __ ___.
|
|
|
|
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
|
|
|
|
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
|
|
|
|
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
|
|
|
|
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
|
|
|
|
* \/ \/ \/ \/ \/
|
|
|
|
* $Id$
|
|
|
|
*
|
|
|
|
* Copyright (C) 2007 Nicolas Pennequin, Dan Everton, Matthias Mohr
|
|
|
|
*
|
2008-06-28 18:10:04 +00:00
|
|
|
* 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.
|
2007-04-04 14:41:40 +00:00
|
|
|
*
|
|
|
|
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
|
|
|
* KIND, either express or implied.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2008-03-26 18:18:22 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
2008-04-28 16:18:04 +00:00
|
|
|
#include <stdlib.h>
|
2009-09-06 16:54:04 +00:00
|
|
|
#include "config.h"
|
2008-03-26 23:35:34 +00:00
|
|
|
#include "file.h"
|
|
|
|
#include "misc.h"
|
2008-05-19 14:37:16 +00:00
|
|
|
#include "plugin.h"
|
2009-08-09 16:16:55 +00:00
|
|
|
#include "viewport.h"
|
2008-05-19 14:37:16 +00:00
|
|
|
|
2008-03-26 18:18:22 +00:00
|
|
|
#ifdef __PCTOOL__
|
2008-08-29 21:08:38 +00:00
|
|
|
#ifdef WPSEDITOR
|
|
|
|
#include "proxy.h"
|
|
|
|
#include "sysfont.h"
|
|
|
|
#else
|
2009-08-21 18:15:20 +00:00
|
|
|
#include "action.h"
|
2008-08-29 21:08:38 +00:00
|
|
|
#include "checkwps.h"
|
2009-01-29 20:49:43 +00:00
|
|
|
#include "audio.h"
|
2008-03-26 18:18:22 +00:00
|
|
|
#define DEBUGF printf
|
2008-08-29 21:08:38 +00:00
|
|
|
#endif /*WPSEDITOR*/
|
2008-03-26 18:18:22 +00:00
|
|
|
#else
|
|
|
|
#include "debug.h"
|
2009-09-26 00:58:32 +00:00
|
|
|
#include "language.h"
|
2008-08-29 21:08:38 +00:00
|
|
|
#endif /*__PCTOOL__*/
|
2008-03-26 18:18:22 +00:00
|
|
|
|
2007-04-04 14:41:40 +00:00
|
|
|
#include <ctype.h>
|
|
|
|
#include <stdbool.h>
|
2008-03-26 18:18:22 +00:00
|
|
|
#include "font.h"
|
|
|
|
|
2009-07-27 07:21:05 +00:00
|
|
|
#include "wps_internals.h"
|
2009-08-06 04:33:35 +00:00
|
|
|
#include "skin_engine.h"
|
2007-04-04 14:41:40 +00:00
|
|
|
#include "settings.h"
|
2008-12-07 16:20:35 +00:00
|
|
|
#include "settings_list.h"
|
2007-04-04 14:41:40 +00:00
|
|
|
|
|
|
|
#ifdef HAVE_LCD_BITMAP
|
|
|
|
#include "bmp.h"
|
|
|
|
#endif
|
2007-04-25 22:08:00 +00:00
|
|
|
|
2009-10-16 19:14:41 +00:00
|
|
|
#ifdef HAVE_ALBUMART
|
|
|
|
#include "playback.h"
|
|
|
|
#endif
|
|
|
|
|
2007-04-25 22:08:00 +00:00
|
|
|
#include "backdrop.h"
|
2007-04-04 14:41:40 +00:00
|
|
|
|
2007-11-14 22:02:41 +00:00
|
|
|
#define WPS_ERROR_INVALID_PARAM -1
|
|
|
|
|
2009-11-04 05:24:30 +00:00
|
|
|
/* which screen are we parsing for? */
|
|
|
|
static enum screen_type curr_screen;
|
|
|
|
|
2007-04-04 14:41:40 +00:00
|
|
|
/* level of current conditional.
|
|
|
|
-1 means we're not in a conditional. */
|
2007-04-04 15:47:51 +00:00
|
|
|
static int level = -1;
|
2007-04-04 14:41:40 +00:00
|
|
|
|
|
|
|
/* index of the last WPS_TOKEN_CONDITIONAL_OPTION
|
|
|
|
or WPS_TOKEN_CONDITIONAL_START in current level */
|
2007-04-04 15:47:51 +00:00
|
|
|
static int lastcond[WPS_MAX_COND_LEVEL];
|
2007-04-04 14:41:40 +00:00
|
|
|
|
|
|
|
/* index of the WPS_TOKEN_CONDITIONAL in current level */
|
2007-04-04 15:47:51 +00:00
|
|
|
static int condindex[WPS_MAX_COND_LEVEL];
|
2007-04-04 14:41:40 +00:00
|
|
|
|
|
|
|
/* number of condtional options in current level */
|
2007-04-04 15:47:51 +00:00
|
|
|
static int numoptions[WPS_MAX_COND_LEVEL];
|
2007-04-04 14:41:40 +00:00
|
|
|
|
2009-09-02 02:55:33 +00:00
|
|
|
/* line number, debug only */
|
|
|
|
static int line_number;
|
2007-04-24 00:57:04 +00:00
|
|
|
|
2009-08-18 05:30:59 +00:00
|
|
|
/* the current viewport */
|
|
|
|
static struct skin_viewport *curr_vp;
|
2009-09-02 02:55:33 +00:00
|
|
|
/* the current line, linked to the above viewport */
|
2009-09-02 06:23:01 +00:00
|
|
|
static struct skin_line *curr_line;
|
2009-08-18 05:30:59 +00:00
|
|
|
|
2007-04-04 14:41:40 +00:00
|
|
|
#ifdef HAVE_LCD_BITMAP
|
2007-06-05 14:57:07 +00:00
|
|
|
|
|
|
|
#if LCD_DEPTH > 1
|
2008-06-23 06:04:17 +00:00
|
|
|
#define MAX_BITMAPS (MAX_IMAGES+MAX_PROGRESSBARS+1) /* WPS images + pbar bitmap + backdrop */
|
2007-06-05 14:57:07 +00:00
|
|
|
#else
|
2008-06-23 06:04:17 +00:00
|
|
|
#define MAX_BITMAPS (MAX_IMAGES+MAX_PROGRESSBARS) /* WPS images + pbar bitmap */
|
2007-06-05 14:57:07 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#define PROGRESSBAR_BMP MAX_IMAGES
|
2008-06-23 06:04:17 +00:00
|
|
|
#define BACKDROP_BMP (MAX_BITMAPS-1)
|
2007-06-05 14:57:07 +00:00
|
|
|
|
2007-04-04 14:41:40 +00:00
|
|
|
/* pointers to the bitmap filenames in the WPS source */
|
2007-06-05 10:42:41 +00:00
|
|
|
static const char *bmp_names[MAX_BITMAPS];
|
2007-06-05 14:57:07 +00:00
|
|
|
|
|
|
|
#endif /* HAVE_LCD_BITMAP */
|
2007-04-04 14:41:40 +00:00
|
|
|
|
2008-12-09 18:15:19 +00:00
|
|
|
#if defined(DEBUG) || defined(SIMULATOR)
|
2007-04-24 23:58:57 +00:00
|
|
|
/* debugging function */
|
|
|
|
extern void print_debug_info(struct wps_data *data, int fail, int line);
|
2009-08-19 05:07:12 +00:00
|
|
|
extern void debug_skin_usage(void);
|
2007-04-04 14:41:40 +00:00
|
|
|
#endif
|
|
|
|
|
2007-04-08 04:01:06 +00:00
|
|
|
/* Function for parsing of details for a token. At the moment the
|
|
|
|
function is called, the token type has already been set. The
|
|
|
|
function must fill in the details and possibly add more tokens
|
|
|
|
to the token array. It should return the number of chars that
|
|
|
|
has been consumed.
|
|
|
|
|
|
|
|
wps_bufptr points to the char following the tag (i.e. where
|
|
|
|
details begin).
|
|
|
|
token is the pointer to the 'main' token being parsed
|
|
|
|
*/
|
|
|
|
typedef int (*wps_tag_parse_func)(const char *wps_bufptr,
|
|
|
|
struct wps_token *token, struct wps_data *wps_data);
|
2007-04-04 14:41:40 +00:00
|
|
|
|
|
|
|
struct wps_tag {
|
|
|
|
enum wps_token_type type;
|
2007-04-05 10:21:49 +00:00
|
|
|
const char name[3];
|
2007-04-04 14:41:40 +00:00
|
|
|
unsigned char refresh_type;
|
2007-04-05 10:21:49 +00:00
|
|
|
const wps_tag_parse_func parse_func;
|
2007-04-04 14:41:40 +00:00
|
|
|
};
|
2009-04-20 01:41:56 +00:00
|
|
|
static int skip_end_of_line(const char *wps_bufptr);
|
2007-04-04 14:41:40 +00:00
|
|
|
/* prototypes of all special parse functions : */
|
2008-10-11 12:20:09 +00:00
|
|
|
static int parse_timeout(const char *wps_bufptr,
|
2007-04-08 04:01:06 +00:00
|
|
|
struct wps_token *token, struct wps_data *wps_data);
|
|
|
|
static int parse_progressbar(const char *wps_bufptr,
|
|
|
|
struct wps_token *token, struct wps_data *wps_data);
|
|
|
|
static int parse_dir_level(const char *wps_bufptr,
|
|
|
|
struct wps_token *token, struct wps_data *wps_data);
|
2009-09-26 00:58:32 +00:00
|
|
|
static int parse_setting_and_lang(const char *wps_bufptr,
|
2008-12-07 16:20:35 +00:00
|
|
|
struct wps_token *token, struct wps_data *wps_data);
|
2009-09-13 12:24:14 +00:00
|
|
|
|
2007-04-04 14:41:40 +00:00
|
|
|
#ifdef HAVE_LCD_BITMAP
|
2008-06-23 06:04:17 +00:00
|
|
|
static int parse_viewport_display(const char *wps_bufptr,
|
|
|
|
struct wps_token *token, struct wps_data *wps_data);
|
2008-03-21 19:38:00 +00:00
|
|
|
static int parse_viewport(const char *wps_bufptr,
|
|
|
|
struct wps_token *token, struct wps_data *wps_data);
|
2007-04-08 04:01:06 +00:00
|
|
|
static int parse_statusbar_enable(const char *wps_bufptr,
|
|
|
|
struct wps_token *token, struct wps_data *wps_data);
|
|
|
|
static int parse_statusbar_disable(const char *wps_bufptr,
|
|
|
|
struct wps_token *token, struct wps_data *wps_data);
|
|
|
|
static int parse_image_display(const char *wps_bufptr,
|
|
|
|
struct wps_token *token, struct wps_data *wps_data);
|
|
|
|
static int parse_image_load(const char *wps_bufptr,
|
|
|
|
struct wps_token *token, struct wps_data *wps_data);
|
2007-04-04 14:41:40 +00:00
|
|
|
#endif /*HAVE_LCD_BITMAP */
|
2008-06-23 06:17:22 +00:00
|
|
|
#if (LCD_DEPTH > 1) || (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1))
|
|
|
|
static int parse_image_special(const char *wps_bufptr,
|
|
|
|
struct wps_token *token, struct wps_data *wps_data);
|
|
|
|
#endif
|
2007-11-11 12:29:37 +00:00
|
|
|
#ifdef HAVE_ALBUMART
|
|
|
|
static int parse_albumart_load(const char *wps_bufptr,
|
|
|
|
struct wps_token *token, struct wps_data *wps_data);
|
2009-09-07 02:36:56 +00:00
|
|
|
static int parse_albumart_display(const char *wps_bufptr,
|
2007-11-11 12:29:37 +00:00
|
|
|
struct wps_token *token, struct wps_data *wps_data);
|
|
|
|
#endif /* HAVE_ALBUMART */
|
2009-04-20 01:41:56 +00:00
|
|
|
#ifdef HAVE_TOUCHSCREEN
|
|
|
|
static int parse_touchregion(const char *wps_bufptr,
|
|
|
|
struct wps_token *token, struct wps_data *wps_data);
|
|
|
|
#else
|
|
|
|
static int fulline_tag_not_supported(const char *wps_bufptr,
|
|
|
|
struct wps_token *token, struct wps_data *wps_data)
|
|
|
|
{
|
|
|
|
(void)token; (void)wps_data;
|
|
|
|
return skip_end_of_line(wps_bufptr);
|
|
|
|
}
|
|
|
|
#define parse_touchregion fulline_tag_not_supported
|
2009-09-13 12:24:14 +00:00
|
|
|
#endif
|
2007-06-16 20:33:30 +00:00
|
|
|
#ifdef CONFIG_RTC
|
|
|
|
#define WPS_RTC_REFRESH WPS_REFRESH_DYNAMIC
|
|
|
|
#else
|
|
|
|
#define WPS_RTC_REFRESH WPS_REFRESH_STATIC
|
|
|
|
#endif
|
|
|
|
|
2007-04-04 14:41:40 +00:00
|
|
|
/* array of available tags - those with more characters have to go first
|
|
|
|
(e.g. "xl" and "xd" before "x"). It needs to end with the unknown token. */
|
|
|
|
static const struct wps_tag all_tags[] = {
|
|
|
|
|
2007-04-05 10:21:49 +00:00
|
|
|
{ WPS_TOKEN_ALIGN_CENTER, "ac", 0, NULL },
|
|
|
|
{ WPS_TOKEN_ALIGN_LEFT, "al", 0, NULL },
|
|
|
|
{ WPS_TOKEN_ALIGN_RIGHT, "ar", 0, NULL },
|
2007-04-04 14:41:40 +00:00
|
|
|
|
2007-04-05 10:21:49 +00:00
|
|
|
{ WPS_TOKEN_BATTERY_PERCENT, "bl", WPS_REFRESH_DYNAMIC, NULL },
|
|
|
|
{ WPS_TOKEN_BATTERY_VOLTS, "bv", WPS_REFRESH_DYNAMIC, NULL },
|
|
|
|
{ WPS_TOKEN_BATTERY_TIME, "bt", WPS_REFRESH_DYNAMIC, NULL },
|
|
|
|
{ WPS_TOKEN_BATTERY_SLEEPTIME, "bs", WPS_REFRESH_DYNAMIC, NULL },
|
2007-04-04 14:41:40 +00:00
|
|
|
#if CONFIG_CHARGING >= CHARGING_MONITOR
|
2007-04-05 10:21:49 +00:00
|
|
|
{ WPS_TOKEN_BATTERY_CHARGING, "bc", WPS_REFRESH_DYNAMIC, NULL },
|
2007-04-04 14:41:40 +00:00
|
|
|
#endif
|
|
|
|
#if CONFIG_CHARGING
|
2007-04-05 10:21:49 +00:00
|
|
|
{ WPS_TOKEN_BATTERY_CHARGER_CONNECTED,"bp", WPS_REFRESH_DYNAMIC, NULL },
|
2007-04-04 14:41:40 +00:00
|
|
|
#endif
|
2009-11-22 19:09:54 +00:00
|
|
|
#ifdef HAVE_USB_POWER
|
2009-12-03 05:36:23 +00:00
|
|
|
{ WPS_TOKEN_USB_POWERED, "bu", WPS_REFRESH_DYNAMIC, NULL },
|
2009-11-22 19:09:54 +00:00
|
|
|
#endif
|
2007-04-04 14:41:40 +00:00
|
|
|
|
2009-05-16 11:22:41 +00:00
|
|
|
{ WPS_TOKEN_RTC_PRESENT , "cc", WPS_REFRESH_STATIC, NULL },
|
2007-06-16 20:33:30 +00:00
|
|
|
{ WPS_TOKEN_RTC_DAY_OF_MONTH, "cd", WPS_RTC_REFRESH, NULL },
|
|
|
|
{ WPS_TOKEN_RTC_DAY_OF_MONTH_BLANK_PADDED,"ce", WPS_RTC_REFRESH, NULL },
|
2007-11-27 01:41:59 +00:00
|
|
|
{ WPS_TOKEN_RTC_12HOUR_CFG, "cf", WPS_RTC_REFRESH, NULL },
|
2007-06-16 20:33:30 +00:00
|
|
|
{ WPS_TOKEN_RTC_HOUR_24_ZERO_PADDED, "cH", WPS_RTC_REFRESH, NULL },
|
|
|
|
{ WPS_TOKEN_RTC_HOUR_24, "ck", WPS_RTC_REFRESH, NULL },
|
|
|
|
{ WPS_TOKEN_RTC_HOUR_12_ZERO_PADDED, "cI", WPS_RTC_REFRESH, NULL },
|
|
|
|
{ WPS_TOKEN_RTC_HOUR_12, "cl", WPS_RTC_REFRESH, NULL },
|
|
|
|
{ WPS_TOKEN_RTC_MONTH, "cm", WPS_RTC_REFRESH, NULL },
|
|
|
|
{ WPS_TOKEN_RTC_MINUTE, "cM", WPS_RTC_REFRESH, NULL },
|
|
|
|
{ WPS_TOKEN_RTC_SECOND, "cS", WPS_RTC_REFRESH, NULL },
|
|
|
|
{ WPS_TOKEN_RTC_YEAR_2_DIGITS, "cy", WPS_RTC_REFRESH, NULL },
|
|
|
|
{ WPS_TOKEN_RTC_YEAR_4_DIGITS, "cY", WPS_RTC_REFRESH, NULL },
|
|
|
|
{ WPS_TOKEN_RTC_AM_PM_UPPER, "cP", WPS_RTC_REFRESH, NULL },
|
|
|
|
{ WPS_TOKEN_RTC_AM_PM_LOWER, "cp", WPS_RTC_REFRESH, NULL },
|
|
|
|
{ WPS_TOKEN_RTC_WEEKDAY_NAME, "ca", WPS_RTC_REFRESH, NULL },
|
|
|
|
{ WPS_TOKEN_RTC_MONTH_NAME, "cb", WPS_RTC_REFRESH, NULL },
|
|
|
|
{ WPS_TOKEN_RTC_DAY_OF_WEEK_START_MON, "cu", WPS_RTC_REFRESH, NULL },
|
|
|
|
{ WPS_TOKEN_RTC_DAY_OF_WEEK_START_SUN, "cw", WPS_RTC_REFRESH, NULL },
|
2007-04-04 14:41:40 +00:00
|
|
|
|
|
|
|
/* current file */
|
2007-04-05 10:21:49 +00:00
|
|
|
{ WPS_TOKEN_FILE_BITRATE, "fb", WPS_REFRESH_STATIC, NULL },
|
|
|
|
{ WPS_TOKEN_FILE_CODEC, "fc", WPS_REFRESH_STATIC, NULL },
|
|
|
|
{ WPS_TOKEN_FILE_FREQUENCY, "ff", WPS_REFRESH_STATIC, NULL },
|
2007-05-21 13:41:43 +00:00
|
|
|
{ WPS_TOKEN_FILE_FREQUENCY_KHZ, "fk", WPS_REFRESH_STATIC, NULL },
|
2007-04-05 10:21:49 +00:00
|
|
|
{ WPS_TOKEN_FILE_NAME_WITH_EXTENSION, "fm", WPS_REFRESH_STATIC, NULL },
|
|
|
|
{ WPS_TOKEN_FILE_NAME, "fn", WPS_REFRESH_STATIC, NULL },
|
|
|
|
{ WPS_TOKEN_FILE_PATH, "fp", WPS_REFRESH_STATIC, NULL },
|
|
|
|
{ WPS_TOKEN_FILE_SIZE, "fs", WPS_REFRESH_STATIC, NULL },
|
|
|
|
{ WPS_TOKEN_FILE_VBR, "fv", WPS_REFRESH_STATIC, NULL },
|
2007-05-02 17:51:01 +00:00
|
|
|
{ WPS_TOKEN_FILE_DIRECTORY, "d", WPS_REFRESH_STATIC,
|
|
|
|
parse_dir_level },
|
2007-04-04 14:41:40 +00:00
|
|
|
|
|
|
|
/* next file */
|
2009-04-06 00:39:43 +00:00
|
|
|
{ WPS_TOKEN_FILE_BITRATE, "Fb", WPS_REFRESH_STATIC, NULL },
|
|
|
|
{ WPS_TOKEN_FILE_CODEC, "Fc", WPS_REFRESH_STATIC, NULL },
|
|
|
|
{ WPS_TOKEN_FILE_FREQUENCY, "Ff", WPS_REFRESH_STATIC, NULL },
|
|
|
|
{ WPS_TOKEN_FILE_FREQUENCY_KHZ, "Fk", WPS_REFRESH_STATIC, NULL },
|
|
|
|
{ WPS_TOKEN_FILE_NAME_WITH_EXTENSION, "Fm", WPS_REFRESH_STATIC, NULL },
|
|
|
|
{ WPS_TOKEN_FILE_NAME, "Fn", WPS_REFRESH_STATIC, NULL },
|
|
|
|
{ WPS_TOKEN_FILE_PATH, "Fp", WPS_REFRESH_STATIC, NULL },
|
|
|
|
{ WPS_TOKEN_FILE_SIZE, "Fs", WPS_REFRESH_STATIC, NULL },
|
|
|
|
{ WPS_TOKEN_FILE_VBR, "Fv", WPS_REFRESH_STATIC, NULL },
|
|
|
|
{ WPS_TOKEN_FILE_DIRECTORY, "D", WPS_REFRESH_STATIC,
|
2007-05-02 17:51:01 +00:00
|
|
|
parse_dir_level },
|
2007-04-04 14:41:40 +00:00
|
|
|
|
|
|
|
/* current metadata */
|
2007-04-05 10:21:49 +00:00
|
|
|
{ WPS_TOKEN_METADATA_ARTIST, "ia", WPS_REFRESH_STATIC, NULL },
|
|
|
|
{ WPS_TOKEN_METADATA_COMPOSER, "ic", WPS_REFRESH_STATIC, NULL },
|
|
|
|
{ WPS_TOKEN_METADATA_ALBUM, "id", WPS_REFRESH_STATIC, NULL },
|
|
|
|
{ WPS_TOKEN_METADATA_ALBUM_ARTIST, "iA", WPS_REFRESH_STATIC, NULL },
|
2007-08-08 10:19:56 +00:00
|
|
|
{ WPS_TOKEN_METADATA_GROUPING, "iG", WPS_REFRESH_STATIC, NULL },
|
2007-04-05 10:21:49 +00:00
|
|
|
{ WPS_TOKEN_METADATA_GENRE, "ig", WPS_REFRESH_STATIC, NULL },
|
2007-08-03 10:00:42 +00:00
|
|
|
{ WPS_TOKEN_METADATA_DISC_NUMBER, "ik", WPS_REFRESH_STATIC, NULL },
|
2007-04-05 10:21:49 +00:00
|
|
|
{ WPS_TOKEN_METADATA_TRACK_NUMBER, "in", WPS_REFRESH_STATIC, NULL },
|
|
|
|
{ WPS_TOKEN_METADATA_TRACK_TITLE, "it", WPS_REFRESH_STATIC, NULL },
|
|
|
|
{ WPS_TOKEN_METADATA_VERSION, "iv", WPS_REFRESH_STATIC, NULL },
|
|
|
|
{ WPS_TOKEN_METADATA_YEAR, "iy", WPS_REFRESH_STATIC, NULL },
|
2007-05-02 17:51:01 +00:00
|
|
|
{ WPS_TOKEN_METADATA_COMMENT, "iC", WPS_REFRESH_STATIC, NULL },
|
2007-04-04 14:41:40 +00:00
|
|
|
|
|
|
|
/* next metadata */
|
2009-04-06 00:39:43 +00:00
|
|
|
{ WPS_TOKEN_METADATA_ARTIST, "Ia", WPS_REFRESH_STATIC, NULL },
|
|
|
|
{ WPS_TOKEN_METADATA_COMPOSER, "Ic", WPS_REFRESH_STATIC, NULL },
|
|
|
|
{ WPS_TOKEN_METADATA_ALBUM, "Id", WPS_REFRESH_STATIC, NULL },
|
|
|
|
{ WPS_TOKEN_METADATA_ALBUM_ARTIST, "IA", WPS_REFRESH_STATIC, NULL },
|
|
|
|
{ WPS_TOKEN_METADATA_GROUPING, "IG", WPS_REFRESH_STATIC, NULL },
|
|
|
|
{ WPS_TOKEN_METADATA_GENRE, "Ig", WPS_REFRESH_STATIC, NULL },
|
|
|
|
{ WPS_TOKEN_METADATA_DISC_NUMBER, "Ik", WPS_REFRESH_STATIC, NULL },
|
|
|
|
{ WPS_TOKEN_METADATA_TRACK_NUMBER, "In", WPS_REFRESH_STATIC, NULL },
|
|
|
|
{ WPS_TOKEN_METADATA_TRACK_TITLE, "It", WPS_REFRESH_STATIC, NULL },
|
|
|
|
{ WPS_TOKEN_METADATA_VERSION, "Iv", WPS_REFRESH_STATIC, NULL },
|
|
|
|
{ WPS_TOKEN_METADATA_YEAR, "Iy", WPS_REFRESH_STATIC, NULL },
|
|
|
|
{ WPS_TOKEN_METADATA_COMMENT, "IC", WPS_REFRESH_STATIC, NULL },
|
2007-04-04 14:41:40 +00:00
|
|
|
|
2007-04-04 15:47:51 +00:00
|
|
|
#if (CONFIG_CODEC != MAS3507D)
|
2007-04-05 10:21:49 +00:00
|
|
|
{ WPS_TOKEN_SOUND_PITCH, "Sp", WPS_REFRESH_DYNAMIC, NULL },
|
2007-04-04 14:41:40 +00:00
|
|
|
#endif
|
2009-11-09 17:57:17 +00:00
|
|
|
#if (CONFIG_CODEC == SWCODEC)
|
|
|
|
{ WPS_TOKEN_SOUND_SPEED, "Ss", WPS_REFRESH_DYNAMIC, NULL },
|
|
|
|
#endif
|
2007-04-04 14:41:40 +00:00
|
|
|
#if (CONFIG_LED == LED_VIRTUAL) || defined(HAVE_REMOTE_LCD)
|
2007-04-05 10:21:49 +00:00
|
|
|
{ WPS_TOKEN_VLED_HDD, "lh", WPS_REFRESH_DYNAMIC, NULL },
|
2007-04-04 14:41:40 +00:00
|
|
|
#endif
|
|
|
|
|
2007-04-05 10:21:49 +00:00
|
|
|
{ WPS_TOKEN_MAIN_HOLD, "mh", WPS_REFRESH_DYNAMIC, NULL },
|
2007-06-25 20:54:11 +00:00
|
|
|
|
2007-04-04 14:41:40 +00:00
|
|
|
#ifdef HAS_REMOTE_BUTTON_HOLD
|
2007-04-05 10:21:49 +00:00
|
|
|
{ WPS_TOKEN_REMOTE_HOLD, "mr", WPS_REFRESH_DYNAMIC, NULL },
|
2007-11-14 00:45:04 +00:00
|
|
|
#else
|
|
|
|
{ WPS_TOKEN_UNKNOWN, "mr", 0, NULL },
|
2007-04-04 14:41:40 +00:00
|
|
|
#endif
|
|
|
|
|
2007-04-05 10:21:49 +00:00
|
|
|
{ WPS_TOKEN_REPEAT_MODE, "mm", WPS_REFRESH_DYNAMIC, NULL },
|
|
|
|
{ WPS_TOKEN_PLAYBACK_STATUS, "mp", WPS_REFRESH_DYNAMIC, NULL },
|
2009-09-13 12:24:14 +00:00
|
|
|
{ WPS_TOKEN_BUTTON_VOLUME, "mv", WPS_REFRESH_DYNAMIC,
|
2008-10-11 12:20:09 +00:00
|
|
|
parse_timeout },
|
2007-04-04 14:41:40 +00:00
|
|
|
|
|
|
|
#ifdef HAVE_LCD_BITMAP
|
2007-05-02 17:51:01 +00:00
|
|
|
{ WPS_TOKEN_PEAKMETER, "pm", WPS_REFRESH_PEAK_METER, NULL },
|
2007-04-04 14:41:40 +00:00
|
|
|
#else
|
2007-05-02 17:51:01 +00:00
|
|
|
{ WPS_TOKEN_PLAYER_PROGRESSBAR, "pf",
|
|
|
|
WPS_REFRESH_DYNAMIC | WPS_REFRESH_PLAYER_PROGRESS, parse_progressbar },
|
2007-04-04 14:41:40 +00:00
|
|
|
#endif
|
2007-05-02 17:51:01 +00:00
|
|
|
{ WPS_TOKEN_PROGRESSBAR, "pb", WPS_REFRESH_PLAYER_PROGRESS,
|
|
|
|
parse_progressbar },
|
2007-04-04 14:41:40 +00:00
|
|
|
|
2007-04-05 10:21:49 +00:00
|
|
|
{ WPS_TOKEN_VOLUME, "pv", WPS_REFRESH_DYNAMIC, NULL },
|
2007-04-04 14:41:40 +00:00
|
|
|
|
2007-07-25 14:14:47 +00:00
|
|
|
{ WPS_TOKEN_TRACK_ELAPSED_PERCENT, "px", WPS_REFRESH_DYNAMIC, NULL },
|
2007-04-05 10:21:49 +00:00
|
|
|
{ WPS_TOKEN_TRACK_TIME_ELAPSED, "pc", WPS_REFRESH_DYNAMIC, NULL },
|
|
|
|
{ WPS_TOKEN_TRACK_TIME_REMAINING, "pr", WPS_REFRESH_DYNAMIC, NULL },
|
|
|
|
{ WPS_TOKEN_TRACK_LENGTH, "pt", WPS_REFRESH_STATIC, NULL },
|
2007-04-04 14:41:40 +00:00
|
|
|
|
2007-04-05 10:21:49 +00:00
|
|
|
{ WPS_TOKEN_PLAYLIST_POSITION, "pp", WPS_REFRESH_STATIC, NULL },
|
|
|
|
{ WPS_TOKEN_PLAYLIST_ENTRIES, "pe", WPS_REFRESH_STATIC, NULL },
|
|
|
|
{ WPS_TOKEN_PLAYLIST_NAME, "pn", WPS_REFRESH_STATIC, NULL },
|
|
|
|
{ WPS_TOKEN_PLAYLIST_SHUFFLE, "ps", WPS_REFRESH_DYNAMIC, NULL },
|
2007-04-04 14:41:40 +00:00
|
|
|
|
2007-11-14 22:02:41 +00:00
|
|
|
#ifdef HAVE_TAGCACHE
|
2007-04-05 10:21:49 +00:00
|
|
|
{ WPS_TOKEN_DATABASE_PLAYCOUNT, "rp", WPS_REFRESH_DYNAMIC, NULL },
|
|
|
|
{ WPS_TOKEN_DATABASE_RATING, "rr", WPS_REFRESH_DYNAMIC, NULL },
|
2007-04-15 15:46:46 +00:00
|
|
|
{ WPS_TOKEN_DATABASE_AUTOSCORE, "ra", WPS_REFRESH_DYNAMIC, NULL },
|
2007-11-14 22:02:41 +00:00
|
|
|
#endif
|
|
|
|
|
2007-04-04 14:41:40 +00:00
|
|
|
#if CONFIG_CODEC == SWCODEC
|
2007-04-05 10:21:49 +00:00
|
|
|
{ WPS_TOKEN_REPLAYGAIN, "rg", WPS_REFRESH_STATIC, NULL },
|
2007-04-12 16:15:34 +00:00
|
|
|
{ WPS_TOKEN_CROSSFADE, "xf", WPS_REFRESH_DYNAMIC, NULL },
|
2007-04-04 14:41:40 +00:00
|
|
|
#endif
|
|
|
|
|
2007-04-08 04:01:06 +00:00
|
|
|
{ WPS_NO_TOKEN, "s", WPS_REFRESH_SCROLL, NULL },
|
2008-10-11 12:20:09 +00:00
|
|
|
{ WPS_TOKEN_SUBLINE_TIMEOUT, "t", 0, parse_timeout },
|
2007-04-04 14:41:40 +00:00
|
|
|
|
|
|
|
#ifdef HAVE_LCD_BITMAP
|
2007-04-08 04:01:06 +00:00
|
|
|
{ WPS_NO_TOKEN, "we", 0, parse_statusbar_enable },
|
|
|
|
{ WPS_NO_TOKEN, "wd", 0, parse_statusbar_disable },
|
2007-04-04 14:41:40 +00:00
|
|
|
|
2007-04-05 10:21:49 +00:00
|
|
|
{ WPS_NO_TOKEN, "xl", 0, parse_image_load },
|
2007-04-04 14:41:40 +00:00
|
|
|
|
2007-05-02 17:51:01 +00:00
|
|
|
{ WPS_TOKEN_IMAGE_PRELOAD_DISPLAY, "xd", WPS_REFRESH_STATIC,
|
|
|
|
parse_image_display },
|
2007-04-04 14:41:40 +00:00
|
|
|
|
2007-04-08 04:01:06 +00:00
|
|
|
{ WPS_TOKEN_IMAGE_DISPLAY, "x", 0, parse_image_load },
|
2007-11-11 12:29:37 +00:00
|
|
|
#ifdef HAVE_ALBUMART
|
|
|
|
{ WPS_NO_TOKEN, "Cl", 0, parse_albumart_load },
|
2009-09-07 02:36:56 +00:00
|
|
|
{ WPS_TOKEN_ALBUMART_DISPLAY, "C", WPS_REFRESH_STATIC, parse_albumart_display },
|
2007-11-11 12:29:37 +00:00
|
|
|
#endif
|
2008-03-21 19:38:00 +00:00
|
|
|
|
2009-09-13 12:24:14 +00:00
|
|
|
{ WPS_VIEWPORT_ENABLE, "Vd", WPS_REFRESH_DYNAMIC,
|
2008-06-23 06:04:17 +00:00
|
|
|
parse_viewport_display },
|
2008-03-21 19:38:00 +00:00
|
|
|
{ WPS_NO_TOKEN, "V", 0, parse_viewport },
|
|
|
|
|
2008-03-29 01:14:10 +00:00
|
|
|
#if (LCD_DEPTH > 1) || (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1))
|
2007-04-08 04:01:06 +00:00
|
|
|
{ WPS_TOKEN_IMAGE_BACKDROP, "X", 0, parse_image_special },
|
2007-04-04 14:41:40 +00:00
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
2009-09-26 00:58:32 +00:00
|
|
|
{ WPS_TOKEN_SETTING, "St", WPS_REFRESH_DYNAMIC,
|
|
|
|
parse_setting_and_lang },
|
|
|
|
{ WPS_TOKEN_TRANSLATEDSTRING, "Sx", WPS_REFRESH_STATIC,
|
|
|
|
parse_setting_and_lang },
|
2009-11-15 21:39:39 +00:00
|
|
|
{ WPS_TOKEN_LANG_IS_RTL , "Sr", WPS_REFRESH_STATIC, NULL },
|
2009-09-26 00:58:32 +00:00
|
|
|
|
2009-04-20 01:41:56 +00:00
|
|
|
{ WPS_TOKEN_LASTTOUCH, "Tl", WPS_REFRESH_DYNAMIC, parse_timeout },
|
2009-10-16 19:14:33 +00:00
|
|
|
{ WPS_TOKEN_CURRENT_SCREEN, "cs", WPS_REFRESH_DYNAMIC, NULL },
|
2009-04-20 01:41:56 +00:00
|
|
|
{ WPS_NO_TOKEN, "T", 0, parse_touchregion },
|
2009-11-03 07:58:10 +00:00
|
|
|
|
|
|
|
|
|
|
|
/* Recording Tokens */
|
|
|
|
{ WPS_TOKEN_HAVE_RECORDING, "Rp", WPS_REFRESH_STATIC, NULL },
|
|
|
|
#ifdef HAVE_RECORDING
|
|
|
|
{ WPS_TOKEN_REC_FREQ, "Rf", WPS_REFRESH_DYNAMIC, NULL },
|
|
|
|
{ WPS_TOKEN_REC_ENCODER, "Re", WPS_REFRESH_DYNAMIC, NULL },
|
|
|
|
{ WPS_TOKEN_REC_BITRATE, "Rb", WPS_REFRESH_DYNAMIC, NULL },
|
|
|
|
{ WPS_TOKEN_REC_MONO, "Rm", WPS_REFRESH_DYNAMIC, NULL },
|
|
|
|
#endif
|
2007-04-08 04:01:06 +00:00
|
|
|
{ WPS_TOKEN_UNKNOWN, "", 0, NULL }
|
|
|
|
/* the array MUST end with an empty string (first char is \0) */
|
2007-04-04 14:41:40 +00:00
|
|
|
};
|
|
|
|
|
2009-08-16 18:23:00 +00:00
|
|
|
|
2009-09-13 12:24:14 +00:00
|
|
|
/* add a skin_token_list item to the list chain. ALWAYS appended because some of the
|
2009-08-16 18:23:00 +00:00
|
|
|
* chains require the order to be kept.
|
|
|
|
*/
|
|
|
|
static void add_to_ll_chain(struct skin_token_list **list, struct skin_token_list *item)
|
|
|
|
{
|
|
|
|
if (*list == NULL)
|
|
|
|
*list = item;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
struct skin_token_list *t = *list;
|
|
|
|
while (t->next)
|
|
|
|
t = t->next;
|
2009-09-13 12:24:14 +00:00
|
|
|
t->next = item;
|
2009-08-16 18:23:00 +00:00
|
|
|
}
|
2009-09-13 12:24:14 +00:00
|
|
|
}
|
2009-11-01 15:48:31 +00:00
|
|
|
|
|
|
|
/* traverse the image linked-list for an image */
|
|
|
|
#ifdef HAVE_LCD_BITMAP
|
|
|
|
struct gui_img* find_image(char label, struct wps_data *data)
|
|
|
|
{
|
|
|
|
struct skin_token_list *list = data->images;
|
|
|
|
while (list)
|
|
|
|
{
|
|
|
|
struct gui_img *img = (struct gui_img *)list->token->value.data;
|
|
|
|
if (img->label == label)
|
|
|
|
return img;
|
|
|
|
list = list->next;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* traverse the viewport linked list for a viewport */
|
|
|
|
struct skin_viewport* find_viewport(char label, struct wps_data *data)
|
|
|
|
{
|
|
|
|
struct skin_token_list *list = data->viewports;
|
|
|
|
while (list)
|
|
|
|
{
|
|
|
|
struct skin_viewport *vp = (struct skin_viewport *)list->token->value.data;
|
|
|
|
if (vp->label == label)
|
|
|
|
return vp;
|
|
|
|
list = list->next;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-08-16 18:23:00 +00:00
|
|
|
/* create and init a new wpsll item.
|
|
|
|
* passing NULL to token will alloc a new one.
|
2009-08-16 21:22:57 +00:00
|
|
|
* You should only pass NULL for the token when the token type (table above)
|
|
|
|
* is WPS_NO_TOKEN which means it is not stored automatically in the skins token array
|
2009-08-16 18:23:00 +00:00
|
|
|
*/
|
|
|
|
static struct skin_token_list *new_skin_token_list_item(struct wps_token *token,
|
|
|
|
void* token_data)
|
|
|
|
{
|
|
|
|
struct skin_token_list *llitem = skin_buffer_alloc(sizeof(struct skin_token_list));
|
|
|
|
if (!token)
|
|
|
|
token = skin_buffer_alloc(sizeof(struct wps_token));
|
|
|
|
if (!llitem || !token)
|
|
|
|
return NULL;
|
|
|
|
llitem->next = NULL;
|
|
|
|
llitem->token = token;
|
2009-12-03 05:36:23 +00:00
|
|
|
if (token_data)
|
|
|
|
llitem->token->value.data = token_data;
|
2009-08-16 18:23:00 +00:00
|
|
|
return llitem;
|
2009-09-13 12:24:14 +00:00
|
|
|
}
|
2009-08-16 18:23:00 +00:00
|
|
|
|
2007-04-08 04:01:06 +00:00
|
|
|
/* 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 */
|
2007-04-05 14:09:59 +00:00
|
|
|
static int skip_end_of_line(const char *wps_bufptr)
|
2007-04-04 14:41:40 +00:00
|
|
|
{
|
2009-09-02 02:55:33 +00:00
|
|
|
line_number++;
|
2007-04-04 14:41:40 +00:00
|
|
|
int skip = 0;
|
2007-04-05 14:09:59 +00:00
|
|
|
while(*(wps_bufptr + skip) != '\n')
|
2007-04-04 14:41:40 +00:00
|
|
|
skip++;
|
|
|
|
return ++skip;
|
|
|
|
}
|
|
|
|
|
2007-04-08 04:01:06 +00:00
|
|
|
/* Starts a new subline in the current line during parsing */
|
2009-09-02 06:23:01 +00:00
|
|
|
static bool skin_start_new_subline(struct skin_line *line, int curr_token)
|
2007-04-15 02:59:34 +00:00
|
|
|
{
|
2009-09-02 06:23:01 +00:00
|
|
|
struct skin_subline *subline = skin_buffer_alloc(sizeof(struct skin_subline));
|
2009-09-02 02:55:33 +00:00
|
|
|
if (!subline)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
subline->first_token_idx = curr_token;
|
|
|
|
subline->next = NULL;
|
2009-09-13 12:24:14 +00:00
|
|
|
|
2009-09-02 02:55:33 +00:00
|
|
|
subline->line_type = 0;
|
|
|
|
subline->time_mult = 0;
|
2009-09-13 12:24:14 +00:00
|
|
|
|
2009-09-02 02:55:33 +00:00
|
|
|
line->curr_subline->last_token_idx = curr_token-1;
|
|
|
|
line->curr_subline->next = subline;
|
|
|
|
line->curr_subline = subline;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2009-09-02 06:23:01 +00:00
|
|
|
static bool skin_start_new_line(struct skin_viewport *vp, int curr_token)
|
2009-09-02 02:55:33 +00:00
|
|
|
{
|
2009-09-02 06:23:01 +00:00
|
|
|
struct skin_line *line = skin_buffer_alloc(sizeof(struct skin_line));
|
|
|
|
struct skin_subline *subline = NULL;
|
2009-09-02 02:55:33 +00:00
|
|
|
if (!line)
|
|
|
|
return false;
|
2009-09-13 12:24:14 +00:00
|
|
|
|
|
|
|
/* init the subline */
|
2009-09-02 02:55:33 +00:00
|
|
|
subline = &line->sublines;
|
|
|
|
subline->first_token_idx = curr_token;
|
2009-09-13 12:24:14 +00:00
|
|
|
subline->next = NULL;
|
2009-09-02 02:55:33 +00:00
|
|
|
subline->line_type = 0;
|
|
|
|
subline->time_mult = 0;
|
2009-09-13 12:24:14 +00:00
|
|
|
|
2009-09-02 02:55:33 +00:00
|
|
|
/* init the new line */
|
2009-09-13 12:24:14 +00:00
|
|
|
line->curr_subline = &line->sublines;
|
2009-09-02 02:55:33 +00:00
|
|
|
line->next = NULL;
|
|
|
|
line->subline_expire_time = 0;
|
2009-09-13 12:24:14 +00:00
|
|
|
|
2009-09-02 02:55:33 +00:00
|
|
|
/* connect to curr_line and vp pointers.
|
|
|
|
* 1) close the previous lines subline
|
|
|
|
* 2) connect to vp pointer
|
|
|
|
* 3) connect to curr_line global pointer
|
|
|
|
*/
|
|
|
|
if (curr_line)
|
|
|
|
{
|
|
|
|
curr_line->curr_subline->last_token_idx = curr_token - 1;
|
|
|
|
curr_line->next = line;
|
|
|
|
curr_line->curr_subline = NULL;
|
|
|
|
}
|
|
|
|
curr_line = line;
|
|
|
|
if (!vp->lines)
|
|
|
|
vp->lines = line;
|
|
|
|
return true;
|
2007-04-08 04:01:06 +00:00
|
|
|
}
|
|
|
|
|
2007-04-04 14:41:40 +00:00
|
|
|
#ifdef HAVE_LCD_BITMAP
|
|
|
|
|
2007-04-08 04:01:06 +00:00
|
|
|
static int parse_statusbar_enable(const char *wps_bufptr,
|
|
|
|
struct wps_token *token,
|
|
|
|
struct wps_data *wps_data)
|
2007-04-04 14:41:40 +00:00
|
|
|
{
|
2007-04-08 04:01:06 +00:00
|
|
|
(void)token; /* Kill warnings */
|
2007-04-04 14:41:40 +00:00
|
|
|
wps_data->wps_sb_tag = true;
|
2007-04-08 04:01:06 +00:00
|
|
|
wps_data->show_sb_on_wps = true;
|
2009-08-18 05:30:59 +00:00
|
|
|
struct skin_viewport *default_vp = find_viewport(VP_DEFAULT_LABEL, wps_data);
|
2009-11-04 05:24:30 +00:00
|
|
|
viewport_set_defaults(&default_vp->vp, curr_screen);
|
2007-04-08 04:01:06 +00:00
|
|
|
return skip_end_of_line(wps_bufptr);
|
|
|
|
}
|
2007-04-04 14:41:40 +00:00
|
|
|
|
2007-04-08 04:01:06 +00:00
|
|
|
static int parse_statusbar_disable(const char *wps_bufptr,
|
|
|
|
struct wps_token *token,
|
|
|
|
struct wps_data *wps_data)
|
|
|
|
{
|
|
|
|
(void)token; /* Kill warnings */
|
|
|
|
wps_data->wps_sb_tag = true;
|
|
|
|
wps_data->show_sb_on_wps = false;
|
2009-08-18 05:30:59 +00:00
|
|
|
struct skin_viewport *default_vp = find_viewport(VP_DEFAULT_LABEL, wps_data);
|
2009-11-04 05:24:30 +00:00
|
|
|
viewport_set_fullscreen(&default_vp->vp, curr_screen);
|
2007-04-05 14:09:59 +00:00
|
|
|
return skip_end_of_line(wps_bufptr);
|
2007-04-04 14:41:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int get_image_id(int c)
|
|
|
|
{
|
|
|
|
if(c >= 'a' && c <= 'z')
|
|
|
|
return c - 'a';
|
|
|
|
else if(c >= 'A' && c <= 'Z')
|
|
|
|
return c - 'A' + 26;
|
|
|
|
else
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *get_image_filename(const char *start, const char* bmpdir,
|
|
|
|
char *buf, int buf_size)
|
|
|
|
{
|
|
|
|
const char *end = strchr(start, '|');
|
|
|
|
|
2008-11-24 22:16:07 +00:00
|
|
|
if ( !end || (end - start) >= (buf_size - (int)ROCKBOX_DIR_LEN - 2) )
|
2007-04-04 14:41:40 +00:00
|
|
|
{
|
|
|
|
buf = "\0";
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
int bmpdirlen = strlen(bmpdir);
|
|
|
|
|
|
|
|
strcpy(buf, bmpdir);
|
|
|
|
buf[bmpdirlen] = '/';
|
|
|
|
memcpy( &buf[bmpdirlen + 1], start, end - start);
|
|
|
|
buf[bmpdirlen + 1 + end - start] = 0;
|
|
|
|
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
2007-04-08 04:01:06 +00:00
|
|
|
static int parse_image_display(const char *wps_bufptr,
|
|
|
|
struct wps_token *token,
|
|
|
|
struct wps_data *wps_data)
|
2007-04-04 14:41:40 +00:00
|
|
|
{
|
2009-08-18 07:17:51 +00:00
|
|
|
char label = wps_bufptr[0];
|
2008-03-23 20:31:00 +00:00
|
|
|
int subimage;
|
2009-12-03 05:36:23 +00:00
|
|
|
struct gui_img *img;;
|
2007-04-14 16:20:33 +00:00
|
|
|
|
2009-08-17 07:16:57 +00:00
|
|
|
/* sanity check */
|
2009-08-18 07:17:51 +00:00
|
|
|
img = find_image(label, wps_data);
|
2009-08-17 07:16:57 +00:00
|
|
|
if (!img)
|
2009-08-18 07:17:51 +00:00
|
|
|
{
|
2009-09-07 07:51:58 +00:00
|
|
|
token->value.i = label; /* so debug works */
|
2009-08-17 07:16:57 +00:00
|
|
|
return WPS_ERROR_INVALID_PARAM;
|
2009-08-18 07:17:51 +00:00
|
|
|
}
|
2007-04-14 16:20:33 +00:00
|
|
|
|
2008-03-23 20:31:00 +00:00
|
|
|
if ((subimage = get_image_id(wps_bufptr[1])) != -1)
|
|
|
|
{
|
2009-08-17 07:16:57 +00:00
|
|
|
if (subimage >= img->num_subimages)
|
2008-03-24 00:03:05 +00:00
|
|
|
return WPS_ERROR_INVALID_PARAM;
|
|
|
|
|
2008-03-23 20:31:00 +00:00
|
|
|
/* Store sub-image number to display in high bits */
|
2009-08-18 07:17:51 +00:00
|
|
|
token->value.i = label | (subimage << 8);
|
2008-03-23 20:31:00 +00:00
|
|
|
return 2; /* We have consumed 2 bytes */
|
|
|
|
} else {
|
2009-08-18 07:17:51 +00:00
|
|
|
token->value.i = label;
|
2008-03-23 20:31:00 +00:00
|
|
|
return 1; /* We have consumed 1 byte */
|
|
|
|
}
|
2007-04-04 14:41:40 +00:00
|
|
|
}
|
|
|
|
|
2007-04-08 04:01:06 +00:00
|
|
|
static int parse_image_load(const char *wps_bufptr,
|
|
|
|
struct wps_token *token,
|
|
|
|
struct wps_data *wps_data)
|
2007-04-04 14:41:40 +00:00
|
|
|
{
|
2007-04-05 14:09:59 +00:00
|
|
|
const char *ptr = wps_bufptr;
|
2008-03-23 20:31:00 +00:00
|
|
|
const char *pos;
|
2008-03-21 13:41:35 +00:00
|
|
|
const char* filename;
|
|
|
|
const char* id;
|
2008-03-23 20:31:00 +00:00
|
|
|
const char *newline;
|
2008-03-21 13:41:35 +00:00
|
|
|
int x,y;
|
2009-12-03 05:36:23 +00:00
|
|
|
struct gui_img *img;
|
2009-09-13 12:24:14 +00:00
|
|
|
|
2007-04-04 14:41:40 +00:00
|
|
|
/* format: %x|n|filename.bmp|x|y|
|
2009-09-13 12:24:14 +00:00
|
|
|
or %xl|n|filename.bmp|x|y|
|
2008-03-23 20:31:00 +00:00
|
|
|
or %xl|n|filename.bmp|x|y|num_subimages|
|
|
|
|
*/
|
2007-04-04 14:41:40 +00:00
|
|
|
|
2008-03-21 13:41:35 +00:00
|
|
|
if (*ptr != '|')
|
|
|
|
return WPS_ERROR_INVALID_PARAM;
|
|
|
|
|
|
|
|
ptr++;
|
2007-04-12 16:15:34 +00:00
|
|
|
|
2008-06-05 08:20:39 +00:00
|
|
|
if (!(ptr = parse_list("ssdd", NULL, '|', ptr, &id, &filename, &x, &y)))
|
2008-03-21 13:41:35 +00:00
|
|
|
return WPS_ERROR_INVALID_PARAM;
|
|
|
|
|
|
|
|
/* Check there is a terminating | */
|
|
|
|
if (*ptr != '|')
|
|
|
|
return WPS_ERROR_INVALID_PARAM;
|
2007-04-12 16:15:34 +00:00
|
|
|
|
|
|
|
/* check the image number and load state */
|
2009-08-18 07:17:51 +00:00
|
|
|
if(find_image(*id, wps_data))
|
2007-04-12 16:15:34 +00:00
|
|
|
{
|
2007-11-14 22:02:41 +00:00
|
|
|
/* Invalid image ID */
|
|
|
|
return WPS_ERROR_INVALID_PARAM;
|
2007-04-12 16:15:34 +00:00
|
|
|
}
|
2009-08-16 18:23:00 +00:00
|
|
|
img = skin_buffer_alloc(sizeof(struct gui_img));
|
2009-12-03 05:36:23 +00:00
|
|
|
if (!img)
|
|
|
|
return WPS_ERROR_INVALID_PARAM;
|
2008-03-21 13:41:35 +00:00
|
|
|
/* save a pointer to the filename */
|
2009-08-16 18:23:00 +00:00
|
|
|
img->bm.data = (char*)filename;
|
2009-08-18 07:17:51 +00:00
|
|
|
img->label = *id;
|
2009-08-16 18:23:00 +00:00
|
|
|
img->x = x;
|
|
|
|
img->y = y;
|
2009-12-03 05:36:23 +00:00
|
|
|
img->num_subimages = 1;
|
2009-08-16 18:23:00 +00:00
|
|
|
img->always_display = false;
|
2007-04-12 16:15:34 +00:00
|
|
|
|
2008-03-21 19:38:00 +00:00
|
|
|
/* save current viewport */
|
2009-08-18 05:30:59 +00:00
|
|
|
img->vp = &curr_vp->vp;
|
2008-03-21 19:38:00 +00:00
|
|
|
|
2007-04-12 16:15:34 +00:00
|
|
|
if (token->type == WPS_TOKEN_IMAGE_DISPLAY)
|
2008-03-23 20:31:00 +00:00
|
|
|
{
|
2009-08-16 18:23:00 +00:00
|
|
|
img->always_display = true;
|
2008-03-23 20:31:00 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Parse the (optional) number of sub-images */
|
|
|
|
ptr++;
|
|
|
|
newline = strchr(ptr, '\n');
|
|
|
|
pos = strchr(ptr, '|');
|
|
|
|
if (pos && pos < newline)
|
2009-08-16 18:23:00 +00:00
|
|
|
img->num_subimages = atoi(ptr);
|
2008-03-24 10:13:47 +00:00
|
|
|
|
2009-08-16 18:23:00 +00:00
|
|
|
if (img->num_subimages <= 0)
|
2008-03-24 10:13:47 +00:00
|
|
|
return WPS_ERROR_INVALID_PARAM;
|
2008-03-23 20:31:00 +00:00
|
|
|
}
|
2009-12-03 05:36:23 +00:00
|
|
|
struct skin_token_list *item = new_skin_token_list_item(NULL, img);
|
|
|
|
if (!item)
|
|
|
|
return WPS_ERROR_INVALID_PARAM;
|
|
|
|
add_to_ll_chain(&wps_data->images, item);
|
2007-04-12 16:15:34 +00:00
|
|
|
|
2007-04-04 14:41:40 +00:00
|
|
|
/* Skip the rest of the line */
|
2007-04-05 14:09:59 +00:00
|
|
|
return skip_end_of_line(wps_bufptr);
|
2007-04-04 14:41:40 +00:00
|
|
|
}
|
|
|
|
|
2008-06-23 06:04:17 +00:00
|
|
|
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 > 'z')
|
|
|
|
{
|
|
|
|
/* invalid viewport tag */
|
|
|
|
return WPS_ERROR_INVALID_PARAM;
|
|
|
|
}
|
|
|
|
token->value.i = letter;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2008-03-21 19:38:00 +00:00
|
|
|
static int parse_viewport(const char *wps_bufptr,
|
|
|
|
struct wps_token *token,
|
|
|
|
struct wps_data *wps_data)
|
|
|
|
{
|
2008-06-05 08:20:39 +00:00
|
|
|
(void)token; /* Kill warnings */
|
2008-03-21 19:38:00 +00:00
|
|
|
const char *ptr = wps_bufptr;
|
2009-08-09 16:16:55 +00:00
|
|
|
|
2009-08-18 05:30:59 +00:00
|
|
|
struct skin_viewport *skin_vp = skin_buffer_alloc(sizeof(struct skin_viewport));
|
2009-09-13 12:24:14 +00:00
|
|
|
|
2008-06-23 06:04:17 +00:00
|
|
|
/* check for the optional letter to signify its a hideable viewport */
|
|
|
|
/* %Vl|<label>|<rest of tags>| */
|
2009-08-18 05:30:59 +00:00
|
|
|
skin_vp->hidden_flags = 0;
|
|
|
|
skin_vp->label = VP_NO_LABEL;
|
|
|
|
skin_vp->pb = NULL;
|
2009-09-02 02:55:33 +00:00
|
|
|
skin_vp->lines = NULL;
|
2009-09-04 06:17:38 +00:00
|
|
|
if (curr_line)
|
2009-09-13 12:15:08 +00:00
|
|
|
{
|
|
|
|
curr_line->curr_subline->last_token_idx = wps_data->num_tokens
|
|
|
|
- (wps_data->num_tokens > 0 ? 1 : 0);
|
|
|
|
}
|
|
|
|
|
2009-09-02 02:55:33 +00:00
|
|
|
curr_line = NULL;
|
2009-09-02 06:23:01 +00:00
|
|
|
if (!skin_start_new_line(skin_vp, wps_data->num_tokens))
|
2009-09-02 02:55:33 +00:00
|
|
|
return WPS_ERROR_INVALID_PARAM;
|
2009-10-19 15:28:15 +00:00
|
|
|
|
|
|
|
|
|
|
|
if (*ptr == 'i')
|
|
|
|
{
|
|
|
|
skin_vp->label = VP_INFO_LABEL;
|
|
|
|
skin_vp->hidden_flags = VP_NEVER_VISIBLE;
|
|
|
|
++ptr;
|
|
|
|
}
|
|
|
|
else if (*ptr == 'l')
|
2008-06-23 06:04:17 +00:00
|
|
|
{
|
|
|
|
if (*(ptr+1) == '|')
|
|
|
|
{
|
|
|
|
char label = *(ptr+2);
|
2008-06-25 08:08:39 +00:00
|
|
|
if (label >= 'a' && label <= 'z')
|
2008-06-23 06:04:17 +00:00
|
|
|
{
|
2009-08-18 05:30:59 +00:00
|
|
|
skin_vp->hidden_flags = VP_DRAW_HIDEABLE;
|
|
|
|
skin_vp->label = label;
|
2008-06-23 06:04:17 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
return WPS_ERROR_INVALID_PARAM; /* malformed token: e.g. %Cl7 */
|
|
|
|
ptr += 3;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (*ptr != '|')
|
|
|
|
return WPS_ERROR_INVALID_PARAM;
|
2009-09-13 12:24:14 +00:00
|
|
|
|
2008-06-23 06:04:17 +00:00
|
|
|
ptr++;
|
2009-08-18 05:30:59 +00:00
|
|
|
struct viewport *vp = &skin_vp->vp;
|
2008-06-23 06:04:17 +00:00
|
|
|
/* format: %V|x|y|width|height|font|fg_pattern|bg_pattern| */
|
2008-03-21 19:38:00 +00:00
|
|
|
|
2009-11-04 07:14:02 +00:00
|
|
|
if (!(ptr = viewport_parse_viewport(vp, curr_screen, ptr, '|')))
|
2009-08-09 16:16:55 +00:00
|
|
|
return WPS_ERROR_INVALID_PARAM;
|
2008-03-21 19:38:00 +00:00
|
|
|
|
2009-10-11 20:15:22 +00:00
|
|
|
vp->flags &= ~VP_FLAG_ALIGN_RIGHT; /* ignore right-to-left languages */
|
2008-03-24 18:40:13 +00:00
|
|
|
/* Check for trailing | */
|
|
|
|
if (*ptr != '|')
|
|
|
|
return WPS_ERROR_INVALID_PARAM;
|
|
|
|
|
2008-03-21 19:38:00 +00:00
|
|
|
|
2009-08-18 05:30:59 +00:00
|
|
|
struct skin_token_list *list = new_skin_token_list_item(NULL, skin_vp);
|
|
|
|
if (!list)
|
|
|
|
return WPS_ERROR_INVALID_PARAM;
|
|
|
|
add_to_ll_chain(&wps_data->viewports, list);
|
2009-09-13 12:24:14 +00:00
|
|
|
curr_vp = skin_vp;
|
2008-03-21 19:38:00 +00:00
|
|
|
/* Skip the rest of the line */
|
|
|
|
return skip_end_of_line(wps_bufptr);
|
2008-03-22 00:31:22 +00:00
|
|
|
}
|
2008-03-21 19:38:00 +00:00
|
|
|
|
2008-12-08 08:32:30 +00:00
|
|
|
#if (LCD_DEPTH > 1) || (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1))
|
|
|
|
static int parse_image_special(const char *wps_bufptr,
|
|
|
|
struct wps_token *token,
|
|
|
|
struct wps_data *wps_data)
|
|
|
|
{
|
|
|
|
(void)wps_data; /* kill warning */
|
|
|
|
(void)token;
|
|
|
|
const char *pos = NULL;
|
|
|
|
const char *newline;
|
|
|
|
|
|
|
|
pos = strchr(wps_bufptr + 1, '|');
|
|
|
|
newline = strchr(wps_bufptr, '\n');
|
|
|
|
|
|
|
|
if (pos > newline)
|
|
|
|
return WPS_ERROR_INVALID_PARAM;
|
|
|
|
#if LCD_DEPTH > 1
|
|
|
|
if (token->type == WPS_TOKEN_IMAGE_BACKDROP)
|
|
|
|
{
|
|
|
|
/* format: %X|filename.bmp| */
|
|
|
|
bmp_names[BACKDROP_BMP] = wps_bufptr + 1;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Skip the rest of the line */
|
|
|
|
return skip_end_of_line(wps_bufptr);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#endif /* HAVE_LCD_BITMAP */
|
|
|
|
|
2009-09-26 00:58:32 +00:00
|
|
|
static int parse_setting_and_lang(const char *wps_bufptr,
|
|
|
|
struct wps_token *token,
|
|
|
|
struct wps_data *wps_data)
|
2008-12-07 16:20:35 +00:00
|
|
|
{
|
2009-09-26 00:58:32 +00:00
|
|
|
/* NOTE: both the string validations that happen in here will
|
|
|
|
* automatically PASS on checkwps because its too hard to get
|
|
|
|
* settings_list.c and englinsh.lang built for it.
|
|
|
|
* If that ever changes remove the #ifndef __PCTOOL__'s here
|
|
|
|
*/
|
2008-12-07 16:20:35 +00:00
|
|
|
(void)wps_data;
|
|
|
|
const char *ptr = wps_bufptr;
|
|
|
|
const char *end;
|
2009-09-26 00:58:32 +00:00
|
|
|
int i = 0;
|
|
|
|
char temp[64];
|
2008-12-07 16:20:35 +00:00
|
|
|
|
|
|
|
/* Find the setting's cfg_name */
|
|
|
|
if (*ptr != '|')
|
|
|
|
return WPS_ERROR_INVALID_PARAM;
|
|
|
|
ptr++;
|
|
|
|
end = strchr(ptr,'|');
|
|
|
|
if (!end)
|
|
|
|
return WPS_ERROR_INVALID_PARAM;
|
2009-09-26 00:58:32 +00:00
|
|
|
strlcpy(temp, ptr,end-ptr+1);
|
|
|
|
|
|
|
|
if (token->type == WPS_TOKEN_TRANSLATEDSTRING)
|
|
|
|
{
|
|
|
|
#ifndef __PCTOOL__
|
|
|
|
i = lang_english_to_id(temp);
|
|
|
|
if (i < 0)
|
|
|
|
return WPS_ERROR_INVALID_PARAM;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Find the setting */
|
|
|
|
for (i=0; i<nb_settings; i++)
|
|
|
|
if (settings[i].cfg_name &&
|
|
|
|
!strncmp(settings[i].cfg_name,ptr,end-ptr) &&
|
|
|
|
/* prevent matches on cfg_name prefixes */
|
|
|
|
strlen(settings[i].cfg_name)==(size_t)(end-ptr))
|
|
|
|
break;
|
|
|
|
#ifndef __PCTOOL__
|
|
|
|
if (i == nb_settings)
|
|
|
|
return WPS_ERROR_INVALID_PARAM;
|
|
|
|
#endif
|
|
|
|
}
|
2008-12-07 16:20:35 +00:00
|
|
|
/* Store the setting number */
|
|
|
|
token->value.i = i;
|
|
|
|
|
|
|
|
/* Skip the rest of the line */
|
|
|
|
return end-ptr+2;
|
|
|
|
}
|
|
|
|
|
2008-03-21 19:38:00 +00:00
|
|
|
|
2007-04-08 04:01:06 +00:00
|
|
|
static int parse_dir_level(const char *wps_bufptr,
|
|
|
|
struct wps_token *token,
|
|
|
|
struct wps_data *wps_data)
|
2007-04-04 14:41:40 +00:00
|
|
|
{
|
2007-04-05 14:09:59 +00:00
|
|
|
char val[] = { *wps_bufptr, '\0' };
|
2007-04-08 04:01:06 +00:00
|
|
|
token->value.i = atoi(val);
|
|
|
|
(void)wps_data; /* Kill warnings */
|
2007-04-04 14:41:40 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2008-10-11 12:20:09 +00:00
|
|
|
static int parse_timeout(const char *wps_bufptr,
|
|
|
|
struct wps_token *token,
|
|
|
|
struct wps_data *wps_data)
|
2007-04-04 14:41:40 +00:00
|
|
|
{
|
|
|
|
int skip = 0;
|
|
|
|
int val = 0;
|
|
|
|
bool have_point = false;
|
|
|
|
bool have_tenth = false;
|
|
|
|
|
2007-04-08 04:01:06 +00:00
|
|
|
(void)wps_data; /* Kill the warning */
|
|
|
|
|
2007-04-05 14:09:59 +00:00
|
|
|
while ( isdigit(*wps_bufptr) || *wps_bufptr == '.' )
|
2007-04-04 14:41:40 +00:00
|
|
|
{
|
2007-04-05 14:09:59 +00:00
|
|
|
if (*wps_bufptr != '.')
|
2007-04-04 14:41:40 +00:00
|
|
|
{
|
|
|
|
val *= 10;
|
2007-04-05 14:09:59 +00:00
|
|
|
val += *wps_bufptr - '0';
|
2007-04-04 14:41:40 +00:00
|
|
|
if (have_point)
|
|
|
|
{
|
|
|
|
have_tenth = true;
|
2007-04-05 14:09:59 +00:00
|
|
|
wps_bufptr++;
|
2007-04-04 14:41:40 +00:00
|
|
|
skip++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
have_point = true;
|
|
|
|
|
2007-04-05 14:09:59 +00:00
|
|
|
wps_bufptr++;
|
2007-04-04 14:41:40 +00:00
|
|
|
skip++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (have_tenth == false)
|
|
|
|
val *= 10;
|
|
|
|
|
2008-10-11 13:49:38 +00:00
|
|
|
if (val == 0 && skip == 0)
|
|
|
|
{
|
|
|
|
/* decide what to do if no value was specified */
|
|
|
|
switch (token->type)
|
|
|
|
{
|
|
|
|
case WPS_TOKEN_SUBLINE_TIMEOUT:
|
|
|
|
return -1;
|
|
|
|
case WPS_TOKEN_BUTTON_VOLUME:
|
2008-11-22 10:31:33 +00:00
|
|
|
val = 10;
|
2008-10-11 13:49:38 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2007-04-08 04:01:06 +00:00
|
|
|
token->value.i = val;
|
2007-04-06 14:18:07 +00:00
|
|
|
|
2007-04-04 14:41:40 +00:00
|
|
|
return skip;
|
|
|
|
}
|
|
|
|
|
2007-04-08 04:01:06 +00:00
|
|
|
static int parse_progressbar(const char *wps_bufptr,
|
|
|
|
struct wps_token *token,
|
|
|
|
struct wps_data *wps_data)
|
2007-04-04 14:41:40 +00:00
|
|
|
{
|
2008-06-23 06:04:17 +00:00
|
|
|
/* %pb or %pb|filename|x|y|width|height|
|
|
|
|
using - for any of the params uses "sane" values */
|
2007-04-04 14:41:40 +00:00
|
|
|
#ifdef HAVE_LCD_BITMAP
|
2008-06-23 06:04:17 +00:00
|
|
|
enum {
|
|
|
|
PB_FILENAME = 0,
|
|
|
|
PB_X,
|
|
|
|
PB_Y,
|
|
|
|
PB_WIDTH,
|
|
|
|
PB_HEIGHT
|
|
|
|
};
|
|
|
|
const char *filename;
|
2008-06-23 06:17:22 +00:00
|
|
|
int x, y, height, width;
|
|
|
|
uint32_t set = 0;
|
2008-06-23 06:04:17 +00:00
|
|
|
const char *ptr = wps_bufptr;
|
2009-08-16 18:23:00 +00:00
|
|
|
struct progressbar *pb = skin_buffer_alloc(sizeof(struct progressbar));
|
|
|
|
struct skin_token_list *item = new_skin_token_list_item(token, pb);
|
2009-09-13 12:24:14 +00:00
|
|
|
|
2009-12-03 05:36:23 +00:00
|
|
|
if (!pb || !item)
|
|
|
|
return WPS_ERROR_INVALID_PARAM;
|
2009-09-13 12:24:14 +00:00
|
|
|
|
2009-08-18 05:30:59 +00:00
|
|
|
struct viewport *vp = &curr_vp->vp;
|
2008-07-06 13:23:28 +00:00
|
|
|
#ifndef __PCTOOL__
|
2008-06-23 06:04:17 +00:00
|
|
|
int font_height = font_get(vp->font)->height;
|
2009-09-13 12:24:14 +00:00
|
|
|
#else
|
2008-07-06 13:23:28 +00:00
|
|
|
int font_height = 8;
|
|
|
|
#endif
|
2009-09-02 02:55:33 +00:00
|
|
|
/* we need to know what line number (viewport relative) this pb is,
|
|
|
|
* so count them... */
|
|
|
|
int line_num = -1;
|
2009-09-02 06:23:01 +00:00
|
|
|
struct skin_line *line = curr_vp->lines;
|
2009-09-02 02:55:33 +00:00
|
|
|
while (line)
|
|
|
|
{
|
|
|
|
line_num++;
|
|
|
|
line = line->next;
|
|
|
|
}
|
2008-06-23 06:04:17 +00:00
|
|
|
pb->have_bitmap_pb = false;
|
2009-12-03 05:36:23 +00:00
|
|
|
pb->bm.data = NULL; /* no bitmap specified */
|
2009-09-13 12:24:14 +00:00
|
|
|
|
2008-06-23 06:04:17 +00:00
|
|
|
if (*wps_bufptr != '|') /* regular old style */
|
|
|
|
{
|
|
|
|
pb->x = 0;
|
|
|
|
pb->width = vp->width;
|
|
|
|
pb->height = SYSFONT_HEIGHT-2;
|
2009-02-16 08:28:51 +00:00
|
|
|
pb->y = -line_num - 1; /* Will be computed during the rendering */
|
2008-06-23 06:04:17 +00:00
|
|
|
|
2009-08-18 05:30:59 +00:00
|
|
|
curr_vp->pb = pb;
|
2009-08-16 18:23:00 +00:00
|
|
|
add_to_ll_chain(&wps_data->progressbars, item);
|
2008-06-23 06:04:17 +00:00
|
|
|
return 0;
|
2007-04-04 14:41:40 +00:00
|
|
|
}
|
2008-06-23 06:04:17 +00:00
|
|
|
ptr = wps_bufptr + 1;
|
2009-09-13 12:24:14 +00:00
|
|
|
|
2008-06-23 06:04:17 +00:00
|
|
|
if (!(ptr = parse_list("sdddd", &set, '|', ptr, &filename,
|
|
|
|
&x, &y, &width, &height)))
|
|
|
|
return WPS_ERROR_INVALID_PARAM;
|
2008-10-22 21:35:38 +00:00
|
|
|
|
2008-06-23 06:04:17 +00:00
|
|
|
if (LIST_VALUE_PARSED(set, PB_FILENAME)) /* filename */
|
2009-08-16 18:23:00 +00:00
|
|
|
pb->bm.data = (char*)filename;
|
2008-10-22 21:35:38 +00:00
|
|
|
|
2008-06-23 06:04:17 +00:00
|
|
|
if (LIST_VALUE_PARSED(set, PB_X)) /* x */
|
|
|
|
pb->x = x;
|
|
|
|
else
|
|
|
|
pb->x = vp->x;
|
2008-10-22 21:35:38 +00:00
|
|
|
|
2008-06-23 06:04:17 +00:00
|
|
|
if (LIST_VALUE_PARSED(set, PB_WIDTH)) /* width */
|
2008-10-22 21:35:38 +00:00
|
|
|
{
|
|
|
|
/* A zero width causes a divide-by-zero error later, so reject it */
|
|
|
|
if (width == 0)
|
|
|
|
return WPS_ERROR_INVALID_PARAM;
|
|
|
|
|
2008-06-23 06:04:17 +00:00
|
|
|
pb->width = width;
|
2008-10-22 21:35:38 +00:00
|
|
|
}
|
2008-06-23 06:04:17 +00:00
|
|
|
else
|
|
|
|
pb->width = vp->width - pb->x;
|
2008-10-22 21:35:38 +00:00
|
|
|
|
2008-06-23 06:04:17 +00:00
|
|
|
if (LIST_VALUE_PARSED(set, PB_HEIGHT)) /* height, default to font height */
|
2008-10-22 21:35:38 +00:00
|
|
|
{
|
|
|
|
/* A zero height makes no sense - reject it */
|
|
|
|
if (height == 0)
|
|
|
|
return WPS_ERROR_INVALID_PARAM;
|
|
|
|
|
2008-06-23 06:04:17 +00:00
|
|
|
pb->height = height;
|
2008-10-22 21:35:38 +00:00
|
|
|
}
|
2008-06-23 06:04:17 +00:00
|
|
|
else
|
|
|
|
pb->height = font_height;
|
2008-10-22 21:35:38 +00:00
|
|
|
|
2008-06-23 06:04:17 +00:00
|
|
|
if (LIST_VALUE_PARSED(set, PB_Y)) /* y */
|
|
|
|
pb->y = y;
|
|
|
|
else
|
2009-02-16 08:28:51 +00:00
|
|
|
pb->y = -line_num - 1; /* Will be computed during the rendering */
|
2008-10-22 21:35:38 +00:00
|
|
|
|
2009-08-18 05:30:59 +00:00
|
|
|
curr_vp->pb = pb;
|
2009-08-16 18:23:00 +00:00
|
|
|
add_to_ll_chain(&wps_data->progressbars, item);
|
2008-10-22 21:35:38 +00:00
|
|
|
|
2008-06-23 06:04:17 +00:00
|
|
|
/* Skip the rest of the line */
|
|
|
|
return skip_end_of_line(wps_bufptr)-1;
|
2007-04-04 14:41:40 +00:00
|
|
|
#else
|
2009-08-16 18:32:25 +00:00
|
|
|
(void)token;
|
2007-04-04 14:41:40 +00:00
|
|
|
|
2007-04-05 14:09:59 +00:00
|
|
|
if (*(wps_bufptr-1) == 'f')
|
2007-04-04 14:41:40 +00:00
|
|
|
wps_data->full_line_progressbar = true;
|
|
|
|
else
|
|
|
|
wps_data->full_line_progressbar = false;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2007-11-11 12:29:37 +00:00
|
|
|
#ifdef HAVE_ALBUMART
|
|
|
|
static int parse_albumart_load(const char *wps_bufptr,
|
|
|
|
struct wps_token *token,
|
|
|
|
struct wps_data *wps_data)
|
|
|
|
{
|
2007-11-14 22:02:41 +00:00
|
|
|
const char *_pos, *newline;
|
2007-11-11 12:29:37 +00:00
|
|
|
bool parsing;
|
2009-10-16 19:14:41 +00:00
|
|
|
struct dim dimensions;
|
|
|
|
int albumart_slot;
|
2009-09-07 02:36:56 +00:00
|
|
|
struct skin_albumart *aa = skin_buffer_alloc(sizeof(struct skin_albumart));
|
2007-11-11 12:29:37 +00:00
|
|
|
(void)token; /* silence warning */
|
2009-09-07 02:36:56 +00:00
|
|
|
if (!aa)
|
|
|
|
return skip_end_of_line(wps_bufptr);
|
2007-11-11 12:29:37 +00:00
|
|
|
|
|
|
|
/* reset albumart info in wps */
|
2009-09-25 18:36:28 +00:00
|
|
|
aa->width = -1;
|
|
|
|
aa->height = -1;
|
|
|
|
aa->xalign = WPS_ALBUMART_ALIGN_CENTER; /* default */
|
|
|
|
aa->yalign = WPS_ALBUMART_ALIGN_CENTER; /* default */
|
2009-09-07 02:36:56 +00:00
|
|
|
aa->vp = &curr_vp->vp;
|
2007-11-11 12:29:37 +00:00
|
|
|
|
2008-12-09 23:07:59 +00:00
|
|
|
/* format: %Cl|x|y|[[l|c|r]mwidth]|[[t|c|b]mheight]| */
|
2007-11-11 12:29:37 +00:00
|
|
|
|
2007-11-14 22:02:41 +00:00
|
|
|
newline = strchr(wps_bufptr, '\n');
|
|
|
|
|
2007-11-11 12:29:37 +00:00
|
|
|
/* initial validation and parsing of x and y components */
|
|
|
|
if (*wps_bufptr != '|')
|
2007-11-14 22:02:41 +00:00
|
|
|
return WPS_ERROR_INVALID_PARAM; /* malformed token: e.g. %Cl7 */
|
2007-11-11 12:29:37 +00:00
|
|
|
|
|
|
|
_pos = wps_bufptr + 1;
|
2009-09-25 18:36:28 +00:00
|
|
|
_pos = parse_list("dd", NULL, '|', _pos, &aa->x, &aa->y);
|
2007-11-11 12:29:37 +00:00
|
|
|
|
2009-09-25 18:36:18 +00:00
|
|
|
if (!_pos || _pos > newline || *_pos != '|')
|
2007-11-14 22:02:41 +00:00
|
|
|
return WPS_ERROR_INVALID_PARAM; /* malformed token: no | after y coordinate
|
|
|
|
e.g. %Cl|7|59\n */
|
2007-11-11 12:29:37 +00:00
|
|
|
|
|
|
|
/* parsing width field */
|
|
|
|
parsing = true;
|
|
|
|
while (parsing)
|
|
|
|
{
|
|
|
|
/* apply each modifier in turn */
|
|
|
|
++_pos;
|
|
|
|
switch (*_pos)
|
|
|
|
{
|
|
|
|
case 'l':
|
|
|
|
case 'L':
|
|
|
|
case '+':
|
2009-09-25 18:36:28 +00:00
|
|
|
aa->xalign = WPS_ALBUMART_ALIGN_LEFT;
|
2007-11-11 12:29:37 +00:00
|
|
|
break;
|
|
|
|
case 'c':
|
|
|
|
case 'C':
|
2009-09-25 18:36:28 +00:00
|
|
|
aa->xalign = WPS_ALBUMART_ALIGN_CENTER;
|
2007-11-11 12:29:37 +00:00
|
|
|
break;
|
|
|
|
case 'r':
|
|
|
|
case 'R':
|
|
|
|
case '-':
|
2009-09-25 18:36:28 +00:00
|
|
|
aa->xalign = WPS_ALBUMART_ALIGN_RIGHT;
|
2007-11-11 12:29:37 +00:00
|
|
|
break;
|
|
|
|
case 'd':
|
|
|
|
case 'D':
|
|
|
|
case 'i':
|
|
|
|
case 'I':
|
|
|
|
case 's':
|
|
|
|
case 'S':
|
2008-12-09 23:07:59 +00:00
|
|
|
/* simply ignored */
|
2007-11-11 12:29:37 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
parsing = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* extract max width data */
|
|
|
|
if (*_pos != '|')
|
|
|
|
{
|
2009-12-04 13:10:06 +00:00
|
|
|
_pos = parse_list("d", NULL, '|', _pos, &aa->width);
|
|
|
|
if (!_pos || _pos > newline || *_pos != '|')
|
2007-11-14 22:02:41 +00:00
|
|
|
return WPS_ERROR_INVALID_PARAM;
|
2007-11-11 12:29:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* parsing height field */
|
|
|
|
parsing = true;
|
|
|
|
while (parsing)
|
|
|
|
{
|
|
|
|
/* apply each modifier in turn */
|
|
|
|
++_pos;
|
|
|
|
switch (*_pos)
|
|
|
|
{
|
|
|
|
case 't':
|
|
|
|
case 'T':
|
|
|
|
case '-':
|
2009-09-25 18:36:28 +00:00
|
|
|
aa->yalign = WPS_ALBUMART_ALIGN_TOP;
|
2007-11-11 12:29:37 +00:00
|
|
|
break;
|
|
|
|
case 'c':
|
|
|
|
case 'C':
|
2009-09-25 18:36:28 +00:00
|
|
|
aa->yalign = WPS_ALBUMART_ALIGN_CENTER;
|
2007-11-11 12:29:37 +00:00
|
|
|
break;
|
|
|
|
case 'b':
|
|
|
|
case 'B':
|
|
|
|
case '+':
|
2009-09-25 18:36:28 +00:00
|
|
|
aa->yalign = WPS_ALBUMART_ALIGN_BOTTOM;
|
2007-11-11 12:29:37 +00:00
|
|
|
break;
|
|
|
|
case 'd':
|
|
|
|
case 'D':
|
|
|
|
case 'i':
|
|
|
|
case 'I':
|
|
|
|
case 's':
|
|
|
|
case 'S':
|
2008-12-09 23:07:59 +00:00
|
|
|
/* simply ignored */
|
2007-11-11 12:29:37 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
parsing = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* extract max height data */
|
|
|
|
if (*_pos != '|')
|
|
|
|
{
|
2009-12-04 13:10:06 +00:00
|
|
|
_pos = parse_list("d", NULL, '|', _pos, &aa->height);
|
|
|
|
if (!_pos || _pos > newline || *_pos != '|')
|
|
|
|
return WPS_ERROR_INVALID_PARAM;
|
2007-11-11 12:29:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* if we got here, we parsed everything ok .. ! */
|
2009-09-25 18:36:28 +00:00
|
|
|
if (aa->width < 0)
|
|
|
|
aa->width = 0;
|
|
|
|
else if (aa->width > LCD_WIDTH)
|
|
|
|
aa->width = LCD_WIDTH;
|
2007-11-11 12:29:37 +00:00
|
|
|
|
2009-09-25 18:36:28 +00:00
|
|
|
if (aa->height < 0)
|
|
|
|
aa->height = 0;
|
|
|
|
else if (aa->height > LCD_HEIGHT)
|
|
|
|
aa->height = LCD_HEIGHT;
|
2007-11-11 12:29:37 +00:00
|
|
|
|
2009-09-25 18:36:28 +00:00
|
|
|
aa->state = WPS_ALBUMART_LOAD;
|
2009-09-07 02:36:56 +00:00
|
|
|
aa->draw = false;
|
|
|
|
wps_data->albumart = aa;
|
2007-11-11 12:29:37 +00:00
|
|
|
|
2009-10-16 19:14:41 +00:00
|
|
|
dimensions.width = aa->width;
|
|
|
|
dimensions.height = aa->height;
|
|
|
|
|
|
|
|
albumart_slot = playback_claim_aa_slot(&dimensions);
|
|
|
|
|
2009-12-04 13:10:06 +00:00
|
|
|
if (0 <= albumart_slot)
|
2009-10-16 19:14:41 +00:00
|
|
|
wps_data->playback_aa_slot = albumart_slot;
|
|
|
|
|
2007-11-11 12:29:37 +00:00
|
|
|
/* Skip the rest of the line */
|
|
|
|
return skip_end_of_line(wps_bufptr);
|
|
|
|
}
|
|
|
|
|
2009-09-07 02:36:56 +00:00
|
|
|
static int parse_albumart_display(const char *wps_bufptr,
|
2007-11-11 12:29:37 +00:00
|
|
|
struct wps_token *token,
|
|
|
|
struct wps_data *wps_data)
|
|
|
|
{
|
2009-09-07 02:36:56 +00:00
|
|
|
(void)wps_bufptr;
|
2009-09-18 05:45:15 +00:00
|
|
|
struct wps_token *prev = token-1;
|
2009-10-05 10:26:06 +00:00
|
|
|
if ((wps_data->num_tokens >= 1) && (prev->type == WPS_TOKEN_CONDITIONAL))
|
2009-09-18 05:15:18 +00:00
|
|
|
{
|
2009-09-18 05:45:15 +00:00
|
|
|
token->type = WPS_TOKEN_ALBUMART_FOUND;
|
2009-09-18 05:15:18 +00:00
|
|
|
}
|
|
|
|
else if (wps_data->albumart)
|
2007-11-12 01:31:42 +00:00
|
|
|
{
|
2009-09-07 02:36:56 +00:00
|
|
|
wps_data->albumart->vp = &curr_vp->vp;
|
2007-11-12 01:31:42 +00:00
|
|
|
}
|
2009-09-07 02:36:56 +00:00
|
|
|
#if 0
|
|
|
|
/* the old code did this so keep it here for now...
|
|
|
|
* this is to allow the posibility to showing the next tracks AA! */
|
|
|
|
if (wps_bufptr+1 == 'n')
|
|
|
|
return 1;
|
|
|
|
#endif
|
|
|
|
return 0;
|
2007-11-11 12:29:37 +00:00
|
|
|
};
|
|
|
|
#endif /* HAVE_ALBUMART */
|
|
|
|
|
2009-04-20 01:41:56 +00:00
|
|
|
#ifdef HAVE_TOUCHSCREEN
|
2009-09-13 12:24:14 +00:00
|
|
|
|
2009-12-20 18:04:07 +00:00
|
|
|
struct touchaction {const char* s; int action;};
|
|
|
|
static const struct touchaction touchactions[] = {
|
2009-04-20 01:41:56 +00:00
|
|
|
{"play", ACTION_WPS_PLAY }, {"stop", ACTION_WPS_STOP },
|
|
|
|
{"prev", ACTION_WPS_SKIPPREV }, {"next", ACTION_WPS_SKIPNEXT },
|
2009-05-17 06:25:18 +00:00
|
|
|
{"ffwd", ACTION_WPS_SEEKFWD }, {"rwd", ACTION_WPS_SEEKBACK },
|
2009-05-15 05:36:16 +00:00
|
|
|
{"menu", ACTION_WPS_MENU }, {"browse", ACTION_WPS_BROWSE },
|
2009-05-15 06:02:50 +00:00
|
|
|
{"shuffle", ACTION_TOUCH_SHUFFLE }, {"repmode", ACTION_TOUCH_REPMODE },
|
|
|
|
{"quickscreen", ACTION_WPS_QUICKSCREEN },{"contextmenu", ACTION_WPS_CONTEXT },
|
2009-08-17 12:46:21 +00:00
|
|
|
{"playlist", ACTION_WPS_VIEW_PLAYLIST }, {"pitch", ACTION_WPS_PITCHSCREEN},
|
2009-11-02 21:56:48 +00:00
|
|
|
{"voldown", ACTION_WPS_VOLDOWN}, {"volup", ACTION_WPS_VOLUP},
|
2009-04-20 01:41:56 +00:00
|
|
|
};
|
|
|
|
static int parse_touchregion(const char *wps_bufptr,
|
|
|
|
struct wps_token *token, struct wps_data *wps_data)
|
|
|
|
{
|
|
|
|
(void)token;
|
2009-07-22 21:14:47 +00:00
|
|
|
unsigned i, imax;
|
2009-08-16 21:22:57 +00:00
|
|
|
struct touchregion *region = NULL;
|
2009-04-20 01:41:56 +00:00
|
|
|
const char *ptr = wps_bufptr;
|
|
|
|
const char *action;
|
2009-08-09 17:30:05 +00:00
|
|
|
const char pb_string[] = "progressbar";
|
|
|
|
const char vol_string[] = "volume";
|
2009-04-20 01:41:56 +00:00
|
|
|
int x,y,w,h;
|
2009-09-13 12:24:14 +00:00
|
|
|
|
2009-04-20 01:41:56 +00:00
|
|
|
/* format: %T|x|y|width|height|action|
|
2009-05-17 06:25:18 +00:00
|
|
|
* if action starts with & the area must be held to happen
|
2009-04-20 01:41:56 +00:00
|
|
|
* action is one of:
|
|
|
|
* play - play/pause playback
|
|
|
|
* stop - stop playback, exit the wps
|
|
|
|
* prev - prev track
|
|
|
|
* next - next track
|
2009-05-17 06:25:18 +00:00
|
|
|
* ffwd - seek forward
|
|
|
|
* rwd - seek backwards
|
2009-04-20 01:41:56 +00:00
|
|
|
* menu - go back to the main menu
|
|
|
|
* browse - go back to the file/db browser
|
2009-05-15 05:36:16 +00:00
|
|
|
* shuffle - toggle shuffle mode
|
|
|
|
* repmode - cycle the repeat mode
|
2009-05-15 06:02:50 +00:00
|
|
|
* quickscreen - go into the quickscreen
|
|
|
|
* contextmenu - open the context menu
|
2009-08-17 12:46:21 +00:00
|
|
|
* playlist - go into the playlist
|
|
|
|
* pitch - go into the pitchscreen
|
2009-11-02 21:56:48 +00:00
|
|
|
* volup - increase volume by one step
|
|
|
|
* voldown - decrease volume by one step
|
2009-04-20 01:41:56 +00:00
|
|
|
*/
|
|
|
|
|
2009-07-22 22:10:25 +00:00
|
|
|
|
2009-08-16 21:22:57 +00:00
|
|
|
if (*ptr != '|')
|
2009-04-20 01:41:56 +00:00
|
|
|
return WPS_ERROR_INVALID_PARAM;
|
|
|
|
ptr++;
|
|
|
|
|
|
|
|
if (!(ptr = parse_list("dddds", NULL, '|', ptr, &x, &y, &w, &h, &action)))
|
|
|
|
return WPS_ERROR_INVALID_PARAM;
|
|
|
|
|
|
|
|
/* Check there is a terminating | */
|
|
|
|
if (*ptr != '|')
|
|
|
|
return WPS_ERROR_INVALID_PARAM;
|
2009-09-13 12:24:14 +00:00
|
|
|
|
2009-08-16 21:22:57 +00:00
|
|
|
region = skin_buffer_alloc(sizeof(struct touchregion));
|
|
|
|
if (!region)
|
|
|
|
return WPS_ERROR_INVALID_PARAM;
|
2009-09-13 12:24:14 +00:00
|
|
|
|
2009-04-20 01:41:56 +00:00
|
|
|
/* should probably do some bounds checking here with the viewport... but later */
|
|
|
|
region->action = ACTION_NONE;
|
|
|
|
region->x = x;
|
|
|
|
region->y = y;
|
|
|
|
region->width = w;
|
|
|
|
region->height = h;
|
2009-08-18 05:30:59 +00:00
|
|
|
region->wvp = curr_vp;
|
2009-09-13 12:24:14 +00:00
|
|
|
|
2009-08-09 17:30:05 +00:00
|
|
|
if(!strncmp(pb_string, action, sizeof(pb_string)-1)
|
|
|
|
&& *(action + sizeof(pb_string)-1) == '|')
|
|
|
|
region->type = WPS_TOUCHREGION_SCROLLBAR;
|
|
|
|
else if(!strncmp(vol_string, action, sizeof(vol_string)-1)
|
|
|
|
&& *(action + sizeof(vol_string)-1) == '|')
|
|
|
|
region->type = WPS_TOUCHREGION_VOLUME;
|
2009-08-03 04:43:34 +00:00
|
|
|
else
|
|
|
|
{
|
2009-08-09 17:30:05 +00:00
|
|
|
region->type = WPS_TOUCHREGION_ACTION;
|
|
|
|
|
|
|
|
if (*action == '&')
|
|
|
|
{
|
|
|
|
action++;
|
|
|
|
region->repeat = true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
region->repeat = false;
|
|
|
|
|
|
|
|
i = 0;
|
|
|
|
imax = ARRAYLEN(touchactions);
|
2009-09-13 12:24:14 +00:00
|
|
|
while ((region->action == ACTION_NONE) &&
|
2009-08-09 17:30:05 +00:00
|
|
|
(i < imax))
|
|
|
|
{
|
|
|
|
/* try to match with one of our touchregion screens */
|
|
|
|
int len = strlen(touchactions[i].s);
|
|
|
|
if (!strncmp(touchactions[i].s, action, len)
|
|
|
|
&& *(action+len) == '|')
|
|
|
|
region->action = touchactions[i].action;
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
if (region->action == ACTION_NONE)
|
|
|
|
return WPS_ERROR_INVALID_PARAM;
|
2009-08-03 04:43:34 +00:00
|
|
|
}
|
2009-08-16 21:22:57 +00:00
|
|
|
struct skin_token_list *item = new_skin_token_list_item(NULL, region);
|
|
|
|
if (!item)
|
|
|
|
return WPS_ERROR_INVALID_PARAM;
|
|
|
|
add_to_ll_chain(&wps_data->touchregions, item);
|
2009-09-13 12:24:14 +00:00
|
|
|
return skip_end_of_line(wps_bufptr);
|
|
|
|
}
|
|
|
|
#endif
|
2009-04-20 01:41:56 +00:00
|
|
|
|
2007-04-04 14:41:40 +00:00
|
|
|
/* Parse a generic token from the given string. Return the length read */
|
2007-04-05 14:09:59 +00:00
|
|
|
static int parse_token(const char *wps_bufptr, struct wps_data *wps_data)
|
2007-04-04 14:41:40 +00:00
|
|
|
{
|
2007-11-14 22:02:41 +00:00
|
|
|
int skip = 0, taglen = 0, ret;
|
2007-04-08 04:01:06 +00:00
|
|
|
struct wps_token *token = wps_data->tokens + wps_data->num_tokens;
|
|
|
|
const struct wps_tag *tag;
|
2009-09-11 14:33:32 +00:00
|
|
|
memset(token, 0, sizeof(*token));
|
2007-04-04 14:41:40 +00:00
|
|
|
|
2007-04-05 14:09:59 +00:00
|
|
|
switch(*wps_bufptr)
|
2007-04-04 14:41:40 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
case '%':
|
|
|
|
case '<':
|
|
|
|
case '|':
|
|
|
|
case '>':
|
|
|
|
case ';':
|
2007-04-13 11:43:10 +00:00
|
|
|
case '#':
|
2007-04-04 14:41:40 +00:00
|
|
|
/* escaped characters */
|
2007-04-08 04:01:06 +00:00
|
|
|
token->type = WPS_TOKEN_CHARACTER;
|
|
|
|
token->value.c = *wps_bufptr;
|
2007-04-21 19:31:46 +00:00
|
|
|
taglen = 1;
|
2007-04-04 14:41:40 +00:00
|
|
|
wps_data->num_tokens++;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case '?':
|
|
|
|
/* conditional tag */
|
2007-04-08 04:01:06 +00:00
|
|
|
token->type = WPS_TOKEN_CONDITIONAL;
|
2007-04-04 14:41:40 +00:00
|
|
|
level++;
|
|
|
|
condindex[level] = wps_data->num_tokens;
|
|
|
|
numoptions[level] = 1;
|
|
|
|
wps_data->num_tokens++;
|
2007-11-14 22:02:41 +00:00
|
|
|
ret = parse_token(wps_bufptr + 1, wps_data);
|
|
|
|
if (ret < 0) return ret;
|
|
|
|
taglen = 1 + ret;
|
2007-04-21 19:31:46 +00:00
|
|
|
break;
|
2007-04-04 14:41:40 +00:00
|
|
|
|
|
|
|
default:
|
|
|
|
/* find what tag we have */
|
2007-04-08 04:01:06 +00:00
|
|
|
for (tag = all_tags;
|
|
|
|
strncmp(wps_bufptr, tag->name, strlen(tag->name)) != 0;
|
|
|
|
tag++) ;
|
2007-04-04 14:41:40 +00:00
|
|
|
|
2007-04-21 19:31:46 +00:00
|
|
|
taglen = (tag->type != WPS_TOKEN_UNKNOWN) ? strlen(tag->name) : 2;
|
2007-04-08 04:01:06 +00:00
|
|
|
token->type = tag->type;
|
2009-09-02 02:55:33 +00:00
|
|
|
curr_line->curr_subline->line_type |= tag->refresh_type;
|
2007-04-04 14:41:40 +00:00
|
|
|
|
|
|
|
/* if the tag has a special parsing function, we call it */
|
2007-04-08 04:01:06 +00:00
|
|
|
if (tag->parse_func)
|
2007-11-14 22:02:41 +00:00
|
|
|
{
|
|
|
|
ret = tag->parse_func(wps_bufptr + taglen, token, wps_data);
|
|
|
|
if (ret < 0) return ret;
|
|
|
|
skip += ret;
|
|
|
|
}
|
2007-04-04 14:41:40 +00:00
|
|
|
|
|
|
|
/* Some tags we don't want to save as tokens */
|
2007-04-08 04:01:06 +00:00
|
|
|
if (tag->type == WPS_NO_TOKEN)
|
2007-04-04 14:41:40 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
/* tags that start with 'F', 'I' or 'D' are for the next file */
|
2007-05-02 17:51:01 +00:00
|
|
|
if ( *(tag->name) == 'I' || *(tag->name) == 'F' ||
|
|
|
|
*(tag->name) == 'D')
|
2007-04-08 04:01:06 +00:00
|
|
|
token->next = true;
|
2007-04-04 14:41:40 +00:00
|
|
|
|
|
|
|
wps_data->num_tokens++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2007-04-21 19:31:46 +00:00
|
|
|
skip += taglen;
|
2007-04-04 14:41:40 +00:00
|
|
|
return skip;
|
|
|
|
}
|
|
|
|
|
2009-11-01 23:35:14 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Returns the number of bytes to skip the buf pointer to access the false
|
|
|
|
* branch in a _binary_ conditional
|
|
|
|
*
|
|
|
|
* That is:
|
|
|
|
* - before the '|' if we have a false branch, (%?<true|false> -> %?<|false>)
|
|
|
|
* - or before the closing '>' if there's no false branch (%?<true> -> %?<>)
|
|
|
|
*
|
|
|
|
* depending on the features of a target it's not called from check_feature_tag,
|
|
|
|
* hence the __attribute__ or it issues compiler warnings
|
|
|
|
*
|
|
|
|
**/
|
|
|
|
|
|
|
|
static int find_false_branch(const char *wps_bufptr) __attribute__((unused));
|
|
|
|
static int find_false_branch(const char *wps_bufptr)
|
|
|
|
{
|
|
|
|
const char *buf = wps_bufptr;
|
|
|
|
/* wps_bufptr is after the opening '<', hence level = 1*/
|
|
|
|
int level = 1;
|
|
|
|
char ch;
|
|
|
|
do
|
|
|
|
{
|
|
|
|
ch = *buf;
|
|
|
|
if (ch == '%')
|
|
|
|
{ /* filter out the characters we check later if they're printed
|
|
|
|
* as literals */
|
|
|
|
ch = *(++buf);
|
|
|
|
if (ch == '<' || ch == '>' || ch == '|')
|
|
|
|
continue;
|
|
|
|
/* else: some tags/printed literals we skip over */
|
|
|
|
}
|
|
|
|
else if (ch == '<') /* nested conditional */
|
|
|
|
level++;
|
|
|
|
else if (ch == '>')
|
|
|
|
{ /* closed our or a nested conditional,
|
|
|
|
* do NOT skip over the '>' so that wps_parse() sees it for closing
|
|
|
|
* if it is the closing one for our conditional */
|
|
|
|
level--;
|
|
|
|
}
|
|
|
|
else if (ch == '|' && level == 1)
|
|
|
|
{ /* we found our separator, point before and get out */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* if level is 0, we don't have a false branch */
|
|
|
|
} while (level > 0 && *(++buf));
|
|
|
|
|
|
|
|
return buf - wps_bufptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* returns the number of bytes to get the appropriate branch of a binary
|
|
|
|
* conditional
|
|
|
|
*
|
|
|
|
* That means:
|
|
|
|
* - if a feature is available, it returns 0 to not skip anything
|
|
|
|
* - if the feature is not available, skip to the false branch and don't
|
|
|
|
* parse the true branch at all
|
|
|
|
*
|
|
|
|
* */
|
|
|
|
static int check_feature_tag(const char *wps_bufptr, const int type)
|
|
|
|
{
|
|
|
|
(void)wps_bufptr;
|
|
|
|
switch (type)
|
|
|
|
{
|
|
|
|
case WPS_TOKEN_RTC_PRESENT:
|
|
|
|
#if CONFIG_RTC
|
|
|
|
return 0;
|
|
|
|
#else
|
|
|
|
return find_false_branch(wps_bufptr);
|
|
|
|
#endif
|
2009-11-03 07:58:10 +00:00
|
|
|
case WPS_TOKEN_HAVE_RECORDING:
|
|
|
|
#ifdef HAVE_RECORDING
|
|
|
|
return 0;
|
|
|
|
#else
|
|
|
|
return find_false_branch(wps_bufptr);
|
|
|
|
#endif
|
2009-11-01 23:35:14 +00:00
|
|
|
default: /* not a tag we care about, just don't skip */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-04-08 04:01:06 +00:00
|
|
|
/* Parses the WPS.
|
|
|
|
data is the pointer to the structure where the parsed WPS should be stored.
|
|
|
|
It is initialised.
|
|
|
|
wps_bufptr points to the string containing the WPS tags */
|
2009-09-13 12:24:14 +00:00
|
|
|
#define TOKEN_BLOCK_SIZE 128
|
2009-08-19 05:07:12 +00:00
|
|
|
static bool wps_parse(struct wps_data *data, const char *wps_bufptr, bool debug)
|
2007-04-04 14:41:40 +00:00
|
|
|
{
|
2007-04-05 14:09:59 +00:00
|
|
|
if (!data || !wps_bufptr || !*wps_bufptr)
|
2007-04-04 14:41:40 +00:00
|
|
|
return false;
|
2008-07-12 15:12:09 +00:00
|
|
|
enum wps_parse_error fail = PARSE_OK;
|
2007-11-14 22:02:41 +00:00
|
|
|
int ret;
|
2009-08-19 04:19:08 +00:00
|
|
|
int max_tokens = TOKEN_BLOCK_SIZE;
|
|
|
|
size_t buf_free = 0;
|
2009-12-03 05:36:23 +00:00
|
|
|
line_number = 0;
|
2007-04-21 19:31:46 +00:00
|
|
|
level = -1;
|
2009-09-13 12:24:14 +00:00
|
|
|
|
|
|
|
/* allocate enough RAM for a reasonable skin, grow as needed.
|
2009-08-19 04:19:08 +00:00
|
|
|
* Free any used RAM before loading the images to be 100% RAM efficient */
|
|
|
|
data->tokens = (struct wps_token *)skin_buffer_grab(&buf_free);
|
|
|
|
if (sizeof(struct wps_token)*max_tokens >= buf_free)
|
|
|
|
return false;
|
|
|
|
skin_buffer_increment(max_tokens * sizeof(struct wps_token), false);
|
|
|
|
data->num_tokens = 0;
|
2007-04-04 14:41:40 +00:00
|
|
|
|
2009-09-02 02:55:33 +00:00
|
|
|
while (*wps_bufptr && !fail)
|
2007-04-04 14:41:40 +00:00
|
|
|
{
|
2009-08-19 04:19:08 +00:00
|
|
|
/* first make sure there is enough room for tokens */
|
2009-09-04 06:17:38 +00:00
|
|
|
if (max_tokens <= data->num_tokens + 5)
|
2009-08-19 04:19:08 +00:00
|
|
|
{
|
|
|
|
int extra_tokens = TOKEN_BLOCK_SIZE;
|
|
|
|
size_t needed = extra_tokens * sizeof(struct wps_token);
|
|
|
|
/* do some smarts here to grow the array a bit */
|
|
|
|
if (skin_buffer_freespace() < needed)
|
|
|
|
{
|
|
|
|
fail = PARSE_FAIL_LIMITS_EXCEEDED;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
skin_buffer_increment(needed, false);
|
|
|
|
max_tokens += extra_tokens;
|
|
|
|
}
|
2009-09-13 12:24:14 +00:00
|
|
|
|
2007-04-05 14:09:59 +00:00
|
|
|
switch(*wps_bufptr++)
|
2007-04-04 14:41:40 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
/* Regular tag */
|
|
|
|
case '%':
|
2007-11-14 22:02:41 +00:00
|
|
|
if ((ret = parse_token(wps_bufptr, data)) < 0)
|
|
|
|
{
|
|
|
|
fail = PARSE_FAIL_COND_INVALID_PARAM;
|
|
|
|
break;
|
|
|
|
}
|
2008-07-12 15:12:09 +00:00
|
|
|
else if (level >= WPS_MAX_COND_LEVEL - 1)
|
|
|
|
{
|
|
|
|
fail = PARSE_FAIL_LIMITS_EXCEEDED;
|
|
|
|
break;
|
|
|
|
}
|
2007-11-14 22:02:41 +00:00
|
|
|
wps_bufptr += ret;
|
2007-04-04 14:41:40 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
/* Alternating sublines separator */
|
|
|
|
case ';':
|
2007-04-21 19:31:46 +00:00
|
|
|
if (level >= 0) /* there are unclosed conditionals */
|
2007-04-24 00:57:04 +00:00
|
|
|
{
|
|
|
|
fail = PARSE_FAIL_UNCLOSED_COND;
|
|
|
|
break;
|
|
|
|
}
|
2007-04-15 02:59:34 +00:00
|
|
|
|
2009-09-02 06:23:01 +00:00
|
|
|
if (!skin_start_new_subline(curr_line, data->num_tokens))
|
2008-07-12 15:12:09 +00:00
|
|
|
fail = PARSE_FAIL_LIMITS_EXCEEDED;
|
2007-04-04 14:41:40 +00:00
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Conditional list start */
|
|
|
|
case '<':
|
2007-04-21 19:31:46 +00:00
|
|
|
if (data->tokens[data->num_tokens-2].type != WPS_TOKEN_CONDITIONAL)
|
2007-04-24 00:57:04 +00:00
|
|
|
{
|
|
|
|
fail = PARSE_FAIL_COND_SYNTAX_ERROR;
|
|
|
|
break;
|
|
|
|
}
|
2009-11-01 23:35:14 +00:00
|
|
|
wps_bufptr += check_feature_tag(wps_bufptr,
|
|
|
|
data->tokens[data->num_tokens-1].type);
|
2007-04-04 14:41:40 +00:00
|
|
|
data->tokens[data->num_tokens].type = WPS_TOKEN_CONDITIONAL_START;
|
|
|
|
lastcond[level] = data->num_tokens++;
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Conditional list end */
|
|
|
|
case '>':
|
2007-04-21 19:31:46 +00:00
|
|
|
if (level < 0) /* not in a conditional, invalid char */
|
2007-04-24 00:57:04 +00:00
|
|
|
{
|
|
|
|
fail = PARSE_FAIL_INVALID_CHAR;
|
|
|
|
break;
|
|
|
|
}
|
2007-04-21 19:31:46 +00:00
|
|
|
|
|
|
|
data->tokens[data->num_tokens].type = WPS_TOKEN_CONDITIONAL_END;
|
|
|
|
if (lastcond[level])
|
|
|
|
data->tokens[lastcond[level]].value.i = data->num_tokens;
|
2007-11-12 18:43:38 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
fail = PARSE_FAIL_COND_SYNTAX_ERROR;
|
|
|
|
break;
|
|
|
|
}
|
2007-04-04 14:41:40 +00:00
|
|
|
|
2007-04-21 19:31:46 +00:00
|
|
|
lastcond[level] = 0;
|
|
|
|
data->num_tokens++;
|
|
|
|
data->tokens[condindex[level]].value.i = numoptions[level];
|
|
|
|
level--;
|
2007-04-04 14:41:40 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
/* Conditional list option */
|
|
|
|
case '|':
|
2007-04-21 19:31:46 +00:00
|
|
|
if (level < 0) /* not in a conditional, invalid char */
|
2007-04-24 00:57:04 +00:00
|
|
|
{
|
|
|
|
fail = PARSE_FAIL_INVALID_CHAR;
|
|
|
|
break;
|
|
|
|
}
|
2007-04-04 14:41:40 +00:00
|
|
|
|
|
|
|
data->tokens[data->num_tokens].type = WPS_TOKEN_CONDITIONAL_OPTION;
|
|
|
|
if (lastcond[level])
|
|
|
|
data->tokens[lastcond[level]].value.i = data->num_tokens;
|
2007-11-12 18:43:38 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
fail = PARSE_FAIL_COND_SYNTAX_ERROR;
|
|
|
|
break;
|
|
|
|
}
|
2007-04-04 14:41:40 +00:00
|
|
|
|
|
|
|
lastcond[level] = data->num_tokens;
|
|
|
|
numoptions[level]++;
|
|
|
|
data->num_tokens++;
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Comment */
|
|
|
|
case '#':
|
2007-04-21 19:31:46 +00:00
|
|
|
if (level >= 0) /* there are unclosed conditionals */
|
2007-04-24 00:57:04 +00:00
|
|
|
{
|
|
|
|
fail = PARSE_FAIL_UNCLOSED_COND;
|
|
|
|
break;
|
|
|
|
}
|
2007-04-15 02:59:34 +00:00
|
|
|
|
2007-04-05 14:09:59 +00:00
|
|
|
wps_bufptr += skip_end_of_line(wps_bufptr);
|
2007-04-04 14:41:40 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
/* End of this line */
|
|
|
|
case '\n':
|
2007-04-21 19:31:46 +00:00
|
|
|
if (level >= 0) /* there are unclosed conditionals */
|
2007-04-24 00:57:04 +00:00
|
|
|
{
|
|
|
|
fail = PARSE_FAIL_UNCLOSED_COND;
|
|
|
|
break;
|
|
|
|
}
|
2009-09-02 02:55:33 +00:00
|
|
|
/* add a new token for the \n so empty lines are correct */
|
|
|
|
data->tokens[data->num_tokens].type = WPS_TOKEN_CHARACTER;
|
|
|
|
data->tokens[data->num_tokens].value.c = '\n';
|
|
|
|
data->tokens[data->num_tokens].next = false;
|
|
|
|
data->num_tokens++;
|
2007-04-15 02:59:34 +00:00
|
|
|
|
2009-09-02 06:23:01 +00:00
|
|
|
if (!skin_start_new_line(curr_vp, data->num_tokens))
|
2009-09-13 12:24:14 +00:00
|
|
|
{
|
2009-09-02 02:55:33 +00:00
|
|
|
fail = PARSE_FAIL_LIMITS_EXCEEDED;
|
|
|
|
break;
|
2007-04-04 14:41:40 +00:00
|
|
|
}
|
2009-12-03 05:36:23 +00:00
|
|
|
line_number++;
|
2007-04-04 14:41:40 +00:00
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* String */
|
|
|
|
default:
|
|
|
|
{
|
2007-04-30 14:08:58 +00:00
|
|
|
unsigned int len = 1;
|
|
|
|
const char *string_start = wps_bufptr - 1;
|
2007-04-04 14:41:40 +00:00
|
|
|
|
2007-05-02 11:39:46 +00:00
|
|
|
/* find the length of the string */
|
2007-05-02 17:51:01 +00:00
|
|
|
while (*wps_bufptr && *wps_bufptr != '#' &&
|
2007-05-02 11:39:46 +00:00
|
|
|
*wps_bufptr != '%' && *wps_bufptr != ';' &&
|
|
|
|
*wps_bufptr != '<' && *wps_bufptr != '>' &&
|
|
|
|
*wps_bufptr != '|' && *wps_bufptr != '\n')
|
2007-04-04 14:41:40 +00:00
|
|
|
{
|
2007-04-30 14:08:58 +00:00
|
|
|
wps_bufptr++;
|
|
|
|
len++;
|
2007-04-04 14:41:40 +00:00
|
|
|
}
|
|
|
|
|
2007-04-30 14:08:58 +00:00
|
|
|
/* look if we already have that string */
|
2009-08-16 18:23:00 +00:00
|
|
|
char *str;
|
|
|
|
bool found = false;
|
2009-12-03 05:36:23 +00:00
|
|
|
struct skin_token_list *list = data->strings;
|
|
|
|
while (list)
|
|
|
|
{
|
|
|
|
str = (char*)list->token->value.data;
|
|
|
|
found = (strlen(str) == len &&
|
2009-08-16 18:23:00 +00:00
|
|
|
strncmp(string_start, str, len) == 0);
|
2009-12-03 05:36:23 +00:00
|
|
|
if (found)
|
|
|
|
break; /* break here because the list item is
|
|
|
|
used if its found */
|
2009-08-16 18:23:00 +00:00
|
|
|
list = list->next;
|
|
|
|
}
|
2007-05-01 23:36:15 +00:00
|
|
|
/* If a matching string is found, found is true and i is
|
|
|
|
the index of the string. If not, found is false */
|
|
|
|
|
2008-07-12 15:12:09 +00:00
|
|
|
if (!found)
|
2007-04-30 14:08:58 +00:00
|
|
|
{
|
2008-07-12 15:12:09 +00:00
|
|
|
/* new string */
|
2009-12-03 05:36:23 +00:00
|
|
|
str = (char*)skin_buffer_alloc(len+1);
|
|
|
|
if (!str)
|
|
|
|
{
|
|
|
|
fail = PARSE_FAIL_LIMITS_EXCEEDED;
|
|
|
|
break;
|
2007-05-01 23:36:15 +00:00
|
|
|
}
|
2009-08-16 18:23:00 +00:00
|
|
|
strlcpy(str, string_start, len+1);
|
2009-12-03 05:36:23 +00:00
|
|
|
struct skin_token_list *item =
|
|
|
|
new_skin_token_list_item(&data->tokens[data->num_tokens], str);
|
|
|
|
if(!item)
|
|
|
|
{
|
|
|
|
fail = PARSE_FAIL_LIMITS_EXCEEDED;
|
|
|
|
break;
|
2009-08-16 18:23:00 +00:00
|
|
|
}
|
2009-12-03 05:36:23 +00:00
|
|
|
add_to_ll_chain(&data->strings, item);
|
2007-04-30 14:08:58 +00:00
|
|
|
}
|
2008-07-12 15:12:09 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
/* another occurrence of an existing string */
|
2009-08-16 18:23:00 +00:00
|
|
|
data->tokens[data->num_tokens].value.data = list->token->value.data;
|
2008-07-12 15:12:09 +00:00
|
|
|
}
|
|
|
|
data->tokens[data->num_tokens].type = WPS_TOKEN_STRING;
|
|
|
|
data->num_tokens++;
|
2007-04-15 02:59:34 +00:00
|
|
|
}
|
2007-04-04 14:41:40 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-11-12 18:43:38 +00:00
|
|
|
if (!fail && level >= 0) /* there are unclosed conditionals */
|
2007-05-02 11:39:46 +00:00
|
|
|
fail = PARSE_FAIL_UNCLOSED_COND;
|
2009-09-13 12:24:14 +00:00
|
|
|
|
2008-07-12 15:12:09 +00:00
|
|
|
if (*wps_bufptr && !fail)
|
|
|
|
/* one of the limits of the while loop was exceeded */
|
|
|
|
fail = PARSE_FAIL_LIMITS_EXCEEDED;
|
2007-05-02 11:39:46 +00:00
|
|
|
|
2009-08-19 04:19:08 +00:00
|
|
|
/* Success! */
|
2009-09-04 06:17:38 +00:00
|
|
|
curr_line->curr_subline->last_token_idx = data->num_tokens;
|
|
|
|
data->tokens[data->num_tokens++].type = WPS_NO_TOKEN;
|
2009-08-19 04:19:08 +00:00
|
|
|
/* freeup unused tokens */
|
2009-09-13 12:24:14 +00:00
|
|
|
skin_buffer_free_from_front(sizeof(struct wps_token)
|
2009-08-19 04:19:08 +00:00
|
|
|
* (max_tokens - data->num_tokens));
|
2009-09-13 12:24:14 +00:00
|
|
|
|
2008-12-09 18:15:19 +00:00
|
|
|
#if defined(DEBUG) || defined(SIMULATOR)
|
2009-08-19 05:07:12 +00:00
|
|
|
if (debug)
|
2009-09-02 02:55:33 +00:00
|
|
|
print_debug_info(data, fail, line_number);
|
2009-08-19 05:07:12 +00:00
|
|
|
#else
|
|
|
|
(void)debug;
|
2007-04-04 14:41:40 +00:00
|
|
|
#endif
|
2007-04-24 00:57:04 +00:00
|
|
|
|
|
|
|
return (fail == 0);
|
2007-04-04 14:41:40 +00:00
|
|
|
}
|
|
|
|
|
2009-10-14 15:49:11 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* initial setup of wps_data; does reset everything
|
|
|
|
* except fields which need to survive, i.e.
|
|
|
|
*
|
|
|
|
**/
|
2009-12-20 16:28:15 +00:00
|
|
|
static void skin_data_reset(struct wps_data *wps_data)
|
2007-04-04 14:41:40 +00:00
|
|
|
{
|
2009-10-14 15:49:11 +00:00
|
|
|
#ifdef HAVE_LCD_BITMAP
|
|
|
|
wps_data->images = NULL;
|
|
|
|
wps_data->progressbars = NULL;
|
2007-04-25 13:09:56 +00:00
|
|
|
#endif
|
2009-10-14 15:49:11 +00:00
|
|
|
#ifdef HAVE_TOUCHSCREEN
|
|
|
|
wps_data->touchregions = NULL;
|
|
|
|
#endif
|
|
|
|
wps_data->viewports = NULL;
|
|
|
|
wps_data->strings = NULL;
|
|
|
|
#ifdef HAVE_ALBUMART
|
|
|
|
wps_data->albumart = NULL;
|
2009-10-16 19:14:41 +00:00
|
|
|
if (wps_data->playback_aa_slot >= 0)
|
|
|
|
{
|
|
|
|
playback_release_aa_slot(wps_data->playback_aa_slot);
|
|
|
|
wps_data->playback_aa_slot = -1;
|
|
|
|
}
|
2009-10-14 15:49:11 +00:00
|
|
|
#endif
|
|
|
|
wps_data->tokens = NULL;
|
|
|
|
wps_data->num_tokens = 0;
|
|
|
|
|
|
|
|
#ifdef HAVE_LCD_BITMAP
|
|
|
|
wps_data->peak_meter_enabled = false;
|
|
|
|
wps_data->wps_sb_tag = false;
|
|
|
|
wps_data->show_sb_on_wps = false;
|
|
|
|
#else /* HAVE_LCD_CHARCELLS */
|
|
|
|
/* progress bars */
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < 8; i++)
|
|
|
|
{
|
|
|
|
wps_data->wps_progress_pat[i] = 0;
|
|
|
|
}
|
|
|
|
wps_data->full_line_progressbar = false;
|
2007-04-25 13:09:56 +00:00
|
|
|
#endif
|
2009-10-14 15:49:11 +00:00
|
|
|
wps_data->wps_loaded = false;
|
2007-04-04 14:41:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef HAVE_LCD_BITMAP
|
2009-08-16 18:23:00 +00:00
|
|
|
static bool load_skin_bmp(struct wps_data *wps_data, struct bitmap *bitmap, char* bmpdir)
|
|
|
|
{
|
2009-12-03 05:36:23 +00:00
|
|
|
(void)wps_data; /* only needed for remote targets */
|
|
|
|
bool loaded = false;
|
2009-08-16 18:23:00 +00:00
|
|
|
char img_path[MAX_PATH];
|
|
|
|
get_image_filename(bitmap->data, bmpdir,
|
|
|
|
img_path, sizeof(img_path));
|
2009-09-13 12:24:14 +00:00
|
|
|
|
2009-12-03 05:36:23 +00:00
|
|
|
/* load the image */
|
2009-08-16 18:23:00 +00:00
|
|
|
int format;
|
|
|
|
#ifdef HAVE_REMOTE_LCD
|
2009-11-04 07:14:02 +00:00
|
|
|
if (curr_screen == SCREEN_REMOTE)
|
2009-08-16 18:23:00 +00:00
|
|
|
format = FORMAT_ANY|FORMAT_REMOTE;
|
|
|
|
else
|
|
|
|
#endif
|
|
|
|
format = FORMAT_ANY|FORMAT_TRANSPARENT;
|
2009-09-13 12:24:14 +00:00
|
|
|
|
2009-12-03 05:36:23 +00:00
|
|
|
size_t max_buf;
|
2009-08-16 18:23:00 +00:00
|
|
|
char* imgbuf = (char*)skin_buffer_grab(&max_buf);
|
2009-12-03 05:36:23 +00:00
|
|
|
bitmap->data = imgbuf;
|
2009-08-16 18:23:00 +00:00
|
|
|
int ret = read_bmp_file(img_path, bitmap, max_buf, format, NULL);
|
|
|
|
|
|
|
|
if (ret > 0)
|
|
|
|
{
|
2009-12-03 05:36:23 +00:00
|
|
|
skin_buffer_increment(ret, true);
|
2009-08-16 18:23:00 +00:00
|
|
|
loaded = true;
|
|
|
|
}
|
|
|
|
else
|
2009-12-03 05:36:23 +00:00
|
|
|
{
|
2009-08-16 18:23:00 +00:00
|
|
|
/* Abort if we can't load an image */
|
2009-12-03 05:36:23 +00:00
|
|
|
loaded = false;
|
2009-08-16 18:23:00 +00:00
|
|
|
}
|
2009-12-03 05:36:23 +00:00
|
|
|
return loaded;
|
2009-08-16 18:23:00 +00:00
|
|
|
}
|
2007-04-04 14:41:40 +00:00
|
|
|
|
2009-08-06 04:33:35 +00:00
|
|
|
static bool load_skin_bitmaps(struct wps_data *wps_data, char *bmpdir)
|
2007-04-04 14:41:40 +00:00
|
|
|
{
|
2009-08-16 18:23:00 +00:00
|
|
|
struct skin_token_list *list;
|
|
|
|
/* do the progressbars */
|
|
|
|
list = wps_data->progressbars;
|
|
|
|
while (list)
|
2007-04-04 14:41:40 +00:00
|
|
|
{
|
2009-08-16 18:23:00 +00:00
|
|
|
struct progressbar *pb = (struct progressbar*)list->token->value.data;
|
|
|
|
if (pb->bm.data)
|
2007-04-04 14:41:40 +00:00
|
|
|
{
|
2009-08-16 18:23:00 +00:00
|
|
|
pb->have_bitmap_pb = load_skin_bmp(wps_data, &pb->bm, bmpdir);
|
|
|
|
}
|
2009-12-03 05:36:23 +00:00
|
|
|
list = list->next;
|
2009-09-13 12:24:14 +00:00
|
|
|
}
|
2009-08-16 18:23:00 +00:00
|
|
|
/* regular images */
|
2009-12-03 05:36:23 +00:00
|
|
|
list = wps_data->images;
|
2009-08-16 18:23:00 +00:00
|
|
|
while (list)
|
|
|
|
{
|
|
|
|
struct gui_img *img = (struct gui_img*)list->token->value.data;
|
|
|
|
if (img->bm.data)
|
|
|
|
{
|
|
|
|
img->loaded = load_skin_bmp(wps_data, &img->bm, bmpdir);
|
2009-12-03 05:36:23 +00:00
|
|
|
if (img->loaded)
|
|
|
|
img->subimage_height = img->bm.height / img->num_subimages;
|
2007-04-04 14:41:40 +00:00
|
|
|
}
|
2009-12-03 05:36:23 +00:00
|
|
|
list = list->next;
|
2007-04-04 14:41:40 +00:00
|
|
|
}
|
|
|
|
|
2008-03-29 01:14:10 +00:00
|
|
|
#if (LCD_DEPTH > 1) || (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1))
|
2007-06-05 14:57:07 +00:00
|
|
|
if (bmp_names[BACKDROP_BMP])
|
2007-04-25 21:44:56 +00:00
|
|
|
{
|
2009-08-16 18:23:00 +00:00
|
|
|
char img_path[MAX_PATH];
|
2007-06-05 14:57:07 +00:00
|
|
|
get_image_filename(bmp_names[BACKDROP_BMP], bmpdir,
|
2007-04-25 21:44:56 +00:00
|
|
|
img_path, sizeof(img_path));
|
2009-11-04 07:14:02 +00:00
|
|
|
screens[curr_screen].backdrop_load(BACKDROP_SKIN_WPS, img_path);
|
2007-04-25 21:44:56 +00:00
|
|
|
}
|
|
|
|
#endif /* has backdrop support */
|
2008-03-26 18:18:22 +00:00
|
|
|
|
|
|
|
/* If we got here, everything was OK */
|
|
|
|
return true;
|
2007-04-04 14:41:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* HAVE_LCD_BITMAP */
|
|
|
|
|
|
|
|
/* to setup up the wps-data from a format-buffer (isfile = false)
|
|
|
|
from a (wps-)file (isfile = true)*/
|
2009-11-04 05:24:30 +00:00
|
|
|
bool skin_data_load(enum screen_type screen, struct wps_data *wps_data,
|
|
|
|
const char *buf, bool isfile)
|
2007-04-04 14:41:40 +00:00
|
|
|
{
|
2009-09-13 12:24:14 +00:00
|
|
|
|
2009-09-07 02:36:56 +00:00
|
|
|
if (!wps_data || !buf)
|
|
|
|
return false;
|
2008-12-09 23:07:59 +00:00
|
|
|
#ifdef HAVE_ALBUMART
|
2009-09-07 02:36:56 +00:00
|
|
|
int status;
|
2008-12-09 23:07:59 +00:00
|
|
|
struct mp3entry *curtrack;
|
|
|
|
long offset;
|
2009-09-25 18:36:28 +00:00
|
|
|
struct skin_albumart old_aa = {.state = WPS_ALBUMART_NONE};
|
2009-09-07 02:36:56 +00:00
|
|
|
if (wps_data->albumart)
|
|
|
|
{
|
2009-09-25 18:36:28 +00:00
|
|
|
old_aa.state = wps_data->albumart->state;
|
|
|
|
old_aa.height = wps_data->albumart->height;
|
|
|
|
old_aa.width = wps_data->albumart->width;
|
2009-09-07 02:36:56 +00:00
|
|
|
}
|
2008-12-09 23:07:59 +00:00
|
|
|
#endif
|
2007-04-04 14:41:40 +00:00
|
|
|
|
2009-10-14 15:49:11 +00:00
|
|
|
skin_data_reset(wps_data);
|
2009-11-04 05:24:30 +00:00
|
|
|
curr_screen = screen;
|
|
|
|
|
2009-10-19 15:28:15 +00:00
|
|
|
/* alloc default viewport, will be fixed up later */
|
2009-08-18 05:30:59 +00:00
|
|
|
curr_vp = skin_buffer_alloc(sizeof(struct skin_viewport));
|
|
|
|
if (!curr_vp)
|
|
|
|
return false;
|
|
|
|
struct skin_token_list *list = new_skin_token_list_item(NULL, curr_vp);
|
|
|
|
if (!list)
|
|
|
|
return false;
|
|
|
|
add_to_ll_chain(&wps_data->viewports, list);
|
2009-09-13 12:24:14 +00:00
|
|
|
|
2007-04-04 14:41:40 +00:00
|
|
|
|
2008-03-21 19:38:00 +00:00
|
|
|
/* Initialise the first (default) viewport */
|
2009-08-18 05:30:59 +00:00
|
|
|
curr_vp->label = VP_DEFAULT_LABEL;
|
|
|
|
curr_vp->pb = NULL;
|
|
|
|
curr_vp->hidden_flags = 0;
|
2009-09-02 02:55:33 +00:00
|
|
|
curr_vp->lines = NULL;
|
2009-11-04 05:24:30 +00:00
|
|
|
|
|
|
|
viewport_set_defaults(&curr_vp->vp, screen);
|
2009-09-13 12:24:14 +00:00
|
|
|
|
2009-09-02 02:55:33 +00:00
|
|
|
curr_line = NULL;
|
2009-09-02 06:23:01 +00:00
|
|
|
if (!skin_start_new_line(curr_vp, 0))
|
2009-09-02 02:55:33 +00:00
|
|
|
return false;
|
2009-09-13 12:24:14 +00:00
|
|
|
|
2007-04-04 14:41:40 +00:00
|
|
|
if (!isfile)
|
|
|
|
{
|
2009-08-19 05:07:12 +00:00
|
|
|
return wps_parse(wps_data, buf, false);
|
2007-04-04 14:41:40 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2008-08-02 20:39:03 +00:00
|
|
|
int fd = open_utf8(buf, O_RDONLY);
|
2007-04-04 14:41:40 +00:00
|
|
|
|
|
|
|
if (fd < 0)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* get buffer space from the plugin buffer */
|
2007-04-21 18:38:25 +00:00
|
|
|
size_t buffersize = 0;
|
2007-04-04 14:41:40 +00:00
|
|
|
char *wps_buffer = (char *)plugin_get_buffer(&buffersize);
|
|
|
|
|
|
|
|
if (!wps_buffer)
|
|
|
|
return false;
|
|
|
|
|
2007-05-02 17:51:01 +00:00
|
|
|
/* copy the file's content to the buffer for parsing,
|
|
|
|
ensuring that every line ends with a newline char. */
|
2007-04-04 14:41:40 +00:00
|
|
|
unsigned int start = 0;
|
|
|
|
while(read_line(fd, wps_buffer + start, buffersize - start) > 0)
|
|
|
|
{
|
|
|
|
start += strlen(wps_buffer + start);
|
|
|
|
if (start < buffersize - 1)
|
|
|
|
{
|
|
|
|
wps_buffer[start++] = '\n';
|
|
|
|
wps_buffer[start] = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
close(fd);
|
|
|
|
|
|
|
|
if (start <= 0)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
#ifdef HAVE_LCD_BITMAP
|
2008-03-21 19:38:00 +00:00
|
|
|
/* Set all filename pointers to NULL */
|
2008-03-23 12:15:52 +00:00
|
|
|
memset(bmp_names, 0, sizeof(bmp_names));
|
2007-04-04 14:41:40 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/* parse the WPS source */
|
2009-08-19 05:07:12 +00:00
|
|
|
if (!wps_parse(wps_data, wps_buffer, true)) {
|
2009-10-14 15:49:11 +00:00
|
|
|
skin_data_reset(wps_data);
|
2007-04-04 14:41:40 +00:00
|
|
|
return false;
|
2008-04-01 17:35:48 +00:00
|
|
|
}
|
2007-04-04 14:41:40 +00:00
|
|
|
|
|
|
|
wps_data->wps_loaded = true;
|
|
|
|
|
|
|
|
#ifdef HAVE_LCD_BITMAP
|
|
|
|
/* get the bitmap dir */
|
|
|
|
char bmpdir[MAX_PATH];
|
|
|
|
char *dot = strrchr(buf, '.');
|
2009-07-14 13:57:45 +00:00
|
|
|
|
|
|
|
strlcpy(bmpdir, buf, dot - buf + 1);
|
2007-04-04 14:41:40 +00:00
|
|
|
|
|
|
|
/* load the bitmaps that were found by the parsing */
|
2009-08-06 04:33:35 +00:00
|
|
|
if (!load_skin_bitmaps(wps_data, bmpdir)) {
|
2009-10-14 15:49:11 +00:00
|
|
|
skin_data_reset(wps_data);
|
2008-03-26 18:18:22 +00:00
|
|
|
return false;
|
2008-04-01 17:35:48 +00:00
|
|
|
}
|
2008-12-09 23:07:59 +00:00
|
|
|
#endif
|
2009-11-01 15:48:31 +00:00
|
|
|
#if defined(HAVE_ALBUMART) && !defined(__PCTOOL__)
|
2008-12-09 23:07:59 +00:00
|
|
|
status = audio_status();
|
2009-09-07 02:36:56 +00:00
|
|
|
if (status & AUDIO_STATUS_PLAY)
|
2008-12-09 23:07:59 +00:00
|
|
|
{
|
2009-09-07 02:36:56 +00:00
|
|
|
struct skin_albumart *aa = wps_data->albumart;
|
2009-09-25 18:36:28 +00:00
|
|
|
if (aa && ((aa->state && !old_aa.state) ||
|
|
|
|
(aa->state &&
|
|
|
|
(((old_aa.height != aa->height) ||
|
|
|
|
(old_aa.width != aa->width))))))
|
2009-09-07 02:36:56 +00:00
|
|
|
{
|
|
|
|
curtrack = audio_current_track();
|
|
|
|
offset = curtrack->offset;
|
|
|
|
audio_stop();
|
|
|
|
if (!(status & AUDIO_STATUS_PAUSE))
|
|
|
|
audio_play(offset);
|
|
|
|
}
|
2008-12-09 23:07:59 +00:00
|
|
|
}
|
2009-08-19 05:07:12 +00:00
|
|
|
#endif
|
|
|
|
#if defined(DEBUG) || defined(SIMULATOR)
|
|
|
|
debug_skin_usage();
|
2007-04-04 14:41:40 +00:00
|
|
|
#endif
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|