radio/src/lua/widgets.cpp

   1 /*
   2  * Copyright (C) OpenTX
   3  *
   4  * Based on code named
   5  *   th9x - http://code.google.com/p/th9x
   6  *   er9x - http://code.google.com/p/er9x
   7  *   gruvin9x - http://code.google.com/p/gruvin9x
   8  *
   9  * License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License version 2 as
  13  * published by the Free Software Foundation.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  */
  20
  21 #include <ctype.h>
  22 #include <stdio.h>
  23 #include "opentx.h"
  24 #include "bin_allocator.h"
  25 #include "lua_api.h"
  26
  27 #define WIDGET_SCRIPTS_MAX_INSTRUCTIONS    (10000/100)
  28 #define MANUAL_SCRIPTS_MAX_INSTRUCTIONS    (20000/100)
  29 #define LUA_WARNING_INFO_LEN               64
  30
  31 lua_State *lsWidgets = NULL;
  32 extern int custom_lua_atpanic(lua_State *L);
  33
  34 #define LUA_WIDGET_FILENAME                "/main.lua"
  35 #define LUA_FULLPATH_MAXLEN                (LEN_FILE_PATH_MAX + LEN_SCRIPT_FILENAME + LEN_FILE_EXTENSION_MAX)  // max length (example: /SCRIPTS/THEMES/mytheme.lua)
  36
  37 void exec(int function, int nresults=0)
  38 {
  39   if (lsWidgets == 0) return;
  40
  41   if (function) {
  42     luaSetInstructionsLimit(lsWidgets, WIDGET_SCRIPTS_MAX_INSTRUCTIONS);
  43     lua_rawgeti(lsWidgets, LUA_REGISTRYINDEX, function);
  44     if (lua_pcall(lsWidgets, 0, nresults, 0) != 0) {
  45       TRACE("Error in theme  %s", lua_tostring(lsWidgets, -1));
  46       // TODO disable theme - revert back to default theme???
  47     }
  48   }
  49 }
  50
  51 ZoneOption * createOptionsArray(int reference, uint8_t maxOptions)
  52 {
  53   if (reference == 0) {
  54     // TRACE("createOptionsArray() no options");
  55     return NULL;
  56   }
  57
  58   int count = 0;
  59   lua_rawgeti(lsWidgets, LUA_REGISTRYINDEX, reference);
  60   for (lua_pushnil(lsWidgets); lua_next(lsWidgets, -2); lua_pop(lsWidgets, 1)) {
  61     count++;
  62   }
  63
  64   // TRACE("we have %d options", count);
  65   if (count > maxOptions) {
  66     count = maxOptions;
  67     // TRACE("limited to %d options", count);
  68   }
  69
  70   ZoneOption * options = (ZoneOption *)malloc(sizeof(ZoneOption) * (count+1));
  71   if (!options) {
  72     return NULL;
  73   }
  74
  75   PROTECT_LUA() {
  76     lua_rawgeti(lsWidgets, LUA_REGISTRYINDEX, reference);
  77     ZoneOption * option = options;
  78     for (lua_pushnil(lsWidgets); lua_next(lsWidgets, -2), count-- > 0; lua_pop(lsWidgets, 1)) {
  79       // TRACE("parsing option %d", count);
  80       luaL_checktype(lsWidgets, -2, LUA_TNUMBER); // key is number
  81       luaL_checktype(lsWidgets, -1, LUA_TTABLE); // value is table
  82       uint8_t field = 0;
  83       for (lua_pushnil(lsWidgets); lua_next(lsWidgets, -2) && field<5; lua_pop(lsWidgets, 1), field++) {
  84         switch (field) {
  85           case 0:
  86             luaL_checktype(lsWidgets, -2, LUA_TNUMBER); // key is number
  87             luaL_checktype(lsWidgets, -1, LUA_TSTRING); // value is string
  88             option->name = lua_tostring(lsWidgets, -1);
  89             // TRACE("name = %s", option->name);
  90             break;
  91           case 1:
  92             luaL_checktype(lsWidgets, -2, LUA_TNUMBER); // key is number
  93             luaL_checktype(lsWidgets, -1, LUA_TNUMBER); // value is number
  94             option->type = (ZoneOption::Type)lua_tointeger(lsWidgets, -1);
  95             // TRACE("type = %d", option->type);
  96             if (option->type > ZoneOption::Color) {
  97               // wrong type
  98               option->type = ZoneOption::Integer;
  99             }
 100             if (option->type == ZoneOption::Integer) {
 101               // set some sensible defaults (only Integer actually uses them)
 102               option->deflt.signedValue = 0;
 103               option->min.signedValue = -100;
 104               option->max.signedValue = 100;
 105             }
 106             break;
 107           case 2:
 108             luaL_checktype(lsWidgets, -2, LUA_TNUMBER); // key is number
 109             if (option->type == ZoneOption::Integer) {
 110               luaL_checktype(lsWidgets, -1, LUA_TNUMBER); // value is number
 111               option->deflt.signedValue = lua_tointeger(lsWidgets, -1);
 112               // TRACE("default signed = %d", option->deflt.signedValue);
 113             }
 114             else if (option->type == ZoneOption::Source ||
 115                      option->type == ZoneOption::TextSize ||
 116                      option->type == ZoneOption::Color) {
 117               luaL_checktype(lsWidgets, -1, LUA_TNUMBER); // value is number
 118               option->deflt.unsignedValue = lua_tounsigned(lsWidgets, -1);
 119               // TRACE("default unsigned = %u", option->deflt.unsignedValue);
 120             }
 121             else if (option->type == ZoneOption::Bool) {
 122               luaL_checktype(lsWidgets, -1, LUA_TNUMBER); // value is number
 123               option->deflt.boolValue = (lua_tounsigned(lsWidgets, -1) != 0);
 124               // TRACE("default bool = %d", (int)(option->deflt.boolValue));
 125             }
 126             else if (option->type == ZoneOption::String) {
 127               str2zchar(option->deflt.stringValue, lua_tostring(lsWidgets, -1), sizeof(option->deflt.stringValue));  // stringValue is ZCHAR
 128               // TRACE("default string = %s", lua_tostring(lsWidgets, -1));
 129             }
 130             break;
 131           case 3:
 132             if (option->type == ZoneOption::Integer) {
 133               luaL_checktype(lsWidgets, -2, LUA_TNUMBER); // key is number
 134               luaL_checktype(lsWidgets, -1, LUA_TNUMBER); // value is number
 135               option->min.signedValue = lua_tointeger(lsWidgets, -1);
 136             }
 137             break;
 138           case 4:
 139             if (option->type == ZoneOption::Integer) {
 140               luaL_checktype(lsWidgets, -2, LUA_TNUMBER); // key is number
 141               luaL_checktype(lsWidgets, -1, LUA_TNUMBER); // value is number
 142               option->max.signedValue = lua_tointeger(lsWidgets, -1);
 143             }
 144             break;
 145         }
 146       }
 147       option++;
 148     }
 149     option->name = NULL; // sentinel
 150   }
 151   else {
 152     TRACE("error in theme/widget options");
 153     free(options);
 154     return NULL;
 155   }
 156   UNPROTECT_LUA();
 157   return options;
 158 }
 159
 160 class LuaTheme: public Theme
 161 {
 162   friend void luaLoadThemeCallback();
 163
 164   public:
 165     LuaTheme(const char * name, ZoneOption * options):
 166       Theme(name, options),
 167       loadFunction(0),
 168       drawBackgroundFunction(0),
 169       drawTopbarBackgroundFunction(0),
 170       drawAlertBoxFunction(0)
 171     {
 172     }
 173
 174     virtual void load() const
 175     {
 176       luaLcdAllowed = true;
 177       exec(loadFunction);
 178     }
 179
 180     virtual void drawBackground() const
 181     {
 182       exec(drawBackgroundFunction);
 183     }
 184
 185     virtual void drawTopbarBackground(uint8_t icon) const
 186     {
 187       exec(drawTopbarBackgroundFunction);
 188     }
 189
 190 #if 0
 191     virtual void drawAlertBox(const char * title, const char * text, const char * action) const
 192     {
 193       exec(drawAlertBoxFunction);
 194     }
 195 #endif
 196
 197   protected:
 198     int loadFunction;
 199     int drawBackgroundFunction;
 200     int drawTopbarBackgroundFunction;
 201     int drawAlertBoxFunction;
 202 };
 203
 204 void luaLoadThemeCallback()
 205 {
 206   TRACE("luaLoadThemeCallback()");
 207   const char * name=NULL;
 208   int themeOptions=0, loadFunction=0, drawBackgroundFunction=0, drawTopbarBackgroundFunction=0;
 209
 210   luaL_checktype(lsWidgets, -1, LUA_TTABLE);
 211
 212   for (lua_pushnil(lsWidgets); lua_next(lsWidgets, -2); lua_pop(lsWidgets, 1)) {
 213     const char * key = lua_tostring(lsWidgets, -2);
 214     if (!strcmp(key, "name")) {
 215       name = luaL_checkstring(lsWidgets, -1);
 216     }
 217     else if (!strcmp(key, "options")) {
 218       themeOptions = luaL_ref(lsWidgets, LUA_REGISTRYINDEX);
 219       lua_pushnil(lsWidgets);
 220     }
 221     else if (!strcmp(key, "load")) {
 222       loadFunction = luaL_ref(lsWidgets, LUA_REGISTRYINDEX);
 223       lua_pushnil(lsWidgets);
 224     }
 225     else if (!strcmp(key, "drawBackground")) {
 226       drawBackgroundFunction = luaL_ref(lsWidgets, LUA_REGISTRYINDEX);
 227       lua_pushnil(lsWidgets);
 228     }
 229     else if (!strcmp(key, "drawTopbarBackground")) {
 230       drawTopbarBackgroundFunction = luaL_ref(lsWidgets, LUA_REGISTRYINDEX);
 231       lua_pushnil(lsWidgets);
 232     }
 233   }
 234
 235   if (name) {
 236     ZoneOption * options = NULL;
 237     if (themeOptions) {
 238       options = createOptionsArray(themeOptions, MAX_THEME_OPTIONS);
 239       if (!options)
 240         return;
 241     }
 242     LuaTheme * theme = new LuaTheme(name, options);
 243     theme->loadFunction = loadFunction;
 244     theme->drawBackgroundFunction = drawBackgroundFunction;
 245     theme->drawTopbarBackgroundFunction = drawTopbarBackgroundFunction;   // NOSONAR
 246     TRACE("Loaded Lua theme %s", name);
 247   }
 248 }
 249
 250 class LuaWidget: public Widget
 251 {
 252   public:
 253     LuaWidget(const WidgetFactory * factory, const Zone & zone, Widget::PersistentData * persistentData, int widgetData):
 254       Widget(factory, zone, persistentData),
 255       widgetData(widgetData),
 256       errorMessage(0)
 257     {
 258     }
 259
 260     virtual ~LuaWidget()
 261     {
 262       luaL_unref(lsWidgets, LUA_REGISTRYINDEX, widgetData);
 263       if (errorMessage) free(errorMessage);
 264     }
 265
 266     virtual void update();
 267
 268     virtual void refresh();
 269
 270     virtual void background();
 271
 272     virtual const char * getErrorMessage() const;
 273
 274   protected:
 275     int widgetData;
 276     char * errorMessage;
 277
 278     void setErrorMessage(const char * funcName);
 279 };
 280
 281 void l_pushtableint(const char * key, int value)
 282 {
 283   lua_pushstring(lsWidgets, key);
 284   lua_pushinteger(lsWidgets, value);
 285   lua_settable(lsWidgets, -3);
 286 }
 287
 288 class LuaWidgetFactory: public WidgetFactory
 289 {
 290   friend void luaLoadWidgetCallback();
 291   friend class LuaWidget;
 292
 293   public:
 294     LuaWidgetFactory(const char * name, ZoneOption * widgetOptions, int createFunction):
 295       WidgetFactory(name, widgetOptions),
 296       createFunction(createFunction),
 297       updateFunction(0),
 298       refreshFunction(0),
 299       backgroundFunction(0)
 300     {
 301     }
 302
 303     virtual Widget * create(const Zone & zone, Widget::PersistentData * persistentData, bool init=true) const
 304     {
 305       if (lsWidgets == 0) return 0;
 306       if (init) {
 307         initPersistentData(persistentData);
 308       }
 309
 310       luaSetInstructionsLimit(lsWidgets, WIDGET_SCRIPTS_MAX_INSTRUCTIONS);
 311       lua_rawgeti(lsWidgets, LUA_REGISTRYINDEX, createFunction);
 312
 313       lua_newtable(lsWidgets);
 314       l_pushtableint("x", zone.x);
 315       l_pushtableint("y", zone.y);
 316       l_pushtableint("w", zone.w);
 317       l_pushtableint("h", zone.h);
 318
 319       lua_newtable(lsWidgets);
 320       int i = 0;
 321       for (const ZoneOption * option = options; option->name; option++, i++) {
 322         l_pushtableint(option->name, persistentData->options[i].signedValue);
 323       }
 324
 325       if (lua_pcall(lsWidgets, 2, 1, 0) != 0) {
 326         TRACE("Error in widget %s create() function: %s", getName(), lua_tostring(lsWidgets, -1));
 327       }
 328       int widgetData = luaL_ref(lsWidgets, LUA_REGISTRYINDEX);
 329       Widget * widget = new LuaWidget(this, zone, persistentData, widgetData);
 330       return widget;
 331     }
 332
 333   protected:
 334     int createFunction;
 335     int updateFunction;
 336     int refreshFunction;
 337     int backgroundFunction;
 338 };
 339
 340 void LuaWidget::update()
 341 {
 342   if (lsWidgets == 0 || errorMessage) return;
 343
 344   luaSetInstructionsLimit(lsWidgets, WIDGET_SCRIPTS_MAX_INSTRUCTIONS);
 345   LuaWidgetFactory * factory = (LuaWidgetFactory *)this->factory;
 346   lua_rawgeti(lsWidgets, LUA_REGISTRYINDEX, factory->updateFunction);
 347   lua_rawgeti(lsWidgets, LUA_REGISTRYINDEX, widgetData);
 348
 349   lua_newtable(lsWidgets);
 350   int i = 0;
 351   for (const ZoneOption * option = getOptions(); option->name; option++, i++) {
 352     l_pushtableint(option->name, persistentData->options[i].signedValue);
 353   }
 354
 355   if (lua_pcall(lsWidgets, 2, 0, 0) != 0) {
 356     setErrorMessage("update()");
 357   }
 358 }
 359
 360 void LuaWidget::setErrorMessage(const char * funcName)
 361 {
 362   TRACE("Error in widget %s %s function: %s", factory->getName(), funcName, lua_tostring(lsWidgets, -1));
 363   TRACE("Widget disabled");
 364   size_t needed = snprintf(NULL, 0, "%s: %s", funcName, lua_tostring(lsWidgets, -1)) + 1;
 365   errorMessage = (char *)malloc(needed);
 366   if (errorMessage) {
 367     snprintf(errorMessage, needed, "%s: %s", funcName, lua_tostring(lsWidgets, -1));
 368   }
 369 }
 370
 371 const char * LuaWidget::getErrorMessage() const
 372 {
 373   return errorMessage;
 374 }
 375
 376 void LuaWidget::refresh()
 377 {
 378   if (lsWidgets == 0) return;
 379
 380   if (errorMessage) {
 381     lcdSetColor(RED);
 382     lcdDrawText(zone.x, zone.y, "Disabled", SMLSIZE|CUSTOM_COLOR);
 383     return;
 384   }
 385
 386   luaSetInstructionsLimit(lsWidgets, WIDGET_SCRIPTS_MAX_INSTRUCTIONS);
 387   LuaWidgetFactory * factory = (LuaWidgetFactory *)this->factory;
 388   lua_rawgeti(lsWidgets, LUA_REGISTRYINDEX, factory->refreshFunction);
 389   lua_rawgeti(lsWidgets, LUA_REGISTRYINDEX, widgetData);
 390   if (lua_pcall(lsWidgets, 1, 0, 0) != 0) {
 391     setErrorMessage("refresh()");
 392   }
 393 }
 394
 395 void LuaWidget::background()
 396 {
 397   if (lsWidgets == 0 || errorMessage) return;
 398
 399   luaSetInstructionsLimit(lsWidgets, WIDGET_SCRIPTS_MAX_INSTRUCTIONS);
 400   LuaWidgetFactory * factory = (LuaWidgetFactory *)this->factory;
 401   if (factory->backgroundFunction) {
 402     lua_rawgeti(lsWidgets, LUA_REGISTRYINDEX, factory->backgroundFunction);
 403     lua_rawgeti(lsWidgets, LUA_REGISTRYINDEX, widgetData);
 404     if (lua_pcall(lsWidgets, 1, 0, 0) != 0) {
 405       setErrorMessage("background()");
 406     }
 407   }
 408 }
 409
 410 void luaLoadWidgetCallback()
 411 {
 412   TRACE("luaLoadWidgetCallback()");
 413   const char * name=NULL;
 414   int widgetOptions=0, createFunction=0, updateFunction=0, refreshFunction=0, backgroundFunction=0;
 415
 416   luaL_checktype(lsWidgets, -1, LUA_TTABLE);
 417
 418   for (lua_pushnil(lsWidgets); lua_next(lsWidgets, -2); lua_pop(lsWidgets, 1)) {
 419     const char * key = lua_tostring(lsWidgets, -2);
 420     if (!strcmp(key, "name")) {
 421       name = luaL_checkstring(lsWidgets, -1);
 422     }
 423     else if (!strcmp(key, "options")) {
 424       widgetOptions = luaL_ref(lsWidgets, LUA_REGISTRYINDEX);
 425       lua_pushnil(lsWidgets);
 426     }
 427     else if (!strcmp(key, "create")) {
 428       createFunction = luaL_ref(lsWidgets, LUA_REGISTRYINDEX);
 429       lua_pushnil(lsWidgets);
 430     }
 431     else if (!strcmp(key, "update")) {
 432       updateFunction = luaL_ref(lsWidgets, LUA_REGISTRYINDEX);
 433       lua_pushnil(lsWidgets);
 434     }
 435     else if (!strcmp(key, "refresh")) {
 436       refreshFunction = luaL_ref(lsWidgets, LUA_REGISTRYINDEX);
 437       lua_pushnil(lsWidgets);
 438     }
 439     else if (!strcmp(key, "background")) {
 440       backgroundFunction = luaL_ref(lsWidgets, LUA_REGISTRYINDEX);
 441       lua_pushnil(lsWidgets);
 442     }
 443   }
 444
 445   if (name && createFunction) {
 446     ZoneOption * options = createOptionsArray(widgetOptions, MAX_WIDGET_OPTIONS);
 447     if (options) {
 448       LuaWidgetFactory * factory = new LuaWidgetFactory(name, options, createFunction);
 449       factory->updateFunction = updateFunction;
 450       factory->refreshFunction = refreshFunction;
 451       factory->backgroundFunction = backgroundFunction;   // NOSONAR
 452       TRACE("Loaded Lua widget %s", name);
 453     }
 454   }
 455 }
 456
 457 void luaLoadFile(const char * filename, void (*callback)())
 458 {
 459   if (lsWidgets == NULL || callback == NULL)
 460     return;
 461
 462   TRACE("luaLoadFile(%s)", filename);
 463
 464   luaSetInstructionsLimit(lsWidgets, MANUAL_SCRIPTS_MAX_INSTRUCTIONS);
 465
 466   PROTECT_LUA() {
 467     if (luaLoadScriptFileToState(lsWidgets, filename, LUA_SCRIPT_LOAD_MODE) == SCRIPT_OK) {
 468       if (lua_pcall(lsWidgets, 0, 1, 0) == LUA_OK && lua_istable(lsWidgets, -1)) {
 469         (*callback)();
 470       }
 471       else {
 472         TRACE("luaLoadFile(%s): Error parsing script: %s", filename, lua_tostring(lsWidgets, -1));
 473       }
 474     }
 475   }
 476   else {
 477     // error while loading Lua widget/theme,
 478     // do not disable whole Lua state, just ingnore bad widget/theme
 479     return;
 480   }
 481   UNPROTECT_LUA();
 482 }
 483
 484 void luaLoadFiles(const char * directory, void (*callback)())
 485 {
 486   char path[LUA_FULLPATH_MAXLEN+1];
 487   FILINFO fno;
 488   DIR dir;
 489
 490   strcpy(path, directory);
 491   TRACE("luaLoadFiles() %s", path);
 492
 493   FRESULT res = f_opendir(&dir, path);        /* Open the directory */
 494
 495   if (res == FR_OK) {
 496     int pathlen = strlen(path);
 497     path[pathlen++] = '/';
 498     for (;;) {
 499       res = f_readdir(&dir, &fno);                   /* Read a directory item */
 500       if (res != FR_OK || fno.fname[0] == 0) break;  /* Break on error or end of dir */
 501       uint8_t len = strlen(fno.fname);
 502       if (len > 0 && (unsigned int)(len + pathlen + sizeof(LUA_WIDGET_FILENAME)) <= sizeof(path) &&
 503           fno.fname[0]!='.' && (fno.fattrib & AM_DIR)) {
 504         strcpy(&path[pathlen], fno.fname);
 505         strcat(&path[pathlen], LUA_WIDGET_FILENAME);
 506         if (isFileAvailable(path)) {
 507           luaLoadFile(path, callback);
 508         }
 509       }
 510     }
 511   }
 512   else {
 513     TRACE("f_opendir(%s) failed, code=%d", path, res);
 514   }
 515
 516   f_closedir(&dir);
 517 }
 518
 519 #if defined(LUA_ALLOCATOR_TRACER)
 520 LuaMemTracer lsWidgetsTrace;
 521 #endif
 522
 523 void luaInitThemesAndWidgets()
 524 {
 525   TRACE("luaInitThemesAndWidgets");
 526
 527 #if defined(USE_BIN_ALLOCATOR)
 528   lsWidgets = lua_newstate(bin_l_alloc, NULL);   //we use our own allocator!
 529 #elif defined(LUA_ALLOCATOR_TRACER)
 530   memset(&lsWidgetsTrace, 0 , sizeof(lsWidgetsTrace));
 531   lsWidgetsTrace.script = "lua_newstate(widgets)";
 532   lsWidgets = lua_newstate(tracer_alloc, &lsWidgetsTrace);   //we use tracer allocator
 533 #else
 534   lsWidgets = lua_newstate(l_alloc, NULL);   //we use Lua default allocator
 535 #endif
 536   if (lsWidgets) {
 537     // install our panic handler
 538     lua_atpanic(lsWidgets, &custom_lua_atpanic);
 539
 540 #if defined(LUA_ALLOCATOR_TRACER)
 541     lua_sethook(lsWidgets, luaHook, LUA_MASKLINE, 0);
 542 #endif
 543
 544     // protect libs and constants registration
 545     PROTECT_LUA() {
 546       luaRegisterLibraries(lsWidgets);
 547     }
 548     else {
 549       // if we got panic during registration
 550       // we disable Lua for this session
 551       // luaDisable();
 552       luaClose(&lsWidgets);
 553       lsWidgets = 0;
 554     }
 555     UNPROTECT_LUA();
 556     TRACE("lsWidgets %p", lsWidgets);
 557     luaLoadFiles(THEMES_PATH, luaLoadThemeCallback);
 558     luaLoadFiles(WIDGETS_PATH, luaLoadWidgetCallback);
 559     luaDoGc(lsWidgets, true);
 560   }
 561 }