833 lines
20 KiB
C
Executable File
833 lines
20 KiB
C
Executable File
/** \file
|
|
* \brief matrix binding for Lua 5.
|
|
*
|
|
* See Copyright Notice in "iup.h"
|
|
*/
|
|
|
|
#include <memory.h>
|
|
|
|
#include <lua.h>
|
|
#include <lualib.h>
|
|
#include <lauxlib.h>
|
|
|
|
#include "iup.h"
|
|
#include "iupcontrols.h"
|
|
#include "iupcbs.h"
|
|
#include <cd.h>
|
|
#include <cdlua.h>
|
|
|
|
#include "iuplua.h"
|
|
#include "il.h"
|
|
#include "il_controls.h"
|
|
|
|
#include "iup_attrib.h"
|
|
#include "iup_object.h"
|
|
#include "iup_assert.h"
|
|
#include "iup_predialogs.h"
|
|
#include "iup_str.h"
|
|
|
|
|
|
|
|
typedef int(*IFnL)(Ihandle*, lua_State *L);
|
|
|
|
|
|
static int math_sum(lua_State *L)
|
|
{
|
|
int n = lua_gettop(L); /* number of arguments */
|
|
lua_Number dsum = luaL_checknumber(L, 1);
|
|
int i;
|
|
for (i = 2; i <= n; i++)
|
|
{
|
|
lua_Number d = luaL_checknumber(L, i);
|
|
dsum += d;
|
|
}
|
|
lua_pushnumber(L, dsum);
|
|
return 1;
|
|
}
|
|
|
|
static int math_average(lua_State *L)
|
|
{
|
|
int n = lua_gettop(L); /* number of arguments */
|
|
lua_Number dsum = luaL_checknumber(L, 1);
|
|
int i;
|
|
for (i = 2; i <= n; i++)
|
|
{
|
|
lua_Number d = luaL_checknumber(L, i);
|
|
dsum += d;
|
|
}
|
|
dsum /= (double)n;
|
|
lua_pushnumber(L, dsum);
|
|
return 1;
|
|
}
|
|
|
|
static int luamatrix_pushvalue(lua_State *L, const char* value, int only_number)
|
|
{
|
|
double num;
|
|
|
|
if (!value || value[0] == 0)
|
|
{
|
|
if (only_number)
|
|
return 0;
|
|
|
|
lua_pushnil(L);
|
|
return 1;
|
|
}
|
|
|
|
if (sscanf(value, "%lf", &num) == 1)
|
|
lua_pushnumber(L, num);
|
|
else
|
|
{
|
|
if (only_number)
|
|
return 0;
|
|
|
|
lua_pushstring(L, value);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static char* get_cell_value_safe(lua_State *L, Ihandle* ih, int lin, int col)
|
|
{
|
|
char* value;
|
|
|
|
if (iupAttribGetId2(ih, "_IUPMATRIX_GETCELL", lin, col))
|
|
luaL_error(L, "recursion detected for cell(%d,%d)", lin, col);
|
|
|
|
iupAttribSetStrId2(ih, "_IUPMATRIX_GETCELL", lin, col, "1");
|
|
value = IupGetAttributeId2(ih, "CELL", lin, col); /* display value */
|
|
iupAttribSetId2(ih, "_IUPMATRIX_GETCELL", lin, col, NULL);
|
|
|
|
return value;
|
|
}
|
|
|
|
static int formula_range(lua_State *L)
|
|
{
|
|
Ihandle *ih;
|
|
int lin1 = luaL_checkinteger(L, 1);
|
|
int col1 = luaL_checkinteger(L, 2);
|
|
int lin2 = luaL_checkinteger(L, 3);
|
|
int col2 = luaL_checkinteger(L, 4);
|
|
int only_number = 0;
|
|
int lin, col, count;
|
|
|
|
if (lua_isboolean(L, 5))
|
|
only_number = lua_toboolean(L, 5);
|
|
|
|
lua_getglobal(L, "matrix");
|
|
ih = (Ihandle*)lua_touserdata(L, -1);
|
|
|
|
count = 0;
|
|
|
|
for (lin = lin1; lin <= lin2; lin++)
|
|
{
|
|
for (col = col1; col <= col2; col++)
|
|
{
|
|
char* value = get_cell_value_safe(L, ih, lin, col);
|
|
|
|
if (luamatrix_pushvalue(L, value, only_number))
|
|
count++;
|
|
}
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
static int formula_cell(lua_State *L)
|
|
{
|
|
Ihandle *ih;
|
|
char* value;
|
|
|
|
int lin = luaL_checkinteger(L, 1);
|
|
int col = luaL_checkinteger(L, 2);
|
|
|
|
lua_getglobal(L, "matrix");
|
|
ih = (Ihandle*)lua_touserdata(L, -1);
|
|
|
|
value = get_cell_value_safe(L, ih, lin, col);
|
|
return luamatrix_pushvalue(L, value, 0);
|
|
}
|
|
|
|
static int formula_ifelse(lua_State *L)
|
|
{
|
|
lua_toboolean(L, 1) ? lua_pushvalue(L, 2) : lua_pushvalue(L, 3);
|
|
return 1;
|
|
}
|
|
|
|
static void show_formula_error(lua_State *L, Ihandle* ih, const char* str_message)
|
|
{
|
|
const char* error = lua_tostring(L, -1);
|
|
char msg[1024];
|
|
sprintf(msg, "%s\n Lua error: %s", str_message, error);
|
|
IupMessageError(IupGetDialog(ih), msg);
|
|
}
|
|
|
|
static void register_math_global(lua_State *L)
|
|
{
|
|
const char* register_global =
|
|
"function openpackage(ns)\n"
|
|
" for n, v in pairs(ns) do _G[n] = v end\n"
|
|
"end\n"
|
|
"openpackage(math)\n";
|
|
|
|
luaL_dostring(L, register_global);
|
|
}
|
|
|
|
#define iup_isupper(_c) (_c>='A' && _c<='Z')
|
|
|
|
static int matrix_get_global_name(const char* key, size_t len, int *lin, int *col)
|
|
{
|
|
int i;
|
|
|
|
if (len < 2)
|
|
return 0;
|
|
|
|
if (key[0] == 'L' && iup_isdigit(key[1]) && len > 3)
|
|
{
|
|
i = 2;
|
|
while (iup_isdigit(key[i]) && i < len)
|
|
i++;
|
|
|
|
if (key[i] == 'C' && iup_isdigit(key[i+1]))
|
|
{
|
|
int start_col = i+1;
|
|
i += 2;
|
|
|
|
while (iup_isdigit(key[i]) && i < len)
|
|
i++;
|
|
|
|
if (i == len) /* found L123C123 notation */
|
|
{
|
|
char str_lin[50];
|
|
int str_lin_len = start_col-2;
|
|
if (str_lin_len > 50)
|
|
return 0;
|
|
|
|
memcpy(str_lin, key + 1, str_lin_len);
|
|
str_lin[str_lin_len] = 0;
|
|
iupStrToInt(str_lin, lin);
|
|
|
|
iupStrToInt(key + start_col, col);
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int excel_get_global_name(const char* key, size_t len, int *lin, int *col)
|
|
{
|
|
int i;
|
|
|
|
if (len < 2)
|
|
return 0;
|
|
|
|
if (iup_isupper(key[0]) && len > 1)
|
|
{
|
|
i = 1;
|
|
while (iup_isupper(key[i]) && i < len)
|
|
i++;
|
|
|
|
if (iup_isdigit(key[i]))
|
|
{
|
|
int start_lin = i;
|
|
i++;
|
|
|
|
while (iup_isdigit(key[i]) && i < len)
|
|
i++;
|
|
|
|
if (i == len) /* found ABC123 (col|lin) notation (same as Excel) */
|
|
{
|
|
*col = 0;
|
|
i = 0;
|
|
while (i < start_lin)
|
|
{
|
|
(*col) = 26 * (*col) + (key[i] - 'A' + 1);
|
|
i++;
|
|
}
|
|
|
|
iupStrToInt(key + start_lin, lin);
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int matrix_global_index(lua_State *L)
|
|
{
|
|
size_t len;
|
|
const char* key = lua_tolstring(L, 2, &len);
|
|
int lin, col;
|
|
|
|
if (matrix_get_global_name(key, len, &lin, &col))
|
|
{
|
|
Ihandle *ih;
|
|
char* value;
|
|
|
|
lua_getglobal(L, "matrix");
|
|
ih = (Ihandle*)lua_touserdata(L, -1);
|
|
|
|
value = get_cell_value_safe(L, ih, lin, col);
|
|
luamatrix_pushvalue(L, value, 0);
|
|
}
|
|
else
|
|
{
|
|
/* get raw method */
|
|
lua_getmetatable(L, 1);
|
|
lua_pushvalue(L, 2);
|
|
lua_rawget(L, -2);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int excel_global_index(lua_State *L)
|
|
{
|
|
size_t len;
|
|
const char* key = lua_tolstring(L, 2, &len);
|
|
int lin, col;
|
|
|
|
if (excel_get_global_name(key, len, &lin, &col))
|
|
{
|
|
Ihandle *ih;
|
|
char* value;
|
|
|
|
lua_getglobal(L, "matrix");
|
|
ih = (Ihandle*)lua_touserdata(L, -1);
|
|
|
|
value = get_cell_value_safe(L, ih, lin, col);
|
|
luamatrix_pushvalue(L, value, 0);
|
|
}
|
|
else
|
|
{
|
|
/* get raw method */
|
|
lua_getmetatable(L, 1);
|
|
lua_pushvalue(L, 2);
|
|
lua_rawget(L, -2);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static lua_State* iMatrixInitFormula(Ihandle* ih, const char* init)
|
|
{
|
|
lua_State *L;
|
|
IFnL init_cb;
|
|
char* cell_names;
|
|
|
|
iupASSERT(iupObjectCheck(ih));
|
|
if (!iupObjectCheck(ih))
|
|
return NULL;
|
|
|
|
/* must be an IupMatrix */
|
|
if (ih->iclass->nativetype != IUP_TYPECANVAS ||
|
|
!IupClassMatch(ih, "matrix"))
|
|
return NULL;
|
|
|
|
L = (lua_State*)iupAttribGet(ih, "_IUPMATRIX_LUASTATE"); /* Used only by SetDynamic */
|
|
if (L)
|
|
lua_close(L);
|
|
|
|
L = luaL_newstate();
|
|
luaL_openlibs(L);
|
|
|
|
register_math_global(L);
|
|
|
|
cell_names = iupAttribGet(ih, "CELLNAMES");
|
|
if (iupStrEqualNoCase(cell_names, "EXCEL"))
|
|
{
|
|
lua_register(L, "global_index", excel_global_index);
|
|
luaL_dostring(L, "setmetatable(_G, {__index=global_index})");
|
|
}
|
|
else if (iupStrEqualNoCase(cell_names, "MATRIX"))
|
|
{
|
|
lua_register(L, "global_index", matrix_global_index);
|
|
luaL_dostring(L, "setmetatable(_G, {__index=global_index})");
|
|
}
|
|
|
|
lua_register(L, "sum", math_sum);
|
|
lua_register(L, "average", math_average);
|
|
lua_register(L, "range", formula_range);
|
|
lua_register(L, "cell", formula_cell);
|
|
lua_register(L, "ifelse", formula_ifelse);
|
|
|
|
if (init)
|
|
luaL_dostring(L, init);
|
|
|
|
init_cb = (IFnL)IupGetCallback(ih, "FORMULAINIT_CB");
|
|
if (init_cb)
|
|
init_cb(ih, L);
|
|
|
|
lua_pushlightuserdata(L, ih);
|
|
lua_setglobal(L, "matrix");
|
|
|
|
return L;
|
|
}
|
|
|
|
static int iMatrixLoadFormula(lua_State *L, const char* formula)
|
|
{
|
|
char formula_func[1024];
|
|
|
|
sprintf(formula_func, "function matrix_formula(lin, col)\n"
|
|
" return %s\n"
|
|
"end\n", formula);
|
|
|
|
if (luaL_dostring(L, formula_func) != 0)
|
|
return 0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int iMatrixExecFormula(lua_State *L, int lin, int col)
|
|
{
|
|
lua_getglobal(L, "matrix_formula");
|
|
lua_pushinteger(L, lin);
|
|
lua_pushinteger(L, col);
|
|
|
|
if (lua_pcall(L, 2, 1, 0) != 0)
|
|
return 0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
void IupMatrixSetFormula(Ihandle* ih, int col, const char* formula, const char* init)
|
|
{
|
|
int lin, numlin;
|
|
|
|
lua_State *L = iMatrixInitFormula(ih, init);
|
|
if (!L)
|
|
return;
|
|
|
|
if (!iMatrixLoadFormula(L, formula))
|
|
{
|
|
const char* str_message = IupGetLanguageString("IUP_ERRORINVALIDFORMULA");
|
|
show_formula_error(L, ih, str_message);
|
|
lua_close(L);
|
|
return;
|
|
}
|
|
|
|
numlin = IupGetInt(ih, "NUMLIN");
|
|
|
|
for (lin = 1; lin <= numlin; lin++)
|
|
{
|
|
if (!iMatrixExecFormula(L, lin, col))
|
|
{
|
|
const char* str_message = IupGetLanguageString("IUP_ERRORINVALIDFORMULA");
|
|
show_formula_error(L, ih, str_message);
|
|
lua_close(L);
|
|
return;
|
|
}
|
|
|
|
/* get the result */
|
|
|
|
if (lua_isnumber(L, -1))
|
|
{
|
|
double num = lua_tonumber(L, -1);
|
|
IupSetDoubleId2(ih, "", lin, col, num);
|
|
}
|
|
else if (lua_isnil(L, -1))
|
|
IupSetAttributeId2(ih, "", lin, col, NULL);
|
|
else if (lua_isboolean(L, -1))
|
|
{
|
|
int num = lua_toboolean(L, -1);
|
|
IupSetIntId2(ih, "", lin, col, num);
|
|
}
|
|
else
|
|
{
|
|
const char* value = lua_tostring(L, -1);
|
|
IupSetStrAttributeId2(ih, "", lin, col, value);
|
|
}
|
|
|
|
lua_pop(L, 1); /* remove the result from the stack */
|
|
}
|
|
|
|
lua_close(L);
|
|
}
|
|
|
|
static char* iMatrixDynamicTranslateValue_CB(Ihandle* ih, int lin, int col, char* value)
|
|
{
|
|
if (value && value[0] == '=' && !iupAttribGet(ih, "EDITVALUE"))
|
|
{
|
|
lua_State* L = (lua_State*)iupAttribGet(ih, "_IUPMATRIX_LUASTATE");
|
|
|
|
if (!iMatrixLoadFormula(L, value + 1))
|
|
{
|
|
const char* str_message = IupGetLanguageString("IUP_ERRORINVALIDFORMULA");
|
|
show_formula_error(L, ih, str_message);
|
|
return (char*)str_message;
|
|
}
|
|
|
|
if (!iMatrixExecFormula(L, lin, col))
|
|
{
|
|
const char* str_message = IupGetLanguageString("IUP_ERRORINVALIDFORMULA");
|
|
show_formula_error(L, ih, str_message);
|
|
return (char*)str_message;
|
|
}
|
|
|
|
/* get the result */
|
|
|
|
if (lua_isnumber(L, -1))
|
|
{
|
|
double num = lua_tonumber(L, -1);
|
|
iupAttribSetDouble(ih, "FORMULA_RETURN", num);
|
|
}
|
|
else
|
|
{
|
|
const char* str = lua_tostring(L, -1);
|
|
iupAttribSetStr(ih, "FORMULA_RETURN", str);
|
|
}
|
|
|
|
lua_pop(L, 1); /* remove the result from the stack */
|
|
return iupAttribGet(ih, "FORMULA_RETURN");
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
/* Samples:
|
|
A = 1
|
|
Z = 26
|
|
BC = 55
|
|
AD = 30
|
|
*/
|
|
static void iMatrixDynamicColName(char* col_name, int col)
|
|
{
|
|
int n = 1;
|
|
int cc = col;
|
|
while (cc > 26)
|
|
{
|
|
cc /= 26;
|
|
n++;
|
|
}
|
|
|
|
col_name[n] = 0;
|
|
|
|
while (n)
|
|
{
|
|
int rem = col % 26;
|
|
int c = rem + 'A' - 1;
|
|
col_name[n-1] = (char)c;
|
|
col /= 26;
|
|
n--;
|
|
}
|
|
}
|
|
|
|
static void iMatrixDynamicInsertCellReference(Ihandle* ih, int lin, int col)
|
|
{
|
|
char* old_value = iupAttribGet(ih, "_IUPMATRIX_EDITVALUE");
|
|
if (old_value)
|
|
{
|
|
char* cell_names;
|
|
char* old_caret = iupAttribGet(ih, "_IUPMATRIX_EDITCARET");
|
|
|
|
IupSetStrAttribute(ih, "VALUE", old_value);
|
|
IupSetStrAttribute(ih, "CARET", old_caret);
|
|
|
|
cell_names = iupAttribGet(ih, "CELLNAMES");
|
|
if (iupStrEqualNoCase(cell_names, "EXCEL"))
|
|
{
|
|
char col_name[30];
|
|
iMatrixDynamicColName(col_name, col);
|
|
IupSetfAttribute(ih, "INSERT", "%s%d", col_name, lin);
|
|
}
|
|
else if (iupStrEqualNoCase(cell_names, "MATRIX"))
|
|
IupSetfAttribute(ih, "INSERT", "L%dC%d", lin, col);
|
|
else
|
|
IupSetfAttribute(ih, "INSERT", "cell(%d,%d)", lin, col);
|
|
}
|
|
}
|
|
|
|
static void iMatrixDynamicInsertRange(Ihandle* ih, int start_lin, int start_col, int lin, int col)
|
|
{
|
|
char* old_value = iupAttribGet(ih, "_IUPMATRIX_EDITVALUE");
|
|
if (old_value)
|
|
{
|
|
char* old_caret = iupAttribGet(ih, "_IUPMATRIX_EDITCARET");
|
|
|
|
IupSetStrAttribute(ih, "VALUE", old_value);
|
|
IupSetStrAttribute(ih, "CARET", old_caret);
|
|
IupSetfAttribute(ih, "INSERT", "range(%d,%d,%d,%d)", start_lin, start_col, lin, col);
|
|
}
|
|
}
|
|
|
|
static int iMatrixDynamicEditKillFocus_CB(Ihandle* ih)
|
|
{
|
|
if (IupGetInt(ih, "EDITTEXT"))
|
|
{
|
|
char* value = IupGetAttribute(ih, "VALUE"); /* edited value */
|
|
char* caret = IupGetAttribute(ih, "CARET");
|
|
iupAttribSetStr(ih, "_IUPMATRIX_EDITVALUE", value);
|
|
iupAttribSetStr(ih, "_IUPMATRIX_EDITCARET", caret);
|
|
}
|
|
|
|
return IUP_DEFAULT;
|
|
}
|
|
|
|
static int iMatrixDynamicEditClick_CB(Ihandle* ih, int lin, int col, char* status)
|
|
{
|
|
if (iup_isbutton1(status) && IupGetInt(ih, "EDITTEXT"))
|
|
{
|
|
char* value = IupGetAttribute(ih, "VALUE"); /* edited value */
|
|
if (value && value[0] == '=')
|
|
{
|
|
iMatrixDynamicInsertCellReference(ih, lin, col);
|
|
iupAttribSetStrf(ih, "_IUPMATRIX_EDITINSERT", "%d:%d", lin, col);
|
|
}
|
|
}
|
|
|
|
return IUP_DEFAULT;
|
|
}
|
|
|
|
static int iMatrixDynamicEditRelease_CB(Ihandle* ih, int lin, int col, char* status)
|
|
{
|
|
(void)lin;
|
|
(void)col;
|
|
(void)status;
|
|
|
|
if (iupAttribGet(ih, "_IUPMATRIX_EDITINSERT"))
|
|
iupAttribSet(ih, "_IUPMATRIX_EDITINSERT", NULL);
|
|
|
|
return IUP_DEFAULT;
|
|
}
|
|
|
|
static int iMatrixDynamicEditMouseMove_CB(Ihandle* ih, int lin, int col)
|
|
{
|
|
char* value = iupAttribGet(ih, "_IUPMATRIX_EDITINSERT");
|
|
if (value)
|
|
{
|
|
int start_lin, start_col;
|
|
iupStrToIntInt(value, &start_lin, &start_col, ':');
|
|
iMatrixDynamicInsertRange(ih, start_lin, start_col, lin, col);
|
|
}
|
|
return IUP_DEFAULT;
|
|
}
|
|
|
|
static int iMatrixDynamicLDestroy_CB(Ihandle* ih)
|
|
{
|
|
Icallback cb = IupGetCallback(ih, "OLD_LDESTROY_CB");
|
|
lua_State* L = (lua_State*)iupAttribGet(ih, "_IUPMATRIX_LUASTATE");
|
|
iupAttribSet(ih, "_IUPMATRIX_LUASTATE", NULL);
|
|
IupSetCallback(ih, "TRANSLATEVALUE_CB", NULL);
|
|
lua_close(L);
|
|
if (cb)
|
|
cb(ih);
|
|
return IUP_DEFAULT;
|
|
}
|
|
|
|
void IupMatrixSetDynamic(Ihandle* ih, const char* init)
|
|
{
|
|
Icallback cb;
|
|
|
|
lua_State *L = iMatrixInitFormula(ih, init);
|
|
if (!L)
|
|
return;
|
|
|
|
iupAttribSet(ih, "_IUPMATRIX_LUASTATE", (char*)L);
|
|
|
|
cb = IupGetCallback(ih, "LDESTROY_CB");
|
|
if (cb)
|
|
IupSetCallback(ih, "OLD_LDESTROY_CB", cb);
|
|
IupSetCallback(ih, "LDESTROY_CB", iMatrixDynamicLDestroy_CB);
|
|
|
|
IupSetCallback(ih, "TRANSLATEVALUE_CB", (Icallback)iMatrixDynamicTranslateValue_CB);
|
|
IupSetCallback(ih, "EDITCLICK_CB", (Icallback)iMatrixDynamicEditClick_CB);
|
|
IupSetCallback(ih, "EDITRELEASE_CB", (Icallback)iMatrixDynamicEditRelease_CB);
|
|
IupSetCallback(ih, "EDITMOUSEMOVE_CB", (Icallback)iMatrixDynamicEditMouseMove_CB);
|
|
IupSetCallback(ih, "EDITKILLFOCUS_CB", (Icallback)iMatrixDynamicEditKillFocus_CB);
|
|
}
|
|
|
|
static int MatrixSetFormula(lua_State *L)
|
|
{
|
|
Ihandle *ih = iuplua_checkihandle(L, 1);
|
|
IupMatrixSetFormula(ih, (int)luaL_checkinteger(L, 2), luaL_checkstring(L, 3), luaL_optstring(L, 4, NULL));
|
|
return 0;
|
|
}
|
|
|
|
static int MatrixSetDynamic(lua_State *L)
|
|
{
|
|
Ihandle *ih = iuplua_checkihandle(L, 1);
|
|
IupMatrixSetDynamic(ih, luaL_optstring(L, 2, NULL));
|
|
return 0;
|
|
}
|
|
|
|
static int matrix_draw_cb(Ihandle *self, int p0, int p1, int p2, int p3, int p4, int p5, cdCanvas* cnv)
|
|
{
|
|
lua_State *L = iuplua_call_start(self, "draw_cb");
|
|
lua_pushinteger(L, p0);
|
|
lua_pushinteger(L, p1);
|
|
lua_pushinteger(L, p2);
|
|
lua_pushinteger(L, p3);
|
|
lua_pushinteger(L, p4);
|
|
lua_pushinteger(L, p5);
|
|
cdlua_pushcanvas(L, cnv);
|
|
return iuplua_call(L, 7);
|
|
}
|
|
|
|
static int matrix_color_cb(Ihandle *self, int p0, int p1, int *p2, int *p3, int *p4, const char* name)
|
|
{
|
|
int status;
|
|
lua_State *L = iuplua_call_start(self, name);
|
|
int top = lua_gettop(L) - 3; /* 3 is the number of pushed values in iuplua_call_start */
|
|
/* don't have control over the number of returned values because of LUA_MULTRET,
|
|
so must restore stack manually */
|
|
|
|
lua_pushinteger(L, p0);
|
|
lua_pushinteger(L, p1);
|
|
|
|
/* similar to iuplua_call */
|
|
status = iuplua_call_raw(L, 2 + 2, LUA_MULTRET); /* 2 args + 2 args(errormsg, ih), variable number of returns */
|
|
|
|
if (status != LUA_OK)
|
|
return IUP_DEFAULT;
|
|
else
|
|
{
|
|
/* can do:
|
|
return r, g, b, iup.DEFAULT
|
|
return r, g, b, iup.IGNORE
|
|
return iup.IGNORE
|
|
return -- same as iup.IGNORE
|
|
*/
|
|
int tmp = (int)lua_isnil(L, -1)? IUP_IGNORE: (int)lua_tointeger(L, -1);
|
|
if (tmp == IUP_IGNORE)
|
|
{
|
|
lua_settop(L, top); /* remove the results */
|
|
return IUP_IGNORE;
|
|
}
|
|
|
|
*p2 = (int)lua_tointeger(L, -4); /* R */
|
|
*p3 = (int)lua_tointeger(L, -3); /* G */
|
|
*p4 = (int)lua_tointeger(L, -2); /* B */
|
|
lua_settop(L, top); /* remove the results */
|
|
return IUP_DEFAULT;
|
|
}
|
|
}
|
|
|
|
static int matrix_bgcolor_cb(Ihandle *self, int p0, int p1, int *p2, int *p3, int *p4)
|
|
{
|
|
return matrix_color_cb(self, p0, p1, p2, p3, p4, "bgcolor_cb");
|
|
}
|
|
|
|
static int matrix_fgcolor_cb(Ihandle *self, int p0, int p1, int *p2, int *p3, int *p4)
|
|
{
|
|
return matrix_color_cb(self, p0, p1, p2, p3, p4, "fgcolor_cb");
|
|
}
|
|
|
|
static int MatGetAttribute(lua_State *L)
|
|
{
|
|
Ihandle *ih = iuplua_checkihandle(L,1);
|
|
const char *name = luaL_checkstring(L,2);
|
|
int lin = (int)luaL_checkinteger(L,3);
|
|
int col = (int)luaL_checkinteger(L, 4);
|
|
const char *value = IupGetAttributeId2(ih, name, lin, col);
|
|
if (!value || iupATTRIB_ISINTERNAL(name))
|
|
lua_pushnil(L);
|
|
else
|
|
{
|
|
if (iupAttribIsNotString(ih, name))
|
|
{
|
|
if (iupAttribIsIhandle(ih, name))
|
|
iuplua_pushihandle(L, (Ihandle*)value);
|
|
else
|
|
lua_pushlightuserdata(L, (void*)value);
|
|
}
|
|
else
|
|
lua_pushstring(L,value);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static int MatStoreAttribute(lua_State *L)
|
|
{
|
|
Ihandle *ih = iuplua_checkihandle(L,1);
|
|
const char *a = luaL_checkstring(L,2);
|
|
int lin = luaL_checkinteger(L,3);
|
|
int col = luaL_checkinteger(L,4);
|
|
|
|
if (lua_isnil(L,5))
|
|
IupSetAttributeId2(ih,a,lin, col,NULL);
|
|
else
|
|
{
|
|
const char *v;
|
|
if(lua_isuserdata(L,5))
|
|
{
|
|
v = lua_touserdata(L,5);
|
|
IupSetAttributeId2(ih,a,lin, col,v);
|
|
}
|
|
else
|
|
{
|
|
v = luaL_checkstring(L,5);
|
|
IupStoreAttributeId2(ih,a,lin, col,v);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static IFnii iMatrixOriginalKeyPress_CB = NULL;
|
|
static IFniiiis iMatrixOriginalButton_CB = NULL;
|
|
static IFniis iMatrixOriginalMotion_CB = NULL;
|
|
|
|
static int MatButtonCB(lua_State *L)
|
|
{
|
|
Ihandle *ih = iuplua_checkihandle(L, 1);
|
|
int p0 = luaL_checkinteger(L, 2);
|
|
int p1 = luaL_checkinteger(L, 3);
|
|
int p2 = luaL_checkinteger(L, 4);
|
|
int p3 = luaL_checkinteger(L, 5);
|
|
const char* p4 = luaL_checkstring(L, 6);
|
|
int ret = iMatrixOriginalButton_CB(ih, p0, p1, p2, p3, (char*)p4);
|
|
lua_pushinteger(L, ret);
|
|
return 1;
|
|
}
|
|
|
|
static int MatMotionCB(lua_State *L)
|
|
{
|
|
Ihandle *ih = iuplua_checkihandle(L, 1);
|
|
int p0 = luaL_checkinteger(L, 2);
|
|
int p1 = luaL_checkinteger(L, 3);
|
|
const char* p2 = luaL_checkstring(L, 4);
|
|
int ret = iMatrixOriginalMotion_CB(ih, p0, p1, (char*)p2);
|
|
lua_pushinteger(L, ret);
|
|
return 1;
|
|
}
|
|
|
|
static int MatKeyPressCB(lua_State *L)
|
|
{
|
|
Ihandle *ih = iuplua_checkihandle(L, 1);
|
|
int p0 = luaL_checkinteger(L, 2);
|
|
int p1 = luaL_checkinteger(L, 3);
|
|
int ret = iMatrixOriginalKeyPress_CB(ih, p0, p1);
|
|
lua_pushinteger(L, ret);
|
|
return 1;
|
|
}
|
|
|
|
void iuplua_matrixfuncs_open(lua_State *L)
|
|
{
|
|
iuplua_register(L, MatrixSetFormula, "MatrixSetFormula");
|
|
iuplua_register(L, MatrixSetDynamic, "MatrixSetDynamic");
|
|
|
|
/* DEPRECATED backward compatibility */
|
|
iuplua_register(L, MatGetAttribute, "MatGetAttribute");
|
|
iuplua_register(L, MatStoreAttribute, "MatStoreAttribute");
|
|
iuplua_register(L, MatStoreAttribute, "MatSetAttribute");
|
|
|
|
/* Original Callback Export */
|
|
iuplua_register(L, MatButtonCB, "MatButtonCb");
|
|
iuplua_register(L, MatMotionCB, "MatMotionCb");
|
|
iuplua_register(L, MatKeyPressCB, "MatKeyPressCb");
|
|
|
|
{
|
|
Ihandle* mat = IupMatrix(NULL);
|
|
iMatrixOriginalKeyPress_CB = (IFnii)IupGetCallback(mat, "KEYPRESS_CB");
|
|
iMatrixOriginalButton_CB = (IFniiiis)IupGetCallback(mat, "BUTTON_CB");
|
|
iMatrixOriginalMotion_CB = (IFniis)IupGetCallback(mat, "MOTION_CB");
|
|
IupDestroy(mat);
|
|
}
|
|
|
|
iuplua_register_cb(L, "BGCOLOR_CB", (lua_CFunction)matrix_bgcolor_cb, NULL);
|
|
iuplua_register_cb(L, "FGCOLOR_CB", (lua_CFunction)matrix_fgcolor_cb, NULL);
|
|
iuplua_register_cb(L, "DRAW_CB", (lua_CFunction)matrix_draw_cb, NULL);
|
|
iuplua_register_cb(L, "LISTDRAW_CB", (lua_CFunction)matrix_draw_cb, NULL);
|
|
}
|