774 lines
16 KiB
C
774 lines
16 KiB
C
// Module for Ucglib
|
|
|
|
// Do not use the code from ucg submodule and skip the complete source here
|
|
// if the ucg module is not selected.
|
|
// Reason: The whole ucg submodule code tree might not even exist in this case.
|
|
#include "user_modules.h"
|
|
#ifdef LUA_USE_MODULES_UCG
|
|
|
|
#include "module.h"
|
|
#include "lauxlib.h"
|
|
|
|
|
|
#define USE_PIN_LIST
|
|
#include "ucg.h"
|
|
#include "ucg_nodemcu_hal.h"
|
|
|
|
|
|
#include "ucg_config.h"
|
|
|
|
|
|
#ifdef ESP_PLATFORM
|
|
// ESP32
|
|
#include "spi_common.h"
|
|
|
|
#include "sdkconfig.h"
|
|
#endif
|
|
|
|
#ifndef CONFIG_LUA_MODULE_U8G2
|
|
// ignore unused functions if u8g2 module will be skipped anyhow
|
|
#pragma GCC diagnostic ignored "-Wunused-function"
|
|
#endif
|
|
|
|
|
|
|
|
typedef struct
|
|
{
|
|
ucg_nodemcu_t ucg;
|
|
|
|
ucg_dev_fnptr dev_cb;
|
|
ucg_dev_fnptr ext_cb;
|
|
|
|
// For Print() function
|
|
ucg_int_t tx, ty;
|
|
uint8_t tdir;
|
|
|
|
int font_ref;
|
|
int host_ref;
|
|
} ucg_ud_t;
|
|
|
|
|
|
|
|
|
|
// shorthand macro for the ucg structure inside the userdata
|
|
#define GET_UCG() \
|
|
ucg_ud_t *ud = (ucg_ud_t *)luaL_checkudata( L, 1, "ucg.display" ); \
|
|
ucg_t *ucg = (ucg_t *)(&(ud->ucg));
|
|
|
|
|
|
// helper function: retrieve given number of integer arguments
|
|
static void lucg_get_int_args( lua_State *L, uint8_t stack, uint8_t num, ucg_int_t *args)
|
|
{
|
|
while (num-- > 0) {
|
|
*args++ = luaL_checkinteger( L, stack++ );
|
|
}
|
|
}
|
|
|
|
// Lua: ucg.begin( self, fontmode )
|
|
static int lucg_begin( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
ucg_Init( ucg, ud->dev_cb, ud->ext_cb, ucg_com_nodemcu_hw_spi );
|
|
|
|
ucg_int_t fontmode = luaL_checkinteger( L, 2 );
|
|
|
|
ucg_SetFontMode( ucg, fontmode );
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Lua: ucg.clearScreen( self )
|
|
static int lucg_clearScreen( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
ucg_ClearScreen( ucg );
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Lua: ucg.draw90Line( self, x, y, len, dir, col_idx )
|
|
static int lucg_draw90Line( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
ucg_int_t args[5];
|
|
lucg_get_int_args( L, 2, 5, args );
|
|
|
|
ucg_Draw90Line( ucg, args[0], args[1], args[2], args[3], args[4] );
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Lua: ucg.drawBox( self, x, y, w, h )
|
|
static int lucg_drawBox( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
ucg_int_t args[4];
|
|
lucg_get_int_args( L, 2, 4, args );
|
|
|
|
ucg_DrawBox( ucg, args[0], args[1], args[2], args[3] );
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Lua: ucg.drawCircle( self, x0, y0, rad, option )
|
|
static int lucg_drawCircle( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
ucg_int_t args[4];
|
|
lucg_get_int_args( L, 2, 4, args );
|
|
|
|
ucg_DrawCircle( ucg, args[0], args[1], args[2], args[3] );
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Lua: ucg.drawDisc( self, x0, y0, rad, option )
|
|
static int lucg_drawDisc( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
ucg_int_t args[4];
|
|
lucg_get_int_args( L, 2, 4, args );
|
|
|
|
ucg_DrawDisc( ucg, args[0], args[1], args[2], args[3] );
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Lua: ucg.drawFrame( self, x, y, w, h )
|
|
static int lucg_drawFrame( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
ucg_int_t args[4];
|
|
lucg_get_int_args( L, 2, 4, args );
|
|
|
|
ucg_DrawFrame( ucg, args[0], args[1], args[2], args[3] );
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Lua: ucg.drawGradientBox( self, x, y, w, h )
|
|
static int lucg_drawGradientBox( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
ucg_int_t args[4];
|
|
lucg_get_int_args( L, 2, 4, args );
|
|
|
|
ucg_DrawGradientBox( ucg, args[0], args[1], args[2], args[3] );
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Lua: width = ucg.drawGlyph( self, x, y, dir, encoding )
|
|
static int lucg_drawGlyph( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
ucg_int_t args[3];
|
|
lucg_get_int_args( L, 2, 3, args );
|
|
|
|
const char *c = luaL_checkstring( L, (1+3) + 1 );
|
|
if (c == NULL)
|
|
return 0;
|
|
|
|
lua_pushinteger( L, ucg_DrawGlyph( ucg, args[0], args[1], args[2], *c ) );
|
|
|
|
return 1;
|
|
}
|
|
|
|
// Lua: ucg.drawGradientLine( self, x, y, len, dir )
|
|
static int lucg_drawGradientLine( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
ucg_int_t args[4];
|
|
lucg_get_int_args( L, 2, 4, args );
|
|
|
|
ucg_DrawGradientLine( ucg, args[0], args[1], args[2], args[3] );
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Lua: ucg.drawHLine( self, x, y, len )
|
|
static int lucg_drawHLine( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
ucg_int_t args[3];
|
|
lucg_get_int_args( L, 2, 3, args );
|
|
|
|
ucg_DrawHLine( ucg, args[0], args[1], args[2] );
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Lua: ucg.drawLine( self, x1, y1, x2, y2 )
|
|
static int lucg_drawLine( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
ucg_int_t args[4];
|
|
lucg_get_int_args( L, 2, 4, args );
|
|
|
|
ucg_DrawLine( ucg, args[0], args[1], args[2], args[3] );
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Lua: ucg.drawPixel( self, x, y )
|
|
static int lucg_drawPixel( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
ucg_int_t args[2];
|
|
lucg_get_int_args( L, 2, 2, args );
|
|
|
|
ucg_DrawPixel( ucg, args[0], args[1] );
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Lua: ucg.drawRBox( self, x, y, w, h, r )
|
|
static int lucg_drawRBox( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
ucg_int_t args[5];
|
|
lucg_get_int_args( L, 2, 5, args );
|
|
|
|
ucg_DrawRBox( ucg, args[0], args[1], args[2], args[3], args[4] );
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Lua: ucg.drawRFrame( self, x, y, w, h, r )
|
|
static int lucg_drawRFrame( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
ucg_int_t args[5];
|
|
lucg_get_int_args( L, 2, 5, args );
|
|
|
|
ucg_DrawRFrame( ucg, args[0], args[1], args[2], args[3], args[4] );
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Lua: width = ucg.drawString( self, x, y, dir, str )
|
|
static int lucg_drawString( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
ucg_int_t args[3];
|
|
lucg_get_int_args( L, 2, 3, args );
|
|
|
|
const char *s = luaL_checkstring( L, (1+3) + 1 );
|
|
if (s == NULL)
|
|
return 0;
|
|
|
|
lua_pushinteger( L, ucg_DrawString( ucg, args[0], args[1], args[2], s ) );
|
|
|
|
return 1;
|
|
}
|
|
|
|
// Lua: ucg.drawTetragon( self, x0, y0, x1, y1, x2, y2, x3, y3 )
|
|
static int lucg_drawTetragon( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
ucg_int_t args[8];
|
|
lucg_get_int_args( L, 2, 8, args );
|
|
|
|
ucg_DrawTetragon( ucg, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7] );
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Lua: ucg.drawTriangle( self, x0, y0, x1, y1, x2, y2 )
|
|
static int lucg_drawTriangle( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
ucg_int_t args[6];
|
|
lucg_get_int_args( L, 2, 6, args );
|
|
|
|
ucg_DrawTriangle( ucg, args[0], args[1], args[2], args[3], args[4], args[5] );
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Lua: ucg.drawVLine( self, x, y, len )
|
|
static int lucg_drawVLine( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
ucg_int_t args[3];
|
|
lucg_get_int_args( L, 2, 3, args );
|
|
|
|
ucg_DrawVLine( ucg, args[0], args[1], args[2] );
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Lua: height = ucg.getFontAscent( self )
|
|
static int lucg_getFontAscent( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
lua_pushinteger( L, ucg_GetFontAscent( ucg ) );
|
|
|
|
return 1;
|
|
}
|
|
|
|
// Lua: height = ucg.getFontDescent( self )
|
|
static int lucg_getFontDescent( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
lua_pushinteger( L, ucg_GetFontDescent( ucg ) );
|
|
|
|
return 1;
|
|
}
|
|
|
|
// Lua: height = ucg.getHeight( self )
|
|
static int lucg_getHeight( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
lua_pushinteger( L, ucg_GetHeight( ucg ) );
|
|
|
|
return 1;
|
|
}
|
|
|
|
// Lua: width = ucg.getStrWidth( self, string )
|
|
static int lucg_getStrWidth( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
const char *s = luaL_checkstring( L, 2 );
|
|
if (s == NULL)
|
|
return 0;
|
|
|
|
lua_pushinteger( L, ucg_GetStrWidth( ucg, s ) );
|
|
|
|
return 1;
|
|
}
|
|
|
|
// Lua: width = ucg.getWidth( self )
|
|
static int lucg_getWidth( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
lua_pushinteger( L, ucg_GetWidth( ucg ) );
|
|
|
|
return 1;
|
|
}
|
|
|
|
// Lua: ucg.setClipRange( self, x, y, w, h )
|
|
static int lucg_setClipRange( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
ucg_int_t args[4];
|
|
lucg_get_int_args( L, 2, 4, args );
|
|
|
|
ucg_SetClipRange( ucg, args[0], args[1], args[2], args[3] );
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Lua: ucg.setColor( self, [idx], r, g, b )
|
|
static int lucg_setColor( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
ucg_int_t args[3];
|
|
lucg_get_int_args( L, 2, 3, args );
|
|
|
|
ucg_int_t opt = luaL_optint( L, (1+3) + 1, -1 );
|
|
|
|
if (opt < 0) {
|
|
ucg_SetColor( ucg, 0, args[0], args[1], args[2] );
|
|
} else {
|
|
ucg_SetColor( ucg, args[0], args[1], args[2], opt );
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Lua: ucg.setFont( self, font )
|
|
static int lucg_setFont( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
ucg_fntpgm_uint8_t *font = (ucg_fntpgm_uint8_t *)lua_touserdata( L, 2 );
|
|
if (font != NULL)
|
|
ucg_SetFont( ucg, font );
|
|
else
|
|
luaL_argerror(L, 2, "font data expected");
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Lua: ucg.print( self, str )
|
|
static int lucg_print( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
const char *s = luaL_checkstring( L, 2 );
|
|
if (s == NULL)
|
|
return 0;
|
|
|
|
while (*s)
|
|
{
|
|
ucg_int_t delta;
|
|
delta = ucg_DrawGlyph(ucg, ud->tx, ud->ty, ud->tdir, *(s++));
|
|
switch(ud->tdir) {
|
|
case 0: ud->tx += delta; break;
|
|
case 1: ud->ty += delta; break;
|
|
case 2: ud->tx -= delta; break;
|
|
default: case 3: ud->ty -= delta; break;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Lua: ucg.setFontMode( self, fontmode )
|
|
static int lucg_setFontMode( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
ucg_int_t fontmode = luaL_checkinteger( L, 2 );
|
|
|
|
ucg_SetFontMode( ucg, fontmode );
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Lua: ucg.setFontPosBaseline( self )
|
|
static int lucg_setFontPosBaseline( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
ucg_SetFontPosBaseline( ucg );
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Lua: ucg.setFontPosBottom( self )
|
|
static int lucg_setFontPosBottom( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
ucg_SetFontPosBottom( ucg );
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Lua: ucg.setFontPosCenter( self )
|
|
static int lucg_setFontPosCenter( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
ucg_SetFontPosCenter( ucg );
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Lua: ucg.setFontPosTop( self )
|
|
static int lucg_setFontPosTop( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
ucg_SetFontPosTop( ucg );
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Lua: ucg.setMaxClipRange( self )
|
|
static int lucg_setMaxClipRange( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
ucg_SetMaxClipRange( ucg );
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Lua: ucg.setPrintPos( self, x, y )
|
|
static int lucg_setPrintPos( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
(void)ucg;
|
|
|
|
ucg_int_t args[2];
|
|
lucg_get_int_args( L, 2, 2, args );
|
|
|
|
ud->tx = args[0];
|
|
ud->ty = args[1];
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Lua: ucg.setPrintDir( self, dir )
|
|
static int lucg_setPrintDir( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
(void)ucg;
|
|
|
|
ud->tdir = luaL_checkinteger( L, 2 );
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Lua: ucg.setRotate90( self )
|
|
static int lucg_setRotate90( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
ucg_SetRotate90( ucg );
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Lua: ucg.setRotate180( self )
|
|
static int lucg_setRotate180( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
ucg_SetRotate180( ucg );
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Lua: ucg.setRotate270( self )
|
|
static int lucg_setRotate270( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
ucg_SetRotate270( ucg );
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Lua: ucg.setScale2x2( self )
|
|
static int lucg_setScale2x2( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
ucg_SetScale2x2( ucg );
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Lua: ucg.undoRotate( self )
|
|
static int lucg_undoRotate( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
ucg_UndoRotate( ucg );
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Lua: ucg.undoScale( self )
|
|
static int lucg_undoScale( lua_State *L )
|
|
{
|
|
GET_UCG();
|
|
|
|
ucg_UndoScale( ucg );
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
// device destructor
|
|
static int lucg_close_display( lua_State *L )
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
// Device constructors
|
|
//
|
|
//
|
|
static int ldisplay_hw_spi( lua_State *L, ucg_dev_fnptr device, ucg_dev_fnptr extension )
|
|
{
|
|
int stack = 0;
|
|
|
|
#ifndef ESP_PLATFORM
|
|
// ESP8266
|
|
typedef struct {
|
|
int host;
|
|
} lspi_host_t;
|
|
lspi_host_t host_elem;
|
|
lspi_host_t *host = &host_elem;
|
|
#else
|
|
// ESP32
|
|
lspi_host_t *host = NULL;
|
|
#endif
|
|
int host_ref = LUA_NOREF;
|
|
int cs = -1;
|
|
int dc = -1;
|
|
int res = -1;
|
|
int get_spi_pins;
|
|
|
|
if (lua_type( L, ++stack ) == LUA_TUSERDATA) {
|
|
host = (lspi_host_t *)luaL_checkudata( L, stack, "spi.master" );
|
|
/* reference host object to avoid automatic gc */
|
|
lua_pushvalue( L, stack );
|
|
host_ref = luaL_ref( L, LUA_REGISTRYINDEX );
|
|
get_spi_pins = 1;
|
|
} else if (lua_type( L, stack ) == LUA_TNUMBER) {
|
|
host->host = luaL_checkint( L, stack );
|
|
get_spi_pins = 1;
|
|
} else {
|
|
get_spi_pins = 0;
|
|
stack--;
|
|
}
|
|
|
|
if (get_spi_pins) {
|
|
cs = luaL_checkint( L, ++stack );
|
|
dc = luaL_checkint( L, ++stack );
|
|
res = luaL_optint( L, ++stack, -1 );
|
|
}
|
|
|
|
ucg_ud_t *ud = (ucg_ud_t *) lua_newuserdata( L, sizeof( ucg_ud_t ) );
|
|
ucg_nodemcu_t *ext_ucg = &(ud->ucg);
|
|
ud->font_ref = LUA_NOREF;
|
|
ud->host_ref = host_ref;
|
|
ext_ucg->hal = host ? (void *)(host->host) : NULL;
|
|
|
|
ucg_t *ucg = (ucg_t *)ext_ucg;
|
|
|
|
/* do a dummy init so that something usefull is part of the ucg structure */
|
|
ucg_Init( ucg, ucg_dev_default_cb, ucg_ext_none, (ucg_com_fnptr)0 );
|
|
|
|
/* reset cursor position */
|
|
ud->tx = 0;
|
|
ud->ty = 0;
|
|
ud->tdir = 0; /* default direction */
|
|
|
|
uint8_t i;
|
|
for( i = 0; i < UCG_PIN_COUNT; i++ )
|
|
ucg->pin_list[i] = UCG_PIN_VAL_NONE;
|
|
|
|
ud->dev_cb = device;
|
|
ud->ext_cb = extension;
|
|
if (res >= 0)
|
|
ucg->pin_list[UCG_PIN_RST] = res;
|
|
ucg->pin_list[UCG_PIN_CD] = dc;
|
|
ucg->pin_list[UCG_PIN_CS] = cs;
|
|
|
|
/* set its metatable */
|
|
luaL_getmetatable(L, "ucg.display");
|
|
lua_setmetatable(L, -2);
|
|
|
|
return 1;
|
|
}
|
|
#undef UCG_DISPLAY_TABLE_ENTRY
|
|
#define UCG_DISPLAY_TABLE_ENTRY(binding, device, extension) \
|
|
static int l ## binding( lua_State *L ) \
|
|
{ \
|
|
return ldisplay_hw_spi( L, device, extension ); \
|
|
}
|
|
//
|
|
// Unroll the display table and insert binding functions.
|
|
UCG_DISPLAY_TABLE
|
|
//
|
|
// ***************************************************************************
|
|
|
|
|
|
|
|
// Module function map
|
|
LROT_BEGIN(lucg_display, NULL, LROT_MASK_GC_INDEX)
|
|
LROT_FUNCENTRY( __gc, lucg_close_display )
|
|
LROT_TABENTRY( __index, lucg_display )
|
|
LROT_FUNCENTRY( begin, lucg_begin )
|
|
LROT_FUNCENTRY( clearScreen, lucg_clearScreen )
|
|
LROT_FUNCENTRY( draw90Line, lucg_draw90Line )
|
|
LROT_FUNCENTRY( drawBox, lucg_drawBox )
|
|
LROT_FUNCENTRY( drawCircle, lucg_drawCircle )
|
|
LROT_FUNCENTRY( drawDisc, lucg_drawDisc )
|
|
LROT_FUNCENTRY( drawFrame, lucg_drawFrame )
|
|
LROT_FUNCENTRY( drawGlyph, lucg_drawGlyph )
|
|
LROT_FUNCENTRY( drawGradientBox, lucg_drawGradientBox )
|
|
LROT_FUNCENTRY( drawGradientLine, lucg_drawGradientLine )
|
|
LROT_FUNCENTRY( drawHLine, lucg_drawHLine )
|
|
LROT_FUNCENTRY( drawLine, lucg_drawLine )
|
|
LROT_FUNCENTRY( drawPixel, lucg_drawPixel )
|
|
LROT_FUNCENTRY( drawRBox, lucg_drawRBox )
|
|
LROT_FUNCENTRY( drawRFrame, lucg_drawRFrame )
|
|
LROT_FUNCENTRY( drawString, lucg_drawString )
|
|
LROT_FUNCENTRY( drawTetragon, lucg_drawTetragon )
|
|
LROT_FUNCENTRY( drawTriangle, lucg_drawTriangle )
|
|
LROT_FUNCENTRY( drawVLine, lucg_drawVLine )
|
|
LROT_FUNCENTRY( getFontAscent, lucg_getFontAscent )
|
|
LROT_FUNCENTRY( getFontDescent, lucg_getFontDescent )
|
|
LROT_FUNCENTRY( getHeight, lucg_getHeight )
|
|
LROT_FUNCENTRY( getStrWidth, lucg_getStrWidth )
|
|
LROT_FUNCENTRY( getWidth, lucg_getWidth )
|
|
LROT_FUNCENTRY( print, lucg_print )
|
|
LROT_FUNCENTRY( setClipRange, lucg_setClipRange )
|
|
LROT_FUNCENTRY( setColor, lucg_setColor )
|
|
LROT_FUNCENTRY( setFont, lucg_setFont )
|
|
LROT_FUNCENTRY( setFontMode, lucg_setFontMode )
|
|
LROT_FUNCENTRY( setFontPosBaseline, lucg_setFontPosBaseline )
|
|
LROT_FUNCENTRY( setFontPosBottom, lucg_setFontPosBottom )
|
|
LROT_FUNCENTRY( setFontPosCenter, lucg_setFontPosCenter )
|
|
LROT_FUNCENTRY( setFontPosTop, lucg_setFontPosTop )
|
|
LROT_FUNCENTRY( setMaxClipRange, lucg_setMaxClipRange )
|
|
LROT_FUNCENTRY( setPrintDir, lucg_setPrintDir )
|
|
LROT_FUNCENTRY( setPrintPos, lucg_setPrintPos )
|
|
LROT_FUNCENTRY( setRotate90, lucg_setRotate90 )
|
|
LROT_FUNCENTRY( setRotate180, lucg_setRotate180 )
|
|
LROT_FUNCENTRY( setRotate270, lucg_setRotate270 )
|
|
LROT_FUNCENTRY( setScale2x2, lucg_setScale2x2 )
|
|
LROT_FUNCENTRY( undoClipRange, lucg_setMaxClipRange )
|
|
LROT_FUNCENTRY( undoRotate, lucg_undoRotate )
|
|
LROT_FUNCENTRY( undoScale, lucg_undoScale )
|
|
LROT_END(lucg_display, NULL, LROT_MASK_GC_INDEX)
|
|
|
|
|
|
LROT_BEGIN(lucg, NULL , 0)
|
|
#undef UCG_DISPLAY_TABLE_ENTRY
|
|
#define UCG_DISPLAY_TABLE_ENTRY(binding, device, extension) LROT_FUNCENTRY(binding,l ## binding)
|
|
UCG_DISPLAY_TABLE
|
|
|
|
// Register fonts
|
|
#undef UCG_FONT_TABLE_ENTRY
|
|
#define UCG_FONT_TABLE_ENTRY(font) LROT_LUDENTRY(font, ucg_ ## font )
|
|
UCG_FONT_TABLE
|
|
|
|
// Font modes
|
|
LROT_NUMENTRY( FONT_MODE_TRANSPARENT, UCG_FONT_MODE_TRANSPARENT )
|
|
LROT_NUMENTRY( FONT_MODE_SOLID, UCG_FONT_MODE_SOLID )
|
|
|
|
// Options for circle/ disc drawing
|
|
LROT_NUMENTRY( DRAW_UPPER_RIGHT, UCG_DRAW_UPPER_RIGHT )
|
|
LROT_NUMENTRY( DRAW_UPPER_LEFT, UCG_DRAW_UPPER_LEFT )
|
|
LROT_NUMENTRY( DRAW_LOWER_RIGHT, UCG_DRAW_LOWER_RIGHT )
|
|
LROT_NUMENTRY( DRAW_LOWER_LEFT, UCG_DRAW_LOWER_LEFT )
|
|
LROT_NUMENTRY( DRAW_ALL, UCG_DRAW_ALL )
|
|
LROT_END(lucg, NULL, 0)
|
|
|
|
|
|
int luaopen_ucg( lua_State *L )
|
|
{
|
|
luaL_rometatable(L, "ucg.display", LROT_TABLEREF(lucg_display));
|
|
return 0;
|
|
}
|
|
|
|
NODEMCU_MODULE(UCG, "ucg", lucg, luaopen_ucg);
|
|
|
|
#endif /* LUA_USE_MODULES_UCG */
|