| /*************************************************************************** |
| * __________ __ ___. |
| * 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_data) luaL_checknumber(L, 4); |
| *rli_element(L) = newvalue; |
| return 0; |
| } |
| |
| static int rli_get(lua_State *L) |
| { |
| lua_pushnumber(L, *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); |
| #ifdef HAVE_LCD_COLOR |
| check_tablevalue(L, "lss_pattern", tablepos, &vp->lss_pattern, true); |
| check_tablevalue(L, "lse_pattern", tablepos, &vp->lse_pattern, true); |
| check_tablevalue(L, "lst_pattern", tablepos, &vp->lst_pattern, true); |
| #endif |
| #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**) dlmalloc(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); |
| |
| dlfree(main_message.message_lines); |
| if(yes) |
| dlfree(yes_message.message_lines); |
| if(no) |
| dlfree(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**) dlmalloc(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); |
| |
| dlfree(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; |
| } |