Nyaaori/rockbox
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
rockbox/apps/plugins/lua/rocklib.c
Thomas Martitz a1842c04f9 lcd-24bit: Introduce a 24-bit mid-level LCD driver 
With LCD driver all calculation will be performed on RGB888 and the hardware/OS
can display from our 24bit framebuffer.

It is not yet as performance optimized as the existing drivers but should be
good enough.The vast number of small changes is due to the fact that
fb_data can be a struct type now, while most of the code expected a scalar type.

lcd-as-memframe ASM code does not work with 24bit currently so the with 24bit
it enforces the generic C code.

All plugins are ported over. Except for rockpaint. It uses so much memory that
it wouldnt fit into the 512k plugin buffer anymore (patches welcome).

Change-Id: Ibb1964545028ce0d8ff9833ccc3ab66be3ee0754
2014-06-21 00:15:53 +02:00

803 lines
21 KiB
C
Raw Blame History

/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2008 Dan Everton (safetydan)
* Copyright (C) 2009 Maurus Cuelenaere
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#define lrocklib_c
#define LUA_LIB
#include "lua.h"
#include "lauxlib.h"
#include "rocklib.h"
#include "lib/helper.h"
#include "lib/pluginlib_actions.h"
/*
* http://www.lua.org/manual/5.1/manual.html#lua_CFunction
*
* In order to communicate properly with Lua, a C function must use the following protocol,
* which defines the way parameters and results are passed: a C function receives its arguments
* from Lua in its stack in direct order (the first argument is pushed first). To return values to Lua,
* a C function just pushes them onto the stack, in direct order (the first result is pushed first),
* and returns the number of results. Any other value in the stack below the results will be properly
* discarded by Lua. Like a Lua function, a C function called by Lua can also return many results.
*
* When porting new functions, don't forget to check rocklib_aux.pl whether it automatically creates
* wrappers for the function and if so, add the function names to @forbidden_functions. This is to
* prevent namespace collisions and adding duplicate wrappers.
*/
/*
* -----------------------------
*
* Rockbox Lua image wrapper
*
* -----------------------------
*/
#define ROCKLUA_IMAGE "rb.image"
struct rocklua_image
{
int width;
int height;
fb_data *data;
fb_data dummy[1][1];
};
static void rli_wrap(lua_State *L, fb_data *src, int width, int height)
{
struct rocklua_image *a = (struct rocklua_image *)lua_newuserdata(L, sizeof(struct rocklua_image));
luaL_getmetatable(L, ROCKLUA_IMAGE);
lua_setmetatable(L, -2);
a->width = width;
a->height = height;
a->data = src;
}
static fb_data* rli_alloc(lua_State *L, int width, int height)
{
size_t nbytes = sizeof(struct rocklua_image) + ((width*height) - 1) * sizeof(fb_data);
struct rocklua_image *a = (struct rocklua_image *)lua_newuserdata(L, nbytes);
luaL_getmetatable(L, ROCKLUA_IMAGE);
lua_setmetatable(L, -2);
a->width = width;
a->height = height;
a->data = &a->dummy[0][0];
return a->data;
}
static int rli_new(lua_State *L)
{
int width = luaL_checkint(L, 1);
int height = luaL_checkint(L, 2);
rli_alloc(L, width, height);
return 1;
}
static struct rocklua_image* rli_checktype(lua_State *L, int arg)
{
void *ud = luaL_checkudata(L, arg, ROCKLUA_IMAGE);
luaL_argcheck(L, ud != NULL, arg, "'" ROCKLUA_IMAGE "' expected");
return (struct rocklua_image*) ud;
}
static int rli_width(lua_State *L)
{
struct rocklua_image *a = rli_checktype(L, 1);
lua_pushnumber(L, a->width);
return 1;
}
static int rli_height(lua_State *L)
{
struct rocklua_image *a = rli_checktype(L, 1);
lua_pushnumber(L, a->height);
return 1;
}
static fb_data* rli_element(lua_State *L)
{
struct rocklua_image *a = rli_checktype(L, 1);
int x = luaL_checkint(L, 2);
int y = luaL_checkint(L, 3);
luaL_argcheck(L, 1 <= x && x <= a->width, 2,
"index out of range");
luaL_argcheck(L, 1 <= y && y <= a->height, 3,
"index out of range");
/* return element address */
return &a->data[a->width * (y - 1) + (x - 1)];
}
static int rli_set(lua_State *L)
{
fb_data newvalue = FB_SCALARPACK((unsigned)luaL_checknumber(L, 4));
*rli_element(L) = newvalue;
return 0;
}
static int rli_get(lua_State *L)
{
lua_pushnumber(L, FB_UNPACK_SCALAR_LCD(*rli_element(L)));
return 1;
}
static int rli_tostring(lua_State *L)
{
struct rocklua_image *a = rli_checktype(L, 1);
lua_pushfstring(L, ROCKLUA_IMAGE ": %dx%d", a->width, a->height);
return 1;
}
static const struct luaL_reg rli_lib [] =
{
{"__tostring", rli_tostring},
{"set", rli_set},
{"get", rli_get},
{"width", rli_width},
{"height", rli_height},
{NULL, NULL}
};
static inline void rli_init(lua_State *L)
{
luaL_newmetatable(L, ROCKLUA_IMAGE);
lua_pushstring(L, "__index");
lua_pushvalue(L, -2); /* pushes the metatable */
lua_settable(L, -3); /* metatable.__index = metatable */
luaL_register(L, NULL, rli_lib);
}
/*
* -----------------------------
*
* Rockbox wrappers start here!
*
* -----------------------------
*/
#define RB_WRAP(M) static int rock_##M(lua_State UNUSED_ATTR *L)
#define SIMPLE_VOID_WRAPPER(func) RB_WRAP(func) { (void)L; func(); return 0; }
/* Helper function for opt_viewport */
static void check_tablevalue(lua_State *L, const char* key, int tablepos, void* res, bool unsigned_val)
{
lua_getfield(L, tablepos, key); /* Find table[key] */
if(!lua_isnoneornil(L, -1))
{
if(unsigned_val)
*(unsigned*)res = luaL_checkint(L, -1);
else
*(int*)res = luaL_checkint(L, -1);
}
lua_pop(L, 1); /* Pop the value off the stack */
}
static struct viewport* opt_viewport(lua_State *L, int narg, struct viewport* alt)
{
if(lua_isnoneornil(L, narg))
return alt;
int tablepos = lua_gettop(L);
struct viewport *vp;
lua_getfield(L, tablepos, "vp"); /* get table['vp'] */
if(lua_isnoneornil(L, -1))
{
lua_pop(L, 1); /* Pop nil off stack */
vp = (struct viewport*) lua_newuserdata(L, sizeof(struct viewport)); /* Allocate memory and push it as udata on the stack */
memset(vp, 0, sizeof(struct viewport)); /* Init viewport values to 0 */
lua_setfield(L, tablepos, "vp"); /* table['vp'] = vp (pops value off the stack) */
}
else
{
vp = (struct viewport*) lua_touserdata(L, -1); /* Reuse viewport struct */
lua_pop(L, 1); /* We don't need the value on stack */
}
luaL_checktype(L, narg, LUA_TTABLE);
check_tablevalue(L, "x", tablepos, &vp->x, false);
check_tablevalue(L, "y", tablepos, &vp->y, false);
check_tablevalue(L, "width", tablepos, &vp->width, false);
check_tablevalue(L, "height", tablepos, &vp->height, false);
#ifdef HAVE_LCD_BITMAP
check_tablevalue(L, "font", tablepos, &vp->font, false);
check_tablevalue(L, "drawmode", tablepos, &vp->drawmode, false);
#endif
#if LCD_DEPTH > 1
check_tablevalue(L, "fg_pattern", tablepos, &vp->fg_pattern, true);
check_tablevalue(L, "bg_pattern", tablepos, &vp->bg_pattern, true);
#endif
return vp;
}
RB_WRAP(set_viewport)
{
struct viewport *vp = opt_viewport(L, 1, NULL);
int screen = luaL_optint(L, 2, SCREEN_MAIN);
rb->screens[screen]->set_viewport(vp);
return 0;
}
RB_WRAP(clear_viewport)
{
int screen = luaL_optint(L, 1, SCREEN_MAIN);
rb->screens[screen]->clear_viewport();
return 0;
}
#ifdef HAVE_LCD_BITMAP
RB_WRAP(lcd_framebuffer)
{
rli_wrap(L, rb->lcd_framebuffer, LCD_WIDTH, LCD_HEIGHT);
return 1;
}
RB_WRAP(lcd_mono_bitmap_part)
{
struct rocklua_image *src = rli_checktype(L, 1);
int src_x = luaL_checkint(L, 2);
int src_y = luaL_checkint(L, 3);
int stride = luaL_checkint(L, 4);
int x = luaL_checkint(L, 5);
int y = luaL_checkint(L, 6);
int width = luaL_checkint(L, 7);
int height = luaL_checkint(L, 8);
int screen = luaL_optint(L, 9, SCREEN_MAIN);
rb->screens[screen]->mono_bitmap_part((const unsigned char *)src->data, src_x, src_y, stride, x, y, width, height);
return 0;
}
RB_WRAP(lcd_mono_bitmap)
{
struct rocklua_image *src = rli_checktype(L, 1);
int x = luaL_checkint(L, 2);
int y = luaL_checkint(L, 3);
int width = luaL_checkint(L, 4);
int height = luaL_checkint(L, 5);
int screen = luaL_optint(L, 6, SCREEN_MAIN);
rb->screens[screen]->mono_bitmap((const unsigned char *)src->data, x, y, width, height);
return 0;
}
#if LCD_DEPTH > 1
RB_WRAP(lcd_bitmap_part)
{
struct rocklua_image *src = rli_checktype(L, 1);
int src_x = luaL_checkint(L, 2);
int src_y = luaL_checkint(L, 3);
int stride = luaL_checkint(L, 4);
int x = luaL_checkint(L, 5);
int y = luaL_checkint(L, 6);
int width = luaL_checkint(L, 7);
int height = luaL_checkint(L, 8);
int screen = luaL_optint(L, 9, SCREEN_MAIN);
rb->screens[screen]->bitmap_part(src->data, src_x, src_y, stride, x, y, width, height);
return 0;
}
RB_WRAP(lcd_bitmap)
{
struct rocklua_image *src = rli_checktype(L, 1);
int x = luaL_checkint(L, 2);
int y = luaL_checkint(L, 3);
int width = luaL_checkint(L, 4);
int height = luaL_checkint(L, 5);
int screen = luaL_optint(L, 6, SCREEN_MAIN);
rb->screens[screen]->bitmap(src->data, x, y, width, height);
return 0;
}
RB_WRAP(lcd_get_backdrop)
{
fb_data* backdrop = rb->lcd_get_backdrop();
if(backdrop == NULL)
lua_pushnil(L);
else
rli_wrap(L, backdrop, LCD_WIDTH, LCD_HEIGHT);
return 1;
}
#endif /* LCD_DEPTH > 1 */
#if LCD_DEPTH == 16
RB_WRAP(lcd_bitmap_transparent_part)
{
struct rocklua_image *src = rli_checktype(L, 1);
int src_x = luaL_checkint(L, 2);
int src_y = luaL_checkint(L, 3);
int stride = luaL_checkint(L, 4);
int x = luaL_checkint(L, 5);
int y = luaL_checkint(L, 6);
int width = luaL_checkint(L, 7);
int height = luaL_checkint(L, 8);
int screen = luaL_optint(L, 9, SCREEN_MAIN);
rb->screens[screen]->transparent_bitmap_part(src->data, src_x, src_y, stride, x, y, width, height);
return 0;
}
RB_WRAP(lcd_bitmap_transparent)
{
struct rocklua_image *src = rli_checktype(L, 1);
int x = luaL_checkint(L, 2);
int y = luaL_checkint(L, 3);
int width = luaL_checkint(L, 4);
int height = luaL_checkint(L, 5);
int screen = luaL_optint(L, 6, SCREEN_MAIN);
rb->screens[screen]->transparent_bitmap(src->data, x, y, width, height);
return 0;
}
#endif /* LCD_DEPTH == 16 */
#endif /* defined(LCD_BITMAP) */
RB_WRAP(current_tick)
{
lua_pushinteger(L, *rb->current_tick);
return 1;
}
#ifdef HAVE_TOUCHSCREEN
RB_WRAP(action_get_touchscreen_press)
{
short x, y;
int result = rb->action_get_touchscreen_press(&x, &y);
lua_pushinteger(L, result);
lua_pushinteger(L, x);
lua_pushinteger(L, y);
return 3;
}
#endif
RB_WRAP(kbd_input)
{
luaL_Buffer b;
luaL_buffinit(L, &b);
const char *input = luaL_optstring(L, 1, NULL);
char *buffer = luaL_prepbuffer(&b);
if(input != NULL)
rb->strlcpy(buffer, input, LUAL_BUFFERSIZE);
else
buffer[0] = '\0';
if(!rb->kbd_input(buffer, LUAL_BUFFERSIZE))
{
luaL_addsize(&b, strlen(buffer));
luaL_pushresult(&b);
}
else
lua_pushnil(L);
return 1;
}
#ifdef HAVE_TOUCHSCREEN
RB_WRAP(touchscreen_set_mode)
{
enum touchscreen_mode mode = luaL_checkint(L, 1);
rb->touchscreen_set_mode(mode);
return 0;
}
RB_WRAP(touchscreen_get_mode)
{
lua_pushinteger(L, rb->touchscreen_get_mode());
return 1;
}
#endif
RB_WRAP(font_getstringsize)
{
const unsigned char* str = luaL_checkstring(L, 1);
int fontnumber = luaL_checkint(L, 2);
int w, h;
if (fontnumber == FONT_UI)
fontnumber = rb->global_status->font_id[SCREEN_MAIN];
else
fontnumber = FONT_SYSFIXED;
int result = rb->font_getstringsize(str, &w, &h, fontnumber);
lua_pushinteger(L, result);
lua_pushinteger(L, w);
lua_pushinteger(L, h);
return 3;
}
#ifdef HAVE_LCD_COLOR
RB_WRAP(lcd_rgbpack)
{
int r = luaL_checkint(L, 1);
int g = luaL_checkint(L, 2);
int b = luaL_checkint(L, 3);
int result = LCD_RGBPACK(r, g, b);
lua_pushinteger(L, result);
return 1;
}
RB_WRAP(lcd_rgbunpack)
{
int rgb = luaL_checkint(L, 1);
lua_pushinteger(L, RGB_UNPACK_RED(rgb));
lua_pushinteger(L, RGB_UNPACK_GREEN(rgb));
lua_pushinteger(L, RGB_UNPACK_BLUE(rgb));
return 3;
}
#endif
RB_WRAP(read_bmp_file)
{
struct bitmap bm;
const char* filename = luaL_checkstring(L, 1);
bool dither = luaL_optboolean(L, 2, true);
bool transparent = luaL_optboolean(L, 3, false);
int format = FORMAT_NATIVE;
if(dither)
format |= FORMAT_DITHER;
if(transparent)
format |= FORMAT_TRANSPARENT;
int result = rb->read_bmp_file(filename, &bm, 0, format | FORMAT_RETURN_SIZE, NULL);
if(result > 0)
{
bm.data = (unsigned char*) rli_alloc(L, bm.width, bm.height);
if(rb->read_bmp_file(filename, &bm, result, format, NULL) < 0)
{
/* Error occured, drop newly allocated image from stack */
lua_pop(L, 1);
lua_pushnil(L);
}
}
else
lua_pushnil(L);
return 1;
}
RB_WRAP(current_path)
{
const char *current_path = get_current_path(L, 1);
if(current_path != NULL)
lua_pushstring(L, current_path);
else
lua_pushnil(L);
return 1;
}
static void fill_text_message(lua_State *L, struct text_message * message,
int pos)
{
int i;
luaL_checktype(L, pos, LUA_TTABLE);
int n = luaL_getn(L, pos);
const char **lines = (const char**) tlsf_malloc(n * sizeof(const char*));
if(lines == NULL)
luaL_error(L, "Can't allocate %d bytes!", n * sizeof(const char*));
for(i=1; i<=n; i++)
{
lua_rawgeti(L, pos, i);
lines[i-1] = luaL_checkstring(L, -1);
lua_pop(L, 1);
}
message->message_lines = lines;
message->nb_lines = n;
}
RB_WRAP(gui_syncyesno_run)
{
struct text_message main_message, yes_message, no_message;
struct text_message *yes = NULL, *no = NULL;
fill_text_message(L, &main_message, 1);
if(!lua_isnoneornil(L, 2))
fill_text_message(L, (yes = &yes_message), 2);
if(!lua_isnoneornil(L, 3))
fill_text_message(L, (no = &no_message), 3);
enum yesno_res result = rb->gui_syncyesno_run(&main_message, yes, no);
tlsf_free(main_message.message_lines);
if(yes)
tlsf_free(yes_message.message_lines);
if(no)
tlsf_free(no_message.message_lines);
lua_pushinteger(L, result);
return 1;
}
RB_WRAP(do_menu)
{
struct menu_callback_with_desc menu_desc = {NULL, NULL, Icon_NOICON};
struct menu_item_ex menu = {MT_RETURN_ID | MENU_HAS_DESC, {.strings = NULL},
{.callback_and_desc = &menu_desc}};
int i, n, start_selected;
const char **items, *title;
title = luaL_checkstring(L, 1);
luaL_checktype(L, 2, LUA_TTABLE);
start_selected = luaL_optint(L, 3, 0);
n = luaL_getn(L, 2);
items = (const char**) tlsf_malloc(n * sizeof(const char*));
if(items == NULL)
luaL_error(L, "Can't allocate %d bytes!", n * sizeof(const char*));
for(i=1; i<=n; i++)
{
lua_rawgeti(L, 2, i); /* Push item on the stack */
items[i-1] = luaL_checkstring(L, -1);
lua_pop(L, 1); /* Pop it */
}
menu.strings = items;
menu.flags |= MENU_ITEM_COUNT(n);
menu_desc.desc = (unsigned char*) title;
int result = rb->do_menu(&menu, &start_selected, NULL, false);
tlsf_free(items);
lua_pushinteger(L, result);
return 1;
}
RB_WRAP(playlist_sync)
{
/* just pass NULL to work with the current playlist */
rb->playlist_sync(NULL);
return 1;
}
RB_WRAP(playlist_remove_all_tracks)
{
/* just pass NULL to work with the current playlist */
int result = rb->playlist_remove_all_tracks(NULL);
lua_pushinteger(L, result);
return 1;
}
RB_WRAP(playlist_insert_track)
{
const char *filename;
int position, queue, sync;
/* for now don't take a playlist_info pointer, but just pass NULL to use
the current playlist. If this changes later, all the other
parameters can be shifted back. */
filename = luaL_checkstring(L, 1); /* only required parameter */
position = luaL_optint(L, 2, PLAYLIST_INSERT);
queue = lua_toboolean(L, 3); /* default to false */
sync = lua_toboolean(L, 4); /* default to false */
int result = rb->playlist_insert_track(NULL, filename, position,
queue, sync);
lua_pushinteger(L, result);
return 1;
}
RB_WRAP(playlist_insert_directory)
{
const char* dirname;
int position, queue, recurse;
/* just like in playlist_insert_track, only works with current playlist. */
dirname = luaL_checkstring(L, 1); /* only required parameter */
position = luaL_optint(L, 2, PLAYLIST_INSERT);
queue = lua_toboolean(L, 3); /* default to false */
recurse = lua_toboolean(L, 4); /* default to false */
int result = rb->playlist_insert_directory(NULL, dirname, position,
queue, recurse);
lua_pushinteger(L, result);
return 1;
}
SIMPLE_VOID_WRAPPER(backlight_force_on);
SIMPLE_VOID_WRAPPER(backlight_use_settings);
#ifdef HAVE_REMOTE_LCD
SIMPLE_VOID_WRAPPER(remote_backlight_force_on);
SIMPLE_VOID_WRAPPER(remote_backlight_use_settings);
#endif
#ifdef HAVE_BUTTON_LIGHT
SIMPLE_VOID_WRAPPER(buttonlight_force_on);
SIMPLE_VOID_WRAPPER(buttonlight_use_settings);
#endif
#ifdef HAVE_BACKLIGHT_BRIGHTNESS
RB_WRAP(backlight_brightness_set)
{
int brightness = luaL_checkint(L, 1);
backlight_brightness_set(brightness);
return 0;
}
SIMPLE_VOID_WRAPPER(backlight_brightness_use_setting);
#endif
RB_WRAP(get_plugin_action)
{
static const struct button_mapping *m1[] = { pla_main_ctx };
int timeout = luaL_checkint(L, 1);
int btn;
#ifdef HAVE_REMOTE_LCD
static const struct button_mapping *m2[] = { pla_main_ctx, pla_remote_ctx };
bool with_remote = luaL_optint(L, 2, 0);
if (with_remote)
btn = pluginlib_getaction(timeout, m2, 2);
else
#endif
btn = pluginlib_getaction(timeout, m1, 1);
lua_pushinteger(L, btn);
return 1;
}
#define R(NAME) {#NAME, rock_##NAME}
static const luaL_Reg rocklib[] =
{
/* Graphics */
#ifdef HAVE_LCD_BITMAP
R(lcd_framebuffer),
R(lcd_mono_bitmap_part),
R(lcd_mono_bitmap),
#if LCD_DEPTH > 1
R(lcd_get_backdrop),
R(lcd_bitmap_part),
R(lcd_bitmap),
#endif
#if LCD_DEPTH == 16
R(lcd_bitmap_transparent_part),
R(lcd_bitmap_transparent),
#endif
#endif
#ifdef HAVE_LCD_COLOR
R(lcd_rgbpack),
R(lcd_rgbunpack),
#endif
/* Kernel */
R(current_tick),
/* Buttons */
#ifdef HAVE_TOUCHSCREEN
R(action_get_touchscreen_press),
R(touchscreen_set_mode),
R(touchscreen_get_mode),
#endif
R(kbd_input),
R(font_getstringsize),
R(read_bmp_file),
R(set_viewport),
R(clear_viewport),
R(current_path),
R(gui_syncyesno_run),
R(playlist_sync),
R(playlist_remove_all_tracks),
R(playlist_insert_track),
R(playlist_insert_directory),
R(do_menu),
/* Backlight helper */
R(backlight_force_on),
R(backlight_use_settings),
#ifdef HAVE_REMOTE_LCD
R(remote_backlight_force_on),
R(remote_backlight_use_settings),
#endif
#ifdef HAVE_BUTTON_LIGHT
R(buttonlight_force_on),
R(buttonlight_use_settings),
#endif
#ifdef HAVE_BACKLIGHT_BRIGHTNESS
R(backlight_brightness_set),
R(backlight_brightness_use_setting),
#endif
R(get_plugin_action),
{"new_image", rli_new},
{NULL, NULL}
};
#undef R
extern const luaL_Reg rocklib_aux[];
#define RB_CONSTANT(x) lua_pushinteger(L, x); lua_setfield(L, -2, #x);
#define RB_STRING_CONSTANT(x) lua_pushstring(L, x); lua_setfield(L, -2, #x);
/*
** Open Rockbox library
*/
LUALIB_API int luaopen_rock(lua_State *L)
{
luaL_register(L, LUA_ROCKLIBNAME, rocklib);
luaL_register(L, LUA_ROCKLIBNAME, rocklib_aux);
RB_CONSTANT(HZ);
RB_CONSTANT(LCD_WIDTH);
RB_CONSTANT(LCD_HEIGHT);
RB_CONSTANT(LCD_DEPTH);
RB_CONSTANT(FONT_SYSFIXED);
RB_CONSTANT(FONT_UI);
RB_CONSTANT(PLAYLIST_PREPEND);
RB_CONSTANT(PLAYLIST_INSERT);
RB_CONSTANT(PLAYLIST_INSERT_LAST);
RB_CONSTANT(PLAYLIST_INSERT_FIRST);
RB_CONSTANT(PLAYLIST_INSERT_SHUFFLED);
RB_CONSTANT(PLAYLIST_REPLACE);
RB_CONSTANT(PLAYLIST_INSERT_LAST_SHUFFLED);
#ifdef HAVE_TOUCHSCREEN
RB_CONSTANT(TOUCHSCREEN_POINT);
RB_CONSTANT(TOUCHSCREEN_BUTTON);
#endif
RB_CONSTANT(SCREEN_MAIN);
#ifdef HAVE_REMOTE_LCD
RB_CONSTANT(SCREEN_REMOTE);
#endif
/* some useful paths constants */
RB_STRING_CONSTANT(ROCKBOX_DIR);
RB_STRING_CONSTANT(HOME_DIR);
RB_STRING_CONSTANT(PLUGIN_DIR);
RB_STRING_CONSTANT(PLUGIN_APPS_DATA_DIR);
RB_STRING_CONSTANT(PLUGIN_GAMES_DATA_DIR);
RB_STRING_CONSTANT(PLUGIN_DATA_DIR);
RB_STRING_CONSTANT(VIEWERS_DATA_DIR);
rli_init(L);
return 1;
}
Reference in a new issue View git blame Copy permalink