radio/src/lua/api_lcd.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 "lua_api.h"
  25
  26 /*luadoc
  27 @function lcd.refresh()
  28
  29 Refresh the LCD screen
  30
  31 @status current Introduced in 2.2.0
  32
  33 @notice This function only works in stand-alone and telemetry scripts.
  34 */
  35 static int luaLcdRefresh(lua_State *L)
  36 {
  37   if (luaLcdAllowed) lcdRefresh();
  38   return 0;
  39 }
  40
  41 /*luadoc
  42 @function lcd.clear([color])
  43
  44 Clear the LCD screen
  45
  46 @param color (optional, only on color screens)
  47
  48 @status current Introduced in 2.0.0, `color` parameter introduced in 2.2.0 RC12
  49
  50 @notice This function only works in stand-alone and telemetry scripts.
  51 */
  52 static int luaLcdClear(lua_State *L)
  53 {
  54   if (luaLcdAllowed) {
  55 #if defined(COLORLCD)
  56     LcdFlags color = luaL_optunsigned(L, 1, TEXT_BGCOLOR);
  57     lcd->clear(color);
  58 #else
  59     lcdClear();
  60 #endif
  61   }
  62   return 0;
  63 }
  64
  65 /*luadoc
  66 @function lcd.drawPoint(x, y)
  67
  68 Draw a single pixel at (x,y) position
  69
  70 @param x (positive number) x position
  71
  72 @param y (positive number) y position
  73
  74 @notice Taranis has an LCD display width of 212 pixels and height of 64 pixels.
  75 Position (0,0) is at top left. Y axis is negative, top line is 0,
  76 bottom line is 63. Drawing on an existing black pixel produces white pixel (TODO check this!)
  77
  78 @status current Introduced in 2.0.0
  79 */
  80 static int luaLcdDrawPoint(lua_State *L)
  81 {
  82   if (!luaLcdAllowed) return 0;
  83   int x = luaL_checkinteger(L, 1);
  84   int y = luaL_checkinteger(L, 2);
  85   lcdDrawPoint(x, y);
  86   return 0;
  87 }
  88
  89 /*luadoc
  90 @function lcd.drawLine(x1, y1, x2, y2, pattern, flags)
  91
  92 Draw a straight line on LCD
  93
  94 @param x1,y1 (positive numbers) starting coordinate
  95
  96 @param x2,y2 (positive numbers) end coordinate
  97
  98 @param pattern TODO
  99
 100 @param flags TODO
 101
 102 @notice If the start or the end of the line is outside the LCD dimensions, then the
 103 whole line will not be drawn (starting from OpenTX 2.1.5)
 104
 105 @status current Introduced in 2.0.0
 106 */
 107 static int luaLcdDrawLine(lua_State *L)
 108 {
 109   if (!luaLcdAllowed) return 0;
 110   coord_t x1 = luaL_checkunsigned(L, 1);
 111   coord_t y1 = luaL_checkunsigned(L, 2);
 112   coord_t x2 = luaL_checkunsigned(L, 3);
 113   coord_t y2 = luaL_checkunsigned(L, 4);
 114   uint8_t pat = luaL_checkunsigned(L, 5);
 115   LcdFlags flags = luaL_checkunsigned(L, 6);
 116
 117   if (x1 > LCD_W || y1 > LCD_H || x2 > LCD_W || y2 > LCD_H)
 118     return 0;
 119
 120   if (pat == SOLID) {
 121     if (x1 == x2) {
 122       lcdDrawSolidVerticalLine(x1, y1<y2 ? y1 : y2,  y1<y2 ? (y2-y1)+1 : (y1-y2)+1, flags);
 123       return 0;
 124     }
 125     else if (y1 == y2) {
 126       lcdDrawSolidHorizontalLine(x1<x2 ? x1 : x2, y1, x1<x2 ? (x2-x1)+1 : (x1-x2)+1, flags);
 127       return 0;
 128     }
 129   }
 130
 131   lcdDrawLine(x1, y1, x2, y2, pat, flags);
 132   return 0;
 133 }
 134
 135 #if !defined(COLORLCD)
 136 /*luadoc
 137 @function lcd.getLastPos()
 138
 139 Returns the rightmost x position from previous output
 140
 141 @retval number (integer) x position
 142
 143 @notice Only available on Taranis
 144
 145 @notice For added clarity, it is recommended to use lcd.getLastRightPos()
 146
 147 @status current Introduced in 2.0.0
 148 */
 149
 150 /*luadoc
 151 @function lcd.getLastRightPos()
 152
 153 Returns the rightest x position from previous drawtext or drawNumber output
 154
 155 @retval number (integer) x position
 156
 157 @notice Only available on Taranis
 158
 159 @notice This is strictly equivalent to former lcd.getLastPos()
 160
 161 @status current Introduced in 2.2.0
 162 */
 163
 164 static int luaLcdGetLastPos(lua_State *L)
 165 {
 166   lua_pushinteger(L, lcdLastRightPos);
 167   return 1;
 168 }
 169
 170 /*luadoc
 171 @function lcd.getLastLeftPos()
 172
 173 Returns the leftmost x position from previous drawtext or drawNumber output
 174
 175 @retval number (integer) x position
 176
 177 @notice Only available on Taranis
 178
 179 @status current Introduced in 2.2.0
 180 */
 181 static int luaLcdGetLeftPos(lua_State *L)
 182 {
 183   lua_pushinteger(L, lcdLastLeftPos);
 184   return 1;
 185 }
 186
 187 #endif // COLORLCD
 188
 189 /*luadoc
 190 @function lcd.drawText(x, y, text [, flags])
 191
 192 Draw a text beginning at (x,y)
 193
 194 @param x,y (positive numbers) starting coordinate
 195
 196 @param text (string) text to display
 197
 198 @param flags (unsigned number) drawing flags. All values can be
 199 combined together using the + character. ie BLINK + DBLSIZE.
 200 See the [Appendix](../appendix/fonts.md) for available characters in each font set.
 201  * `0 or not specified` normal font
 202  * `XXLSIZE` jumbo sized font
 203  * `DBLSIZE` double size font
 204  * `MIDSIZE` mid sized font
 205  * `SMLSIZE` small font
 206  * `INVERS` inverted display
 207  * `BLINK` blinking text
 208  * `SHADOWED` Horus only, apply a shadow effect
 209
 210 @status current Introduced in 2.0.0, `SHADOWED` introduced in 2.2.1
 211 */
 212 static int luaLcdDrawText(lua_State *L)
 213 {
 214   if (!luaLcdAllowed) return 0;
 215   int x = luaL_checkinteger(L, 1);
 216   int y = luaL_checkinteger(L, 2);
 217   const char * s = luaL_checkstring(L, 3);
 218   unsigned int att = luaL_optunsigned(L, 4, 0);
 219   #if defined(COLORLCD)
 220   if ((att&SHADOWED) && !(att&INVERS)) lcdDrawText(x+1, y+1, s, att&0xFFFF);
 221   #endif
 222   lcdDrawText(x, y, s, att);
 223   return 0;
 224 }
 225
 226 /*luadoc
 227 @function lcd.drawTimer(x, y, value [, flags])
 228
 229 Display a value formatted as time at (x,y)
 230
 231 @param x,y (positive numbers) starting coordinate
 232
 233 @param value (number) time in seconds
 234
 235 @param flags (unsigned number) drawing flags:
 236  * `0 or not specified` normal representation (minutes and seconds)
 237  * `TIMEHOUR` display hours
 238  * other general LCD flag also apply
 239  * `SHADOWED` Horus only, apply a shadow effect
 240
 241 @status current Introduced in 2.0.0,  `SHADOWED` introduced in 2.2.1
 242 */
 243 static int luaLcdDrawTimer(lua_State *L)
 244 {
 245   if (!luaLcdAllowed) return 0;
 246   int x = luaL_checkinteger(L, 1);
 247   int y = luaL_checkinteger(L, 2);
 248   int seconds = luaL_checkinteger(L, 3);
 249   unsigned int att = luaL_optunsigned(L, 4, 0);
 250 #if defined(COLORLCD)
 251   if (att&SHADOWED) drawTimer(x+1, y+1, seconds, (att&0xFFFF)|LEFT);
 252   drawTimer(x, y, seconds, att|LEFT);
 253 #else
 254   drawTimer(x, y, seconds, att|LEFT, att);
 255 #endif
 256   return 0;
 257 }
 258
 259 /*luadoc
 260 @function lcd.drawNumber(x, y, value [, flags])
 261
 262 Display a number at (x,y)
 263
 264 @param x,y (positive numbers) starting coordinate
 265
 266 @param value (number) value to display
 267
 268 @param flags (unsigned number) drawing flags:
 269  * `0 or not specified` display with no decimal (like abs())
 270  * `PREC1` display with one decimal place (number 386 is displayed as 38.6)
 271  * `PREC2` display with tow decimal places (number 386 is displayed as 3.86)
 272  * other general LCD flag also apply
 273  * `SHADOWED` Horus only, apply a shadow effect
 274
 275 @status current Introduced in 2.0.0,  `SHADOWED` introduced in 2.2.1
 276 */
 277 static int luaLcdDrawNumber(lua_State *L)
 278 {
 279   if (!luaLcdAllowed) return 0;
 280   int x = luaL_checkinteger(L, 1);
 281   int y = luaL_checkinteger(L, 2);
 282   int val = luaL_checkinteger(L, 3);
 283   unsigned int att = luaL_optunsigned(L, 4, 0);
 284   #if defined(COLORLCD)
 285   if ((att&SHADOWED) && !(att&INVERS)) lcdDrawNumber(x, y, val, att&0xFFFF);
 286   #endif
 287   lcdDrawNumber(x, y, val, att);
 288   return 0;
 289 }
 290
 291 /*luadoc
 292 @function lcd.drawChannel(x, y, source, flags)
 293
 294 Display a telemetry value at (x,y)
 295
 296 @param x,y (positive numbers) starting coordinate
 297
 298 @param source can be a source identifier (number) or a source name (string).
 299 See getValue()
 300
 301 @param flags (unsigned number) drawing flags
 302
 303 @status current Introduced in 2.0.6, changed in 2.1.0 (only telemetry sources are valid)
 304 */
 305 static int luaLcdDrawChannel(lua_State *L)
 306 {
 307   if (!luaLcdAllowed) return 0;
 308   int x = luaL_checkinteger(L, 1);
 309   int y = luaL_checkinteger(L, 2);
 310   int channel = -1;
 311   if (lua_isnumber(L, 3)) {
 312     channel = luaL_checkinteger(L, 3);
 313   }
 314   else {
 315     const char * what = luaL_checkstring(L, 3);
 316     LuaField field;
 317     bool found = luaFindFieldByName(what, field);
 318     if (found) {
 319       channel = field.id;
 320     }
 321   }
 322   unsigned int att = luaL_optunsigned(L, 4, 0);
 323   getvalue_t value = getValue(channel);
 324   drawSensorCustomValue(x, y, (channel-MIXSRC_FIRST_TELEM)/3, value, att);
 325   return 0;
 326 }
 327
 328 /*luadoc
 329 @function lcd.drawSwitch(x, y, switch, flags)
 330
 331 Draw a text representation of switch at (x,y)
 332
 333 @param x,y (positive numbers) starting coordinate
 334
 335 @param switch (number) number of switch to display, negative number
 336 displays negated switch
 337
 338 @param flags (unsigned number) drawing flags, only SMLSIZE, BLINK and INVERS.
 339
 340 @status current Introduced in 2.0.0
 341 */
 342 static int luaLcdDrawSwitch(lua_State *L)
 343 {
 344   if (!luaLcdAllowed) return 0;
 345   int x = luaL_checkinteger(L, 1);
 346   int y = luaL_checkinteger(L, 2);
 347   int s = luaL_checkinteger(L, 3);
 348   unsigned int att = luaL_optunsigned(L, 4, 0);
 349   drawSwitch(x, y, s, att);
 350   return 0;
 351 }
 352
 353 /*luadoc
 354 @function lcd.drawSource(x, y, source [, flags])
 355
 356 Displays the name of the corresponding input as defined by the source at (x,y)
 357
 358 @param x,y (positive numbers) starting coordinate
 359
 360 @param source (number) source index
 361
 362 @param flags (unsigned number) drawing flags
 363
 364 @status current Introduced in 2.0.0
 365 */
 366 static int luaLcdDrawSource(lua_State *L)
 367 {
 368   if (!luaLcdAllowed) return 0;
 369   int x = luaL_checkinteger(L, 1);
 370   int y = luaL_checkinteger(L, 2);
 371   int s = luaL_checkinteger(L, 3);
 372   unsigned int att = luaL_optunsigned(L, 4, 0);
 373   drawSource(x, y, s, att);
 374   return 0;
 375 }
 376
 377 #if defined(COLORLCD)
 378
 379 #define LUA_BITMAPHANDLE          "BITMAP*"
 380
 381 /*luadoc
 382 @function Bitmap.open(name)
 383
 384 Loads a bitmap in memory, for later use with lcd.drawBitmap(). Bitmaps should be loaded only
 385 once, returned object should be stored and used for drawing. If loading fails for whatever
 386 reason the resulting bitmap object will have width and height set to zero.
 387
 388 Bitmap loading can fail if:
 389  * File is not found or contains invalid image
 390  * System is low on memory
 391  * Combined memory usage of all Lua script bitmaps exceeds certain value
 392
 393 @param name (string) full path to the bitmap on SD card (i.e. “/IMAGES/test.bmp”)
 394
 395 @retval bitmap (object) a bitmap object that can be used with other bitmap functions
 396
 397 @notice Only available on Horus
 398
 399 @status current Introduced in 2.2.0
 400 */
 401 static int luaOpenBitmap(lua_State * L)
 402 {
 403   const char * filename = luaL_checkstring(L, 1);
 404
 405   BitmapBuffer ** b = (BitmapBuffer **)lua_newuserdata(L, sizeof(BitmapBuffer *));
 406
 407   if (luaExtraMemoryUsage > LUA_MEM_EXTRA_MAX) {
 408     // already allocated more than max allowed, fail
 409     TRACE("luaOpenBitmap: Error, using too much memory %u/%u", luaExtraMemoryUsage, LUA_MEM_EXTRA_MAX);
 410     *b = 0;
 411   }
 412   else {
 413     *b = BitmapBuffer::load(filename);
 414     if (*b == NULL && G(L)->gcrunning) {
 415       luaC_fullgc(L, 1);  /* try to free some memory... */
 416       *b = BitmapBuffer::load(filename);  /* try again */
 417     }
 418   }
 419
 420   if (*b) {
 421     uint32_t size = (*b)->getDataSize();
 422     luaExtraMemoryUsage += size;
 423     TRACE("luaOpenBitmap: %p (%u)", *b, size);
 424   }
 425
 426   luaL_getmetatable(L, LUA_BITMAPHANDLE);
 427   lua_setmetatable(L, -2);
 428
 429   return 1;
 430 }
 431
 432 static BitmapBuffer * checkBitmap(lua_State * L, int index)
 433 {
 434   BitmapBuffer ** b = (BitmapBuffer **)luaL_checkudata(L, index, LUA_BITMAPHANDLE);
 435   return *b;
 436 }
 437
 438 /*luadoc
 439 @function Bitmap.getSize(name)
 440
 441 Return width, height of a bitmap object
 442
 443 @param bitmap (pointer) point to a bitmap previously opened with Bitmap.open()
 444
 445 @retval multiple returns 2 values:
 446  * (number) width in pixels
 447  * (number) height in pixels
 448
 449 @notice Only available on Horus
 450
 451 @status current Introduced in 2.2.0
 452 */
 453 static int luaGetBitmapSize(lua_State * L)
 454 {
 455   const BitmapBuffer * b = checkBitmap(L, 1);
 456   if (b) {
 457     lua_pushinteger(L, b->getWidth());
 458     lua_pushinteger(L, b->getHeight());
 459   }
 460   else {
 461     lua_pushinteger(L, 0);
 462     lua_pushinteger(L, 0);
 463   }
 464   return 2;
 465 }
 466
 467 static int luaDestroyBitmap(lua_State * L)
 468 {
 469   BitmapBuffer * b = checkBitmap(L, 1);
 470   if (b) {
 471     uint32_t size = b->getDataSize();
 472     TRACE("luaDestroyBitmap: %p (%u)", b, size);
 473     if (luaExtraMemoryUsage >= size) {
 474       luaExtraMemoryUsage -= size;
 475     }
 476     else {
 477       luaExtraMemoryUsage = 0;
 478     }
 479     delete b;
 480   }
 481   return 0;
 482 }
 483
 484 const luaL_Reg bitmapFuncs[] = {
 485   { "open", luaOpenBitmap },
 486   { "getSize", luaGetBitmapSize },
 487   { "__gc", luaDestroyBitmap },
 488   { NULL, NULL }
 489 };
 490
 491 void registerBitmapClass(lua_State * L)
 492 {
 493   luaL_newmetatable(L, LUA_BITMAPHANDLE);
 494   luaL_setfuncs(L, bitmapFuncs, 0);
 495   lua_pushvalue(L, -1);
 496   lua_setfield(L, -2, "__index");
 497   lua_setglobal(L, "Bitmap");
 498 }
 499
 500 /*luadoc
 501 @function lcd.drawBitmap(bitmap, x, y [, scale])
 502
 503 Displays a bitmap at (x,y)
 504
 505 @param bitmap (pointer) point to a bitmap previously opened with Bitmap.open()
 506
 507 @param x,y (positive numbers) starting coordinates
 508
 509 @param scale (positive numbers) scale in %, 50 divides size by two, 100 is unchanged, 200 doubles size.
 510 Omitting scale draws image in 1:1 scale and is faster than specifying 100 for scale.
 511
 512 @notice Only available on Horus
 513
 514 @status current Introduced in 2.2.0
 515 */
 516 static int luaLcdDrawBitmap(lua_State *L)
 517 {
 518   if (!luaLcdAllowed) return 0;
 519   const BitmapBuffer * b = checkBitmap(L, 1);
 520
 521   if (b) {
 522     unsigned int x = luaL_checkunsigned(L, 2);
 523     unsigned int y = luaL_checkunsigned(L, 3);
 524     unsigned int scale = luaL_optunsigned(L, 4, 0);
 525     if (scale) {
 526       lcd->drawBitmap(x, y, b, 0, 0, 0, 0, scale/100.0f);
 527     }
 528     else {
 529       lcd->drawBitmap(x, y, b);
 530     }
 531   }
 532   return 0;
 533 }
 534 #else
 535 /*luadoc
 536 @function lcd.drawPixmap(x, y, name)
 537
 538 Draw a bitmap at (x,y)
 539
 540 @param x,y (positive numbers) starting coordinates
 541
 542 @param name (string) full path to the bitmap on SD card (i.e. “/IMAGES/test.bmp”)
 543
 544 @notice Only available on Taranis X9 series. Maximum image size if 106 x 64 pixels (width x height).
 545
 546 @status current Introduced in 2.0.0
 547 */
 548 static int luaLcdDrawPixmap(lua_State *L)
 549 {
 550   if (!luaLcdAllowed) return 0;
 551   int x = luaL_checkinteger(L, 1);
 552   int y = luaL_checkinteger(L, 2);
 553   const char * filename = luaL_checkstring(L, 3);
 554
 555   uint8_t bitmap[BITMAP_BUFFER_SIZE(LCD_W/2, LCD_H)]; // width max is LCD_W/2 pixels for saving stack and avoid a malloc here
 556   if (lcdLoadBitmap(bitmap, filename, LCD_W/2, LCD_H)) {
 557     lcdDrawBitmap(x, y, bitmap);
 558   }
 559
 560   return 0;
 561 }
 562 #endif
 563
 564 /*luadoc
 565 @function lcd.drawRectangle(x, y, w, h [, flags [, t]])
 566
 567 Draw a rectangle from top left corner (x,y) of specified width and height
 568
 569 @param x,y (positive numbers) top left corner position
 570
 571 @param w (number) width in pixels
 572
 573 @param h (number) height in pixels
 574
 575 @param flags (unsigned number) drawing flags
 576
 577 @param t (number) thickness in pixels, defaults to 1 (only on Horus)
 578
 579 @status current Introduced in 2.0.0, changed in 2.2.0
 580 */
 581 static int luaLcdDrawRectangle(lua_State *L)
 582 {
 583   if (!luaLcdAllowed) return 0;
 584   int x = luaL_checkinteger(L, 1);
 585   int y = luaL_checkinteger(L, 2);
 586   int w = luaL_checkinteger(L, 3);
 587   int h = luaL_checkinteger(L, 4);
 588   unsigned int flags = luaL_optunsigned(L, 5, 0);
 589 #if defined(PCBHORUS)
 590   unsigned int t = luaL_optunsigned(L, 6, 1);
 591   lcdDrawRect(x, y, w, h, t, 0xff, flags);
 592 #else
 593   lcdDrawRect(x, y, w, h, 0xff, flags);
 594 #endif
 595   return 0;
 596 }
 597
 598 /*luadoc
 599 @function lcd.drawFilledRectangle(x, y, w, h [, flags])
 600
 601 Draw a solid rectangle from top left corner (x,y) of specified width and height
 602
 603 @param x,y (positive numbers) top left corner position
 604
 605 @param w (number) width in pixels
 606
 607 @param h (number) height in pixels
 608
 609 @param flags (unsigned number) drawing flags
 610
 611 @status current Introduced in 2.0.0
 612 */
 613 static int luaLcdDrawFilledRectangle(lua_State *L)
 614 {
 615   if (!luaLcdAllowed) return 0;
 616   int x = luaL_checkinteger(L, 1);
 617   int y = luaL_checkinteger(L, 2);
 618   int w = luaL_checkinteger(L, 3);
 619   int h = luaL_checkinteger(L, 4);
 620   unsigned int flags = luaL_optunsigned(L, 5, 0);
 621   lcdDrawFilledRect(x, y, w, h, SOLID, flags);
 622   return 0;
 623 }
 624
 625
 626 /*luadoc
 627 @function lcd.drawGauge(x, y, w, h, fill, maxfill [, flags])
 628
 629 Draw a simple gauge that is filled based upon fill value
 630
 631 @param x,y (positive numbers) top left corner position
 632
 633 @param w (number) width in pixels
 634
 635 @param h (number) height in pixels
 636
 637 @param fill (number) amount of fill to apply
 638
 639 @param maxfill (number) total value of fill
 640
 641 @param flags (unsigned number) drawing flags
 642
 643 @status current Introduced in 2.0.0, changed in 2.2.0
 644 */
 645 static int luaLcdDrawGauge(lua_State *L)
 646 {
 647   if (!luaLcdAllowed) return 0;
 648   int x = luaL_checkinteger(L, 1);
 649   int y = luaL_checkinteger(L, 2);
 650   int w = luaL_checkinteger(L, 3);
 651   int h = luaL_checkinteger(L, 4);
 652   int num = luaL_checkinteger(L, 5);
 653   int den = luaL_checkinteger(L, 6);
 654   unsigned int flags = luaL_optunsigned(L, 7, 0);
 655 #if defined(PCBHORUS)
 656   lcdDrawRect(x, y, w, h, 1, 0xff, flags);
 657 #else
 658   lcdDrawRect(x, y, w, h, 0xff, flags);
 659 #endif
 660   uint8_t len = limit((uint8_t)1, uint8_t(w*num/den), uint8_t(w));
 661   lcdDrawSolidFilledRect(x+1, y+1, len, h-2, flags);
 662   return 0;
 663 }
 664
 665
 666 #if !defined(COLORLCD)
 667 /*luadoc
 668 @function lcd.drawScreenTitle(title, page, pages)
 669
 670 Draw a title bar
 671
 672 @param title (string) text for the title
 673
 674 @param page (number) page number
 675
 676 @param pages (number) total number of pages. Only used as indicator on
 677 the right side of title bar. (i.e. idx=2, cnt=5, display `2/5`)
 678
 679 @notice Only available on Taranis
 680
 681 @status current Introduced in 2.0.0
 682 */
 683 static int luaLcdDrawScreenTitle(lua_State *L)
 684 {
 685   if (!luaLcdAllowed) return 0;
 686   const char * str = luaL_checkstring(L, 1);
 687   int idx = luaL_checkinteger(L, 2);
 688   int cnt = luaL_checkinteger(L, 3);
 689
 690   if (cnt) drawScreenIndex(idx-1, cnt, 0);
 691 #if LCD_DEPTH > 1
 692   lcdDrawFilledRect(0, 0, LCD_W, FH, SOLID, FILL_WHITE|GREY_DEFAULT);
 693 #endif
 694   title(str);
 695
 696   return 0;
 697 }
 698 #endif
 699
 700 #if !defined(COLORLCD)
 701 /*luadoc
 702 @function lcd.drawCombobox(x, y, w, list, idx [, flags])
 703
 704 Draw a combo box
 705
 706 @param x,y (positive numbers) top left corner position
 707
 708 @param w (number) width of combo box in pixels
 709
 710 @param list (table) combo box elements, each element is a string
 711
 712 @param idx (integer) index of entry to highlight
 713
 714 @param flags (unsigned number) drawing flags, the flags can not be combined:
 715  * `BLINK` combo box is expanded
 716  * `INVERS` combo box collapsed, text inversed
 717  * `0 or not present` combo box collapsed, text normal
 718
 719 @notice Only available on Taranis
 720
 721 @status current Introduced in 2.0.0
 722 */
 723 static int luaLcdDrawCombobox(lua_State *L)
 724 {
 725   if (!luaLcdAllowed) return 0;
 726   int x = luaL_checkinteger(L, 1);
 727   int y = luaL_checkinteger(L, 2);
 728   int w = luaL_checkinteger(L, 3);
 729   luaL_checktype(L, 4, LUA_TTABLE);
 730   int count = luaL_len(L, 4);  /* get size of table */
 731   int idx = luaL_checkinteger(L, 5);
 732   unsigned int flags = luaL_optunsigned(L, 6, 0);
 733   if (idx >= count) {
 734     // TODO error
 735   }
 736   if (flags & BLINK) {
 737     lcdDrawFilledRect(x, y, w-9, count*9+2, SOLID, ERASE);
 738     lcdDrawRect(x, y, w-9, count*9+2);
 739     for (int i=0; i<count; i++) {
 740       lua_rawgeti(L, 4, i+1);
 741       const char * item = luaL_checkstring(L, -1);
 742       lcdDrawText(x+2, y+2+9*i, item, 0);
 743     }
 744     lcdDrawFilledRect(x+1, y+1+9*idx, w-11, 9);
 745     lcdDrawFilledRect(x+w-10, y, 10, 11, SOLID, ERASE);
 746     lcdDrawRect(x+w-10, y, 10, 11);
 747   }
 748   else if (flags & INVERS) {
 749     lcdDrawFilledRect(x, y, w, 11);
 750     lcdDrawFilledRect(x+w-9, y+1, 8, 9, SOLID, ERASE);
 751     lua_rawgeti(L, 4, idx+1);
 752     const char * item = luaL_checkstring(L, -1);
 753     lcdDrawText(x+2, y+2, item, INVERS);
 754   }
 755   else {
 756     lcdDrawFilledRect(x, y, w, 11, SOLID, ERASE);
 757     lcdDrawRect(x, y, w, 11);
 758     lcdDrawFilledRect(x+w-10, y+1, 9, 9, SOLID);
 759     lua_rawgeti(L, 4, idx+1);
 760     const char * item = luaL_checkstring(L, -1);
 761     lcdDrawText(x+2, y+2, item, 0);
 762   }
 763
 764   lcdDrawSolidHorizontalLine(x+w-8, y+3, 6);
 765   lcdDrawSolidHorizontalLine(x+w-8, y+5, 6);
 766   lcdDrawSolidHorizontalLine(x+w-8, y+7, 6);
 767
 768   return 0;
 769 }
 770 #endif
 771
 772 #if defined(COLORLCD)
 773 /*luadoc
 774 @function lcd.setColor(area, color)
 775
 776 Set a color for specific area
 777
 778 @param area (unsigned number) specific screen area in the list bellow
 779  * `CUSTOM_COLOR`
 780  * `TEXT_COLOR`
 781  * `TEXT_BGCOLOR`
 782  * `TEXT_INVERTED_COLOR`
 783  * `TEXT_INVERTED_BGCOLOR`
 784  * `LINE_COLOR`
 785  * `SCROLLBOX_COLOR`
 786  * `MENU_TITLE_BGCOLOR`
 787  * `MENU_TITLE_COLOR`
 788  * `MENU_TITLE_DISABLE_COLOR`
 789  * `HEADER_COLOR`
 790  * `ALARM_COLOR`
 791  * `WARNING_COLOR`
 792  * `TEXT_DISABLE_COLOR`
 793  * `HEADER_COLOR`
 794  * `CURVE_AXIS_COLOR`
 795  * `CURVE_CURSOR_COLOR`
 796  * `TITLE_BGCOLOR`
 797  * `TRIM_BGCOLOR`
 798  * `TRIM_SHADOW_COLOR`
 799  * `MAINVIEW_PANES_COLOR`
 800  * `MAINVIEW_GRAPHICS_COLOR`
 801  * `HEADER_BGCOLOR`
 802  * `HEADER_ICON_BGCOLOR`
 803  * `HEADER_CURRENT_BGCOLOR`
 804  * `OVERLAY_COLOR`
 805
 806 @param color (number) color in 5/6/5 rgb format. The following prefined colors are available
 807  * `WHITE`
 808  * `GREY`
 809  * `LIGHTGREY`
 810  * `DARKGREY`
 811  * `BLACK`
 812  * `YELLOW`
 813  * `BLUE`
 814  * `RED`
 815  * `DARKRED`
 816
 817 @notice Only available on Horus
 818
 819 @status current Introduced in 2.2.0
 820 */
 821 static int luaLcdSetColor(lua_State *L)
 822 {
 823   if (!luaLcdAllowed) return 0;
 824   unsigned int index = luaL_checkunsigned(L, 1) >> 16;
 825   unsigned int color = luaL_checkunsigned(L, 2);
 826   lcdColorTable[index] = color;
 827   return 0;
 828 }
 829
 830 /*luadoc
 831 @function lcd.RGB(r, g, b)
 832
 833 Returns a 5/6/5 rgb color code, that can be used with lcd.setColor
 834
 835 @param r (integer) a number between 0x00 and 0xff that expresses te amount of red in the color
 836
 837 @param g (integer) a number between 0x00 and 0xff that expresses te amount of green in the color
 838
 839 @param b (integer) a number between 0x00 and 0xff that expresses te amount of blue in the color
 840
 841 @retval number (integer) rgb color expressed in 5/6/5 format
 842
 843 @notice Only available on Horus
 844
 845 @status current Introduced in 2.2.0
 846 */
 847 static int luaRGB(lua_State *L)
 848 {
 849   if (!luaLcdAllowed) return 0;
 850   int r = luaL_checkinteger(L, 1);
 851   int g = luaL_checkinteger(L, 2);
 852   int b = luaL_checkinteger(L, 3);
 853   lua_pushinteger(L, RGB(r, g, b));
 854   return 1;
 855 }
 856 #endif
 857
 858 const luaL_Reg lcdLib[] = {
 859   { "refresh", luaLcdRefresh },
 860   { "clear", luaLcdClear },
 861   { "drawPoint", luaLcdDrawPoint },
 862   { "drawLine", luaLcdDrawLine },
 863   { "drawRectangle", luaLcdDrawRectangle },
 864   { "drawFilledRectangle", luaLcdDrawFilledRectangle },
 865   { "drawText", luaLcdDrawText },
 866   { "drawTimer", luaLcdDrawTimer },
 867   { "drawNumber", luaLcdDrawNumber },
 868   { "drawChannel", luaLcdDrawChannel },
 869   { "drawSwitch", luaLcdDrawSwitch },
 870   { "drawSource", luaLcdDrawSource },
 871   { "drawGauge", luaLcdDrawGauge },
 872 #if defined(COLORLCD)
 873   { "drawBitmap", luaLcdDrawBitmap },
 874   { "setColor", luaLcdSetColor },
 875   { "RGB", luaRGB },
 876 #else
 877   { "getLastPos", luaLcdGetLastPos },
 878   { "getLastRightPos", luaLcdGetLastPos },
 879   { "getLastLeftPos", luaLcdGetLeftPos },
 880   { "drawPixmap", luaLcdDrawPixmap },
 881   { "drawScreenTitle", luaLcdDrawScreenTitle },
 882   { "drawCombobox", luaLcdDrawCombobox },
 883 #endif
 884   { NULL, NULL }  /* sentinel */
 885 };