SCOLWidget.cpp

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2012 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
 
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
 
#include "SCOLPack/SO3SCOL.h"
 
// Renderer includes
#include "SO3Renderer/SO3Widget.h"
#include "SO3Renderer/SO3WidgetListener.h"
#include "SO3Renderer/SO3WidgetManager.h"
#include "SO3Renderer/SO3WebNavigatorWidget.h"
#include "SO3Renderer/SO3Root.h"
 
// Scene Graph includes
#include "SO3SceneGraph/SO3Scene.h"
 
int WIDGET_ENTER_EVENT;
int WIDGET_EXIT_EVENT;
int WIDGET_MOUSEDOWN_EVENT;
int WIDGET_MOUSEUP_EVENT;
int WIDGET_MOUSEMOVE_EVENT;
int WIDGET_MOUSEWHEEL_EVENT;
int WIDGET_TOUCHADD_EVENT;
int WIDGET_TOUCHREMOVE_EVENT;
int WIDGET_TOUCHUPDATE_EVENT;
int WIDGET_INPUTDOWN_EVENT;
int WIDGET_INPUTUP_EVENT;
int WIDGET_INPUTUPDATE_EVENT;
int WIDGET_INPUTWHEEL_EVENT;
int WIDGET_KEY_DOWN_EVENT;
int WIDGET_KEY_UP_EVENT;
int WIDGET_KEY_EVENT;
int WIDGET_FOCUS_EVENT;
int WIDGET_ON_LOAD_START_EVENT;
int WIDGET_ON_LOAD_END_EVENT;
int WIDGET_ON_LOAD_ERROR_EVENT;
int WIDGET_SCRIPT_EVENT;
 
#define XK_BackSpace            0xFF08  /* back space, back char */
#define XK_Tab                  0xFF09
#define XK_Linefeed             0xFF0A  /* Linefeed, LF */
#define XK_Clear                0xFF0B
#define XK_Return               0xFF0D  /* Return, enter */
#define XK_Pause                0xFF13  /* Pause, hold */
#define XK_Scroll_Lock          0xFF14
#define XK_Sys_Req              0xFF15
#define XK_Escape               0xFF1B
#define XK_Delete               0xFFFF  /* Delete, rubout */
 
#define XK_Multi_key            0xFF20  /* Multi-key character compose */
 
/* Cursor control & motion */
 
#define XK_Home                 0xFF50
#define XK_Left                 0xFF51  /* Move left, left arrow */
#define XK_Up                   0xFF52  /* Move up, up arrow */
#define XK_Right                0xFF53  /* Move right, right arrow */
#define XK_Down                 0xFF54  /* Move down, down arrow */
#define XK_Prior                0xFF55  /* Prior, previous */
#define XK_Page_Up              0xFF55
#define XK_Next                 0xFF56  /* Next */
#define XK_Page_Down            0xFF56
#define XK_End                  0xFF57  /* EOL */
#define XK_Begin                0xFF58  /* BOL */
 
 
/* Misc Functions */
 
#define XK_Select               0xFF60  /* Select, mark */
#define XK_Print                0xFF61
#define XK_Execute              0xFF62  /* Execute, run, do */
#define XK_Insert               0xFF63  /* Insert, insert here */
#define XK_Undo                 0xFF65  /* Undo, oops */
#define XK_Redo                 0xFF66  /* redo, again */
#define XK_Menu                 0xFF67
#define XK_Find                 0xFF68  /* Find, search */
#define XK_Cancel               0xFF69  /* Cancel, stop, abort, exit */
#define XK_Help                 0xFF6A  /* Help */
#define XK_Break                0xFF6B
#define XK_Mode_switch          0xFF7E  /* Character set switch */
#define XK_script_switch        0xFF7E  /* Alias for mode_switch */
#define XK_Num_Lock             0xFF7F
 
/* Keypad Functions, keypad numbers cleverly chosen to map to ascii */
 
#define XK_KP_Space             0xFF80  /* space */
#define XK_KP_Tab               0xFF89
#define XK_KP_Enter             0xFF8D  /* enter */
#define XK_KP_F1                0xFF91  /* PF1, KP_A, ... */
#define XK_KP_F2                0xFF92
#define XK_KP_F3                0xFF93
#define XK_KP_F4                0xFF94
#define XK_KP_Home              0xFF95
#define XK_KP_Left              0xFF96
#define XK_KP_Up                0xFF97
#define XK_KP_Right             0xFF98
#define XK_KP_Down              0xFF99
#define XK_KP_Prior             0xFF9A
#define XK_KP_Page_Up           0xFF9A
#define XK_KP_Next              0xFF9B
#define XK_KP_Page_Down         0xFF9B
#define XK_KP_End               0xFF9C
#define XK_KP_Begin             0xFF9D
#define XK_KP_Insert            0xFF9E
#define XK_KP_Delete            0xFF9F
#define XK_KP_Equal             0xFFBD  /* equals */
#define XK_KP_Multiply          0xFFAA
#define XK_KP_Add               0xFFAB
#define XK_KP_Separator         0xFFAC  /* separator, often comma */
#define XK_KP_Subtract          0xFFAD
#define XK_KP_Decimal           0xFFAE
#define XK_KP_Divide            0xFFAF
 
#define XK_KP_0                 0xFFB0
#define XK_KP_1                 0xFFB1
#define XK_KP_2                 0xFFB2
#define XK_KP_3                 0xFFB3
#define XK_KP_4                 0xFFB4
#define XK_KP_5                 0xFFB5
#define XK_KP_6                 0xFFB6
#define XK_KP_7                 0xFFB7
#define XK_KP_8                 0xFFB8
#define XK_KP_9                 0xFFB9
 
#define XK_F1                   0xFFBE
#define XK_F2                   0xFFBF
#define XK_F3                   0xFFC0
#define XK_F4                   0xFFC1
#define XK_F5                   0xFFC2
#define XK_F6                   0xFFC3
#define XK_F7                   0xFFC4
#define XK_F8                   0xFFC5
#define XK_F9                   0xFFC6
#define XK_F10                  0xFFC7
#define XK_F11                  0xFFC8
#define XK_L1                   0xFFC8
#define XK_F12                  0xFFC9
#define XK_L2                   0xFFC9
#define XK_F13                  0xFFCA
#define XK_L3                   0xFFCA
#define XK_F14                  0xFFCB
#define XK_L4                   0xFFCB
#define XK_F15                  0xFFCC
#define XK_L5                   0xFFCC
#define XK_F16                  0xFFCD
#define XK_L6                   0xFFCD
#define XK_F17                  0xFFCE
#define XK_L7                   0xFFCE
#define XK_F18                  0xFFCF
#define XK_L8                   0xFFCF
#define XK_F19                  0xFFD0
#define XK_L9                   0xFFD0
#define XK_F20                  0xFFD1
#define XK_L10                  0xFFD1
#define XK_F21                  0xFFD2
#define XK_R1                   0xFFD2
#define XK_F22                  0xFFD3
#define XK_R2                   0xFFD3
#define XK_F23                  0xFFD4
#define XK_R3                   0xFFD4
#define XK_F24                  0xFFD5
#define XK_R4                   0xFFD5
#define XK_F25                  0xFFD6
#define XK_R5                   0xFFD6
#define XK_F26                  0xFFD7
#define XK_R6                   0xFFD7
#define XK_F27                  0xFFD8
#define XK_R7                   0xFFD8
#define XK_F28                  0xFFD9
#define XK_R8                   0xFFD9
#define XK_F29                  0xFFDA
#define XK_R9                   0xFFDA
#define XK_F30                  0xFFDB
#define XK_R10                  0xFFDB
#define XK_F31                  0xFFDC
#define XK_R11                  0xFFDC
#define XK_F32                  0xFFDD
#define XK_R12                  0xFFDD
#define XK_F33                  0xFFDE
#define XK_R13                  0xFFDE
#define XK_F34                  0xFFDF
#define XK_R14                  0xFFDF
#define XK_F35                  0xFFE0
#define XK_R15                  0xFFE0
 
 
#define XK_Shift_L              0xFFE1  /* Left shift */
#define XK_Shift_R              0xFFE2  /* Right shift */
#define XK_Control_L            0xFFE3  /* Left control */
#define XK_Control_R            0xFFE4  /* Right control */
#define XK_Caps_Lock            0xFFE5  /* Caps lock */
#define XK_Shift_Lock           0xFFE6  /* Shift lock */
 
#define XK_Meta_L               0xFFE7  /* Left meta */
#define XK_Meta_R               0xFFE8  /* Right meta */
#define XK_Alt_L                0xFFE9  /* Left alt */
#define XK_Alt_R                0xFFEA  /* Right alt */
#define XK_Super_L              0xFFEB  /* Left super */
#define XK_Super_R              0xFFEC  /* Right super */
#define XK_Hyper_L              0xFFED  /* Left hyper */
#define XK_Hyper_R              0xFFEE  /* Right hyper */
 
int ScolZooTabCodes[160] =
{
  0, 0, 0, 0, 0, 0, 0, 0, /*0.*/
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, XK_Pause, XK_Caps_Lock, 0, 0, 0,
  0, 0, 0, XK_Escape, 0, 0, 0, 0,
  0, XK_Prior, XK_Next, XK_End, XK_Home, XK_Left, XK_Up, XK_Right,
  XK_Down, 0, 0, 0, XK_Sys_Req, XK_Insert, XK_Delete, 0,
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0, /*4.*/
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0,
  XK_F1, XK_F2, XK_F3, XK_F4, XK_F5, XK_F6, XK_F7, XK_F8,
  XK_F9, XK_F10, XK_F11, XK_F12, XK_F13, XK_F14, XK_F15, XK_F16,
  0, 0, 0, 0, 0, 0, 0, 0, /*8.*/
  0, 0, 0, 0, 0, 0, 0, 0,
  XK_Num_Lock, XK_Scroll_Lock, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0
};
 
int ZooConvertvirtcode(int c)
{
  if ((c < 0) || (c >= 160)) return 0;
  return ScolZooTabCodes[c];
}
 
class ScolMessageParameterKeyboard
{
public:
  UINT msg;
  ScolWindowHandle hwnd;
  UINT wParam;
  LONG lParam;
protected:
private:
 
public:
  ScolMessageParameterKeyboard(const UINT paramMsg, const ScolWindowHandle paramHwnd, const UINT paramWParam, const LONG paramLParam)
  {
    msg = (UINT)paramMsg;
    hwnd = (ScolWindowHandle)paramHwnd;
    wParam = (UINT)paramWParam;
    lParam = (LONG)paramLParam;
  };
protected:
private:
  ScolMessageParameterKeyboard()
  {
  };
};
 
class ScolWidgetEventsListener : public SWidgetListener
{
public:
protected:
private:
 
public:
  ScolWidgetEventsListener()
  {
  };
 
  virtual void OnEnter(SWidget* targetWidget)
  {
    OBJpostEvent(WIDGET_ENTER_EVENT, SCOL_PTR targetWidget, 0);
  };
 
  virtual void OnExit(SWidget* targetWidget)
  {
    OBJpostEvent(WIDGET_EXIT_EVENT, SCOL_PTR targetWidget, 0);
  };
 
  virtual void OnInside(SWidget* targetWidget)
  {
    // Not used anymore
  };
 
  virtual void OnMouseMove(SWidget* targetWidget, const int& mousePosX, const int& mousePosY, const MouseButtonId& mouseButton, const int& id)
  {
    MMOUSE* mouseParams = new MMOUSE(mousePosX, mousePosY, mouseButton, id);
    OBJpostEvent(WIDGET_MOUSEMOVE_EVENT, SCOL_PTR targetWidget, SCOL_PTR mouseParams);
 
    mouseParams = new MMOUSE(mousePosX, mousePosY, mouseButton, id);
    OBJpostEvent(WIDGET_INPUTUPDATE_EVENT, SCOL_PTR targetWidget, SCOL_PTR mouseParams);
  };
 
  virtual void OnMouseDown(SWidget* targetWidget, const int& mousePosX, const int& mousePosY, const MouseButtonId& mouseButton, const int& id)
  {
    MMOUSE* mouseParams = new MMOUSE(mousePosX, mousePosY, mouseButton, id);
    OBJpostEvent(WIDGET_MOUSEDOWN_EVENT, SCOL_PTR targetWidget, SCOL_PTR mouseParams);
 
    mouseParams = new MMOUSE(mousePosX, mousePosY, mouseButton, id);
    OBJpostEvent(WIDGET_INPUTDOWN_EVENT, SCOL_PTR targetWidget, SCOL_PTR mouseParams);
  };
 
  virtual void OnMouseUp(SWidget* targetWidget, const int& mousePosX, const int& mousePosY, const MouseButtonId& mouseButton, const int& id)
  {
    MMOUSE* mouseParams = new MMOUSE(mousePosX, mousePosY, mouseButton, id);
    OBJpostEvent(WIDGET_MOUSEUP_EVENT, SCOL_PTR targetWidget, SCOL_PTR mouseParams);
 
    mouseParams = new MMOUSE(mousePosX, mousePosY, mouseButton, id);
    OBJpostEvent(WIDGET_INPUTUP_EVENT, SCOL_PTR targetWidget, SCOL_PTR mouseParams);
  };
 
  virtual void OnMouseWheel(SWidget* targetWidget, const int& mousePosX, const int& mousePosY, const int& relativeScroll, const int& id)
  {
    MMOUSE* mouseParams = new MMOUSE(mousePosX, mousePosY, 0, id, relativeScroll);
    OBJpostEvent(WIDGET_MOUSEWHEEL_EVENT, SCOL_PTR targetWidget, SCOL_PTR mouseParams);
 
    mouseParams = new MMOUSE(mousePosX, mousePosY, 0, id, relativeScroll);
    OBJpostEvent(WIDGET_INPUTWHEEL_EVENT, SCOL_PTR targetWidget, SCOL_PTR mouseParams);
  };
 
  virtual void OnTouchAdd(SWidget* targetWidget, const int& mousePosX, const int& mousePosY, const int& touchid)
  {
    MMOUSE* mouseParams = new MMOUSE(mousePosX, mousePosY, 0, touchid);
    OBJpostEvent(WIDGET_TOUCHADD_EVENT, SCOL_PTR targetWidget, SCOL_PTR mouseParams);
  };
 
  virtual void OnTouchRemove(SWidget* targetWidget, const int& mousePosX, const int& mousePosY, const int& touchid)
  {
    MMOUSE* mouseParams = new MMOUSE(mousePosX, mousePosY, 0, touchid);
    OBJpostEvent(WIDGET_TOUCHREMOVE_EVENT, SCOL_PTR targetWidget, SCOL_PTR mouseParams);
  };
 
  virtual void OnTouchUpdate(SWidget* targetWidget, const int& mousePosX, const int& mousePosY, const int& vx, const int& vy, const int& touchid)
  {
    MMOUSE* mouseParams = new MMOUSE(mousePosX, mousePosY, 0, touchid, 0, 0, 0, vx, vy);
    OBJpostEvent(WIDGET_TOUCHUPDATE_EVENT, SCOL_PTR targetWidget, SCOL_PTR mouseParams);
  };
 
  virtual void OnKey(SWidget* targetWidget, const UINT& msg, const ScolWindowHandle& hwnd, const UINT& wParam, const LONG& lParam)
  {
    ScolMessageParameterKeyboard* messageParameterFull = new ScolMessageParameterKeyboard(msg, hwnd, wParam, lParam);
    OBJpostEvent(WIDGET_KEY_EVENT, SCOL_PTR targetWidget, SCOL_PTR messageParameterFull);
 
    ScolMessageParameterKeyboard* messageParameter = new ScolMessageParameterKeyboard(msg, hwnd, wParam, (lParam >> 16) & 0x1ff);
    if ((msg == WM_KEYDOWN) || (msg == WM_IME_KEYDOWN) || (msg == WM_SYSKEYDOWN) || (msg == WM_CHAR))
    {
      if (msg != WM_CHAR)
      {
        int c = ZooConvertvirtcode((int)wParam);
        if (c == 0)
          return;
        messageParameter->wParam = c;
      }
      else if ((int)wParam == XK_Escape)
        return;
 
      OBJpostEvent(WIDGET_KEY_DOWN_EVENT, SCOL_PTR targetWidget, SCOL_PTR messageParameter);
    }
    else if ((msg == WM_KEYUP) || (msg == WM_IME_KEYUP) || (msg == WM_SYSKEYUP))
      OBJpostEvent(WIDGET_KEY_UP_EVENT, SCOL_PTR targetWidget, SCOL_PTR messageParameter);
  };
 
  virtual void OnScriptCall(SWidget* targetWidget, const SScriptFunction& functionCalled)
  {
    // Copy to avoid multithread memory access errors
    SScriptFunction* scriptFunction = new SScriptFunction(functionCalled);
    OBJpostEvent(WIDGET_SCRIPT_EVENT, SCOL_PTR targetWidget, SCOL_PTR scriptFunction);
  };
 
  virtual void OnFocus(SWidget* targetWidget, const bool& focused)
  {
    OBJpostEvent(WIDGET_FOCUS_EVENT, SCOL_PTR targetWidget, SCOL_PTR (focused ? 1 : 0));
  };
 
  virtual void OnLoadStart(SWidget* targetWidget)
  {
    OBJpostEvent(WIDGET_ON_LOAD_START_EVENT, SCOL_PTR targetWidget, SCOL_PTR targetWidget);
  };
 
  virtual void OnLoadEnd(SWidget* targetWidget)
  {
    OBJpostEvent(WIDGET_ON_LOAD_END_EVENT, SCOL_PTR targetWidget, 0);
  };
 
  virtual void OnLoadError(SWidget* targetWidget, const int& errorCode, const std::string& failedUrl)
  {
    OBJpostEvent(WIDGET_ON_LOAD_ERROR_EVENT, SCOL_PTR targetWidget, SCOL_PTR failedUrl.c_str());
  };
protected:
private:
};
 
int getWidgetCallbackOnScriptCallback(mmachine m, SCOL_PTR_TYPE id, SCOL_PTR_TYPE param)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "getWidgetCallbackOnScriptCallback\n");
#endif
 
  int k;
  int res = 0;
 
  // Retrieve script function and arguments
  SO3::SScriptFunction* functionCalled = (SScriptFunction*)param;
 
  if (!(k = OBJbeginreflex(m, SO3WIDGET, id, SO3_WIDGET_SCRIPT_EVENT)))
  {
    // Push function name
    Mpushstrbloc(m, (char*)(functionCalled->function.c_str()));
 
    // Push every arguments
    for (unsigned int i = 0; i < functionCalled->arguments.size(); i++)
    {
      if (k = Mpushstrbloc(m, (char*)(functionCalled->arguments.at(i).c_str())))
        return k;
    }
 
    if (MMpush(m, NIL))
      return MERRMEM;
 
    for (unsigned int i = 0; i < functionCalled->arguments.size(); i++)
    {
      if (MMpush(m, 2 * 2))
        return MERRMEM;
 
      if (k = MBdeftab(m))
        return k;
    }
    res = OBJcallreflex(m, 2);
  }
 
  delete(functionCalled);
  return res;
}
 
 
int getWidgetCallbackOnEnterEvent(mmachine m, SCOL_PTR_TYPE id, SCOL_PTR_TYPE param)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "getWidgetCallbackOnEnterEvent\n");
#endif
 
  int k;
  int res = 0;
 
  if (!(k = OBJbeginreflex(m, SO3WIDGET, id, SO3_WIDGET_ENTER_EVENT)))
    res = OBJcallreflex(m, 0);
 
  return res;
}
 
 
int getWidgetCallbackOnExitEvent(mmachine m, SCOL_PTR_TYPE id, SCOL_PTR_TYPE param)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "getWidgetCallbackOnExitEvent\n");
#endif
 
  int k;
  int res = 0;
 
  if (!(k = OBJbeginreflex(m, SO3WIDGET, id, SO3_WIDGET_EXIT_EVENT)))
    res = OBJcallreflex(m, 0);
 
  return res;
}
 
 
int getWidgetCallbackMouseMoveEvent(mmachine m, SCOL_PTR_TYPE id, SCOL_PTR_TYPE param)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "getWidgetCallbackMouseMoveEvent\n");
#endif
 
  int k;
  int res = 0;
  MMOUSE* result = (MMOUSE*)param;
 
  if (!(k = OBJbeginreflex(m, SO3WIDGET, id, SO3_WIDGET_MOUSE_MOVE_EVENT)))
  {
    MMpush(m, ITOM(result->x));
    MMpush(m, ITOM(result->y));
    MMpush(m, ITOM(result->btn));
 
    res = OBJcallreflex(m, 3);
  }
 
  delete(result);
  return res;
}
 
 
int getWidgetCallbackMouseDownEvent(mmachine m, SCOL_PTR_TYPE id, SCOL_PTR_TYPE param)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "getWidgetCallbackMouseDownEvent\n");
#endif
 
  int k;
  int res = 0;
  MMOUSE* result = (MMOUSE*)param;
 
  if (!(k = OBJbeginreflex(m, SO3WIDGET, id, SO3_WIDGET_MOUSE_DOWN_EVENT)))
  {
    MMpush(m, ITOM(result->x));
    MMpush(m, ITOM(result->y));
    MMpush(m, ITOM(result->btn));
 
    res = OBJcallreflex(m, 3);
  }
 
  delete(result);
  return res;
}
 
 
int getWidgetCallbackMouseUpEvent(mmachine m, SCOL_PTR_TYPE id, SCOL_PTR_TYPE param)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "getWidgetCallbackMouseUpEvent\n");
#endif
 
  int k;
  int res = 0;
  MMOUSE* result = (MMOUSE*)param;
 
  if (!(k = OBJbeginreflex(m, SO3WIDGET, id, SO3_WIDGET_MOUSE_UP_EVENT)))
  {
    MMpush(m, ITOM(result->x));
    MMpush(m, ITOM(result->y));
    MMpush(m, ITOM(result->btn));
 
    res = OBJcallreflex(m, 3);
  }
 
  delete(result);
  return res;
}
 
 
int getWidgetCallbackMouseWheelEvent(mmachine m, SCOL_PTR_TYPE id, SCOL_PTR_TYPE param)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "getWidgetCallbackMouseWheelEvent\n");
#endif
 
  int k;
  int res = 0;
  MMOUSE* result = (MMOUSE*)param;
 
  if (!(k = OBJbeginreflex(m, SO3WIDGET, id, SO3_WIDGET_MOUSEWHEEL_EVENT)))
  {
    MMpush(m, ITOM(result->x));
    MMpush(m, ITOM(result->y));
    MMpush(m, ITOM(result->scroll));
 
    res = OBJcallreflex(m, 3);
  }
 
  delete(result);
  return res;
}
 
 
int getWidgetCallbackTouchAddEvent(mmachine m, SCOL_PTR_TYPE id, SCOL_PTR_TYPE param)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "getWidgetCallbackTouchAddEvent\n");
#endif
 
  int k;
  int res = 0;
  MMOUSE* result = (MMOUSE*)param;
 
  if (!(k = OBJbeginreflex(m, SO3WIDGET, id, SO3_WIDGET_TOUCH_ADD_EVENT)))
  {
    MMpush(m, ITOM(result->index));
    MMpush(m, ITOM(result->x));
    MMpush(m, ITOM(result->y));
 
    res = OBJcallreflex(m, 3);
  }
 
  delete(result);
  return res;
}
 
 
int getWidgetCallbackTouchRemoveEvent(mmachine m, SCOL_PTR_TYPE id, SCOL_PTR_TYPE param)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "getWidgetCallbackTouchRemoveEvent\n");
#endif
 
  int k;
  int res = 0;
  MMOUSE* result = (MMOUSE*)param;
 
  if (!(k = OBJbeginreflex(m, SO3WIDGET, id, SO3_WIDGET_TOUCH_REMOVE_EVENT)))
  {
    MMpush(m, ITOM(result->index));
    MMpush(m, ITOM(result->x));
    MMpush(m, ITOM(result->y));
 
    res = OBJcallreflex(m, 3);
  }
 
  delete(result);
  return res;
}
 
 
int getWidgetCallbackTouchUpdateEvent(mmachine m, SCOL_PTR_TYPE id, SCOL_PTR_TYPE param)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "getWidgetCallbackTouchUpdateEvent\n");
#endif
 
  int k;
  int res = 0;
  MMOUSE* result = (MMOUSE*)param;
 
  if (!(k = OBJbeginreflex(m, SO3WIDGET, id, SO3_WIDGET_TOUCH_UPDATE_EVENT)))
  {
    MMpush(m, ITOM(result->index));
    MMpush(m, ITOM(result->x));
    MMpush(m, ITOM(result->y));
    MMpush(m, ITOM(result->vx));
    MMpush(m, ITOM(result->vy));
 
    res = OBJcallreflex(m, 5);
  }
 
  delete(result);
  return res;
}
 
 
int getWidgetCallbackInputDownEvent(mmachine m, SCOL_PTR_TYPE id, SCOL_PTR_TYPE param)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "getWidgetCallbackInputDownEvent\n");
#endif
 
  int k;
  int res = 0;
  MMOUSE* result = (MMOUSE*)param;
 
  if (!(k = OBJbeginreflex(m, SO3WIDGET, id, SO3_WIDGET_INPUT_DOWN_EVENT)))
  {
    MMpush(m, ITOM(result->index));
    MMpush(m, ITOM(result->x));
    MMpush(m, ITOM(result->y));
    MMpush(m, ITOM(result->btn));
 
    res = OBJcallreflex(m, 4);
  }
 
  delete(result);
  return res;
}
 
 
int getWidgetCallbackInputUpEvent(mmachine m, SCOL_PTR_TYPE id, SCOL_PTR_TYPE param)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "getWidgetCallbackInputUpEvent\n");
#endif
 
  int k;
  int res = 0;
  MMOUSE* result = (MMOUSE*)param;
 
  if (!(k = OBJbeginreflex(m, SO3WIDGET, id, SO3_WIDGET_INPUT_UP_EVENT)))
  {
    MMpush(m, ITOM(result->index));
    MMpush(m, ITOM(result->x));
    MMpush(m, ITOM(result->y));
    MMpush(m, ITOM(result->btn));
 
    res = OBJcallreflex(m, 4);
  }
 
  delete(result);
  return res;
}
 
 
int getWidgetCallbackInputUpdateEvent(mmachine m, SCOL_PTR_TYPE id, SCOL_PTR_TYPE param)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "getWidgetCallbackInputUpdateEvent\n");
#endif
 
  int k;
  int res = 0;
  MMOUSE* result = (MMOUSE*)param;
 
  if (!(k = OBJbeginreflex(m, SO3WIDGET, id, SO3_WIDGET_INPUT_UPDATE_EVENT)))
  {
    MMpush(m, ITOM(result->index));
    MMpush(m, ITOM(result->x));
    MMpush(m, ITOM(result->y));
    MMpush(m, ITOM(result->btn));
 
    res = OBJcallreflex(m, 4);
  }
 
  delete(result);
  return res;
}
 
 
int getWidgetCallbackInputWheelEvent(mmachine m, SCOL_PTR_TYPE id, SCOL_PTR_TYPE param)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "getWidgetCallbackInputWheelEvent\n");
#endif
 
  int k;
  int res = 0;
  MMOUSE* result = (MMOUSE*)param;
 
  if (!(k = OBJbeginreflex(m, SO3WIDGET, id, SO3_WIDGET_INPUT_WHEEL_EVENT)))
  {
    MMpush(m, ITOM(result->index));
    MMpush(m, ITOM(result->x));
    MMpush(m, ITOM(result->y));
    MMpush(m, ITOM(result->scroll));
 
    res = OBJcallreflex(m, 4);
  }
 
  delete(result);
  return res;
}
 
 
int getWidgetCallbackKeyDownEvent(mmachine m, SCOL_PTR_TYPE id, SCOL_PTR_TYPE param)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "getWidgetCallbackKeyDownEvent\n");
#endif
 
  int k;
  int res = 0;
  ScolMessageParameterKeyboard* result = (ScolMessageParameterKeyboard*)param;
 
  if (!(k = OBJbeginreflex(m, SO3WIDGET, id, SO3_WIDGET_KEY_DOWN_EVENT)))
  {
    MMpush(m, ITOM(result->lParam));
    MMpush(m, ITOM(result->wParam));
    res = OBJcallreflex(m, 2);
  }
 
  delete(result);
  return res;
}
 
 
int getWidgetCallbackKeyUpEvent(mmachine m, SCOL_PTR_TYPE id, SCOL_PTR_TYPE param)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "getWidgetCallbackKeyUpEvent\n");
#endif
 
  int k;
  int res = 0;
  ScolMessageParameterKeyboard* result = (ScolMessageParameterKeyboard*)param;
 
  if (!(k = OBJbeginreflex(m, SO3WIDGET, id, SO3_WIDGET_KEY_UP_EVENT)))
  {
    MMpush(m, ITOM(result->lParam));
    res = OBJcallreflex(m, 1);
  }
 
  delete(result);
  return res;
}
 
 
int getWidgetCallbackKeyEvent(mmachine m, SCOL_PTR_TYPE id, SCOL_PTR_TYPE param)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "getWidgetCallbackKeyEvent\n");
#endif
 
  int k;
  int res = 0;
  ScolMessageParameterKeyboard* result = (ScolMessageParameterKeyboard*)param;
 
  if (!(k = OBJbeginreflex(m, SO3WIDGET, id, SO3_WIDGET_KEY_EVENT)))
  {
    MMpush(m, ITOM(result->msg));
    MMpush(m, ITOM(result->lParam));
    MMpush(m, ITOM(result->wParam));
    res = OBJcallreflex(m, 3);
  }
 
  delete(result);
  return res;
}
 
 
int getWidgetCallbackFocusEvent(mmachine m, SCOL_PTR_TYPE id, SCOL_PTR_TYPE param)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "getWidgetCallbackFocusEvent\n");
#endif
 
  int k;
  int res = 0;
  int result = (int)param;
 
  if (!(k = OBJbeginreflex(m, SO3WIDGET, id, SO3_WIDGET_FOCUS_EVENT)))
  {
    MMpush(m, ITOM(result));
    res = OBJcallreflex(m, 1);
  }
  return res;
}
 
int getWidgetCallbackOnLoadStartEvent(mmachine m, SCOL_PTR_TYPE id, SCOL_PTR_TYPE param)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "getWidgetCallbackOnLoadStartEvent\n");
#endif
 
  int k;
  int res = 0;
 
  if (!(k = OBJbeginreflex(m, SO3WIDGET, id, SO3_WIDGET_ON_LOAD_START_EVENT)))
  {
    res = OBJcallreflex(m, 0);
  }
  return res;
}
 
int getWidgetCallbackOnLoadEndEvent(mmachine m, SCOL_PTR_TYPE id, SCOL_PTR_TYPE param)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "getWidgetCallbackOnLoadEndEvent\n");
#endif
 
  int res = 0;
#if SO3_WEB_NAVIGATOR_BUILD == 1
  int k;
 
  SWidget* sWidget = (SWidget*)id;
  SWebNavigatorWidget* targetWidget = static_cast<SWebNavigatorWidget*>(sWidget);
  if (!(k = OBJbeginreflex(m, SO3WIDGET, id, SO3_WIDGET_ON_LOAD_END_EVENT)))
  {
    // force the update only if the scol object is valid
    if (targetWidget && targetWidget->GetUpdateOnFocusOnly() && !targetWidget->HasFocus())
      targetWidget->Update(true);
 
    res = OBJcallreflex(m, 0);
  }
#endif
  return res;
}
 
int getWidgetCallbackOnLoadErrorEvent(mmachine m, SCOL_PTR_TYPE id, SCOL_PTR_TYPE param)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "getWidgetCallbackOnLoadErrorEvent\n");
#endif
 
  int res = 0;
#if SO3_WEB_NAVIGATOR_BUILD == 1
  int k;
 
  SWidget* sWidget = (SWidget*)id;
  SWebNavigatorWidget* targetWidget = static_cast<SWebNavigatorWidget*>(sWidget);
 
  if (!(k = OBJbeginreflex(m, SO3WIDGET, id, SO3_WIDGET_ON_LOAD_ERROR_EVENT)))
  {
    // force the update only if the scol object is valid
    if (targetWidget && targetWidget->GetUpdateOnFocusOnly() && !targetWidget->HasFocus())
      targetWidget->Update(true);
 
    Mpushstrbloc(m, (char*)param);
    res = OBJcallreflex(m, 1);
  }
#endif
  return res;
}
 
int SO3WidgetLoadFile(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetLoadFile\n");
#endif
 
  int ff = MMpull(m);
  int fc = MMget(m, 0);
  if ((fc == NIL) || (ff == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
  if (widget == 0)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  char* file = MMstartstr(m, MTOP(ff));
  if (file == 0)
  {
    MMechostr(MSKDEBUG, "file is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!strcmp("", file))
  {
    MMechostr(MSKDEBUG, "file is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  try
  {
    widget->LoadFile(std::string(file));
  }
  catch (const Ogre::Exception& e)
  {
    MMechostr(MSKDEBUG, "An error occurs while trying to load a file named \"%s\" on a widget: %s\n", file, e.what());
    MMset(m, 0, NIL);
    return 0;
  }
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3WidgetLoadUrl(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetLoadUrl\n");
#endif
 
  int u = MMpull(m);
  int fc = MMget(m, 0);
  if ((fc == NIL) || (u == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
  if (widget == 0)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  const char* url = MMstartstr(m, MTOP(u));
  if (url == 0)
  {
    MMechostr(MSKDEBUG, "url is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (!strcmp("", url))
  {
    MMechostr(MSKDEBUG, "url is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  try
  {
    widget->LoadURL(std::string(url));
  }
  catch (const Ogre::Exception& e)
  {
    MMechostr(MSKDEBUG, "An error occurs while trying to load an URL to \"%s\"on a widget: %s\n", url, e.what());
    MMset(m, 0, NIL);
    return 0;
  }
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3WidgetDestroy(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetDestroy\n");
#endif
 
  int fc = MMget(m, 0);
  if (fc == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
  if (widget == 0)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  OBJdelTM(m, SO3WIDGET, fc);
 
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetDestroy : OK !\n");
#endif
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3WidgetSetZOrder(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetSetZOrder\n");
#endif
 
  int z = MMpull(m);
  int fc = MMget(m, 0);
  if ((fc == NIL) || (z == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
  if (widget == NULL)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  int val = MTOI(z);
  widget->SetZOrder((unsigned short)val);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3WidgetSetForeground(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetSetForeground\n");
#endif
 
  int b = MMpull(m);
  int fc = MMget(m, 0);
  if ((fc == NIL) || (b == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
  if (widget == NULL)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  bool enable = false;
  if (MTOI(b) == 1)
    enable = true;
 
  widget->SetForeground(enable);
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3WidgetGetForeground(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetGetForeground\n");
#endif
 
  int fc = MMget(m, 0);
  if (fc == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
  if (widget == NULL)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  int val = 0;
  if (widget->GetForeground())
    val = 1;
 
  MMset(m, 0, ITOM(val));
  return 0;
}
 
 
int SO3WidgetSetTopOnFocus(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetSetTopOnFocus\n");
#endif
 
  int b = MMpull(m);
  int fc = MMget(m, 0);
  if ((fc == NIL) || (b == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
  if (widget == NULL)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  bool enable = false;
  if (MTOI(b) == 1)
    enable = true;
 
  widget->SetTopOnFocus(enable);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3WidgetGetTopOnFocus(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetGetTopOnFocus\n");
#endif
 
  int fc = MMget(m, 0);
  if (fc == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
  if (widget == NULL)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  int val = 0;
  if (widget->GetTopOnFocus())
    val = 1;
 
  MMset(m, 0, ITOM(val));
  return 0;
}
 
 
int SO3WidgetSetIgnoreTransparentPixels(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetSetIgnoreTransparentPixels\n");
#endif
 
  int t = MMpull(m);
  int b = MMpull(m);
  int fc = MMget(m, 0);
  if ((fc == NIL) || (b == NIL) || (t == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
  if (widget == NULL)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  bool ignore = false;
  if (MTOI(b) == 1)
    ignore = true;
 
  widget->SetIgnoreTransparentPixels(ignore, MTOF(t));
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3WidgetGetIgnoreTransparentPixels(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetGetIgnoreTransparentPixels\n");
#endif
 
  int fc = MMget(m, 0);
  if (fc == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
  if (widget == NULL)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  float valT = widget->GetIgnoreTransparentPixelsTreshold();
  int valI = 0;
  if (widget->GetIgnoreTransparentPixels())
    valI = 1;
 
 
  int tuple = MMmalloc(m, 2, TYPETAB);
  if (tuple == NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  MMstore(m, tuple, 0, ITOM((int)(valI)));
  MMstore(m, tuple, 1, FTOM((float)(valT)));
  MMset(m, 0, PTOM(tuple));
  return 0;
}
 
 
int SO3WidgetSetFocus(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetSetFocus\n");
#endif
 
  int fc = MMget(m, 0);
  if (fc == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
  if (widget == NULL)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  widget->TakeFocus();
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int SO3WidgetUnFocus(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetSetFocus\n");
#endif
 
  int fc = MMget(m, 0);
  if (fc == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
  if (widget == NULL)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  widget->ReleaseFocus();
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int SO3WidgetGetZOrder(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetGetZOrder\n");
#endif
 
  int fc = MMget(m, 0);
  if (fc == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
  if (widget == NULL)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMset(m, 0, ITOM(static_cast<int> (widget->GetZOrder())));
  return 0;
}
 
 
int SO3WidgetSetPosition(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetSetPosition\n");
#endif
 
  int y = MTOI(MMpull(m));
  int x = MTOI(MMpull(m));
  int fc = MMget(m, 0);
  if ((fc == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
  if (widget == NULL)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  widget->SetPosition(SPoint<int>(x, y));
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3WidgetGetPosition(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetGetPosition\n");
#endif
 
  int fc = MMget(m, 0);
  if (fc == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
  if (widget == NULL)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  int tuple = MMmalloc(m, 2, TYPETAB);
  if (tuple == NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  SPoint<int> currentPosition = widget->GetPosition();
  MMstore(m, tuple, 0, ITOM(currentPosition.x));
  MMstore(m, tuple, 1, ITOM(currentPosition.y));
  MMset(m, 0, PTOM(tuple));
  return 0;
}
 
int SO3WidgetSetTextureRatio(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetSetTextureRatio\n");
#endif
 
  int scolScale = MMpull(m);
  int scolWidget = MMget(m, 0);
  if ((scolWidget == NIL) || (scolScale == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(scolWidget));
  if (widget == NULL)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  float scale = MTOF(scolScale);
  if ((scale <= 0.0f) || (scale > 1.0f))
  {
    MMechostr(MSKDEBUG, "Invalid texture ratio provided!\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  widget->SetTextureRatio(scale);
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int SO3WidgetGetTextureRatio(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetGetTextureRatio\n");
#endif
 
  int scolWidget = MMget(m, 0);
  if (scolWidget == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(scolWidget));
  if (widget == 0)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMset(m, 0, FTOM(widget->GetTextureRatio()));
  return 0;
}
 
int SO3WidgetGetSize(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetGetSize\n");
#endif
 
  int fc = MMget(m, 0);
  if (fc == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
  if (widget == 0)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  int tuple = MMmalloc(m, 2, TYPETAB);
  if (tuple == NIL)
  {
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  MMstore(m, tuple, 0, ITOM((int)(widget->GetWidth())));
  MMstore(m, tuple, 1, ITOM((int)(widget->GetHeight())));
  MMset(m, 0, PTOM(tuple));
  return 0;
}
 
 
int SO3WidgetSetSize(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetSetSize\n");
#endif
 
  int h = MTOI(MMpull(m));
  int w = MTOI(MMpull(m));
  int fc = MMget(m, 0);
  if (fc == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
  if (widget == 0)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  try
  {
    widget->SetSize(abs(w), abs(h));
  }
  catch (Ogre::Exception &e)
  {
    MMechostr(MSKDEBUG, "An exception has occurred: %s\n", e.what());
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3WidgetGetName(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetGetName\n");
#endif
 
  int fc = MMget(m, 0);
  if (fc == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
  if (widget == 0)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMpull(m);
  return Mpushstrbloc(m, (char*)(widget->GetName().c_str()));
}
 
 
int SO3WidgetGetType(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetGetType\n");
#endif
 
  int fc = MMget(m, 0);
  if (fc == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
  if (widget == 0)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMpull(m);
  return Mpushstrbloc(m, (char*)(widget->GetType().c_str()));
}
 
 
int SO3WidgetGetMode(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetGetMode\n");
#endif
 
  int fc = MMget(m, 0);
  if (fc == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
  if (widget == 0)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  int mode = 3;
  if (widget->GetIsOverlayed())
    mode = 1;
  else if (widget->GetIs2DRect())
    mode = 2;
 
  MMset(m, 0, ITOM(mode));
  return 0;
}
 
 
int SO3WidgetSetStereo(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetSetStereo\n");
#endif
 
  int st = MMpull(m);
  int fc = MMget(m, 0);
  if (fc == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
  if (widget == 0)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget::StereoMode state = (st == NIL) ? SWidget::StereoMode::MONO : (SWidget::StereoMode)MTOI(st);
  widget->SetStereo(state);
 
  return 0;
}
 
 
int SO3WidgetGetStereo(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetGetStereo\n");
#endif
 
  int fc = MMget(m, 0);
  if (fc == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
  if (widget == 0)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  int state = widget->GetIsStereo() ? 1 : 0;
 
  MMset(m, 0, ITOM(state));
  return 0;
}
 
 
int SO3WidgetSetStereoEye(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetSetStereoEye\n");
#endif
 
  int ey = MMpull(m);
  int fc = MMget(m, 0);
  if (fc == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
  if (widget == 0)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  bool left = (MTOI(ey) > 0) ? false : true;
  widget->SetStereoEye(left);
 
  return 0;
}
 
 
int SO3WidgetSetVisibility(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetSetVisibility\n");
#endif
  // TODO Improvments: manage fade in/out enable or not, and fade duration.
  int b = MTOI(MMpull(m));
  int fc = MMget(m, 0);
  if (fc == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
  if (widget == NULL)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (b == 0)
    widget->Hide();
  else
    widget->Show();
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3WidgetGetVisibility(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetGetVisibility\n");
#endif
  int fc = MMget(m, 0);
  if (fc == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
  if (widget == NULL)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  int val = 0;
  if (widget->GetVisible())
    val = 1;
 
  MMset(m, 0, ITOM(val));
  return 0;
}
 
 
int SO3WidgetSetKeyboardEnable(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetSetKeyboardEnable\n");
#endif
  int enab = MTOI(MMpull(m));
  int fc = MMget(m, 0);
  if (fc == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
  if (widget == NULL)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  bool enable = false;
  if (enab == 1)
    enable = true;
 
  widget->SetKeyboardEnable(enable);
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3WidgetGetKeyboardEnable(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetGetKeyboardEnable\n");
#endif
  int fc = MMget(m, 0);
  if (fc == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
  if (widget == NULL)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  int val = 0;
  if (widget->GetKeyboardEnable())
    val = 1;
 
  MMset(m, 0, ITOM(val));
  return 0;
}
 
 
int SO3WidgetSetMouseEnable(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetSetMouseEnable\n");
#endif
  int enab = MTOI(MMpull(m));
  int fc = MMget(m, 0);
  if (fc == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
  if (widget == NULL)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  bool enable = false;
  if (enab == 1)
    enable = true;
 
  widget->SetMouseEnable(enable);
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3WidgetGetMouseEnable(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetGetMouseEnable\n");
#endif
  int fc = MMget(m, 0);
  if (fc == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
  if (widget == NULL)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  int val = 0;
  if (widget->GetMouseEnable())
    val = 1;
 
  MMset(m, 0, ITOM(val));
  return 0;
}
 
 
int SO3WidgetIsMouseOver(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetIsMouseOver\n");
#endif
 
  int fc = MMget(m, 0);
  if (fc == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
  if (widget == NULL)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  int val = 0;
  if (widget->GetMouseOver())
    val = 1;
 
  MMset(m, 0, ITOM(val));
  return 0;
}
 
 
int SO3WidgetSetTransparency(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetSetTransparency\n");
#endif
 
  int b = MMpull(m);
  int fc = MMget(m, 0);
  if ((fc == NIL) || (b == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
  if (widget == NULL)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  bool val = false;
  if (MTOI(b) == 1)
    val = true;
 
  widget->SetTransparency(val);
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3WidgetGetTransparency(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetGetTransparency\n");
#endif
 
  int fc = MMget(m, 0);
  if (fc == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
  if (widget == NULL)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  int val = 0;
  if (widget->GetTransparency())
    val = 1;
 
  MMset(m, 0, ITOM(val));
  return 0;
}
 
 
int SO3WidgetSetOpacity(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetSetOpacity\n");
#endif
 
  int opacity = MMpull(m);
  int fc = MMget(m, 0);
  if ((fc == NIL) || (opacity == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
  if (widget == NULL)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  widget->SetOpacity(MTOF(opacity));
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3WidgetGetOpacity(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetGetOpacity\n");
#endif
 
  int fc = MMget(m, 0);
  if (fc == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
  if (widget == NULL)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMset(m, 0, FTOM(widget->GetOpacity()));
  return 0;
}
 
 
int SO3WidgetHasFocus(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetHasFocus\n");
#endif
 
  int fc = MMget(m, 0);
  if (fc == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
  if (widget == NULL)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  int val = 0;
  if (widget->HasFocus())
    val = 1;
 
  MMset(m, 0, ITOM(val));
  return 0;
}
 
 
int SO3WidgetCallFunction(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetCallFunction\n");
#endif
 
  int list = MTOP(MMpull(m));
  int f = MMpull(m);
  int fc = MMget(m, 0);
  if ((fc == NIL) || (f == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
  if (widget == NULL)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  // Get function name
  std::string asFunc(MMstartstr(m, MTOP(f)));
 
  // Get funtion's parameters
  std::vector<std::string> argVec;
  int curPointer;
  while (list != NIL)
  {
    curPointer = MTOP(MMfetch(m, list, 0));
    if (curPointer != NIL)
    {
      std::string argumentStr(MMstartstr(m, curPointer));
      argVec.push_back(argumentStr);
      list = MTOP(MMfetch(m, list, 1));
    }
  }
 
  // Call function with parameters.
  try
  {
    widget->RunScriptFunction(asFunc, argVec);
  }
  catch (Ogre::Exception &e)
  {
    MMechostr(MSKRUNTIME, "An exception has occurred: %s\n", e.what());
    MMset(m, 0, NIL);
    return 0;
  }
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
int SO3WidgetGetUpdateOnFocusOnly(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetGetUpdateOnFocusOnly\n");
#endif
 
  int scolWidget = MMget(m, 0);
  if (scolWidget == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(scolWidget));
  if (widget == NULL)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (widget->GetUpdateOnFocusOnly())
    MMset(m, 0, ITOM(1));
  else
    MMset(m, 0, ITOM(0));
  return 0;
}
 
int SO3WidgetSetUpdateOnFocusOnly(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetSetUpdateOnFocusOnly\n");
#endif
 
  int scolActivateOnFocusOnly = MMpull(m);
  int scolWidget = MMget(m, 0);
  if ((scolWidget == NIL) || (scolActivateOnFocusOnly == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(scolWidget));
  if (widget == NULL)
  {
    MMechostr(MSKDEBUG, "widget instance is NULL \n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  bool activateOnFocusOnly = false;
  if (MTOI(scolActivateOnFocusOnly) == 1)
    activateOnFocusOnly = true;
 
  widget->SetUpdateOnFocusOnly(activateOnFocusOnly);
  return 0;
}
 
int SO3WidgetEnterEventCb(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetEnterEventCb\n");
#endif
 
  return OBJaddreflex(m, SO3WIDGET, SO3_WIDGET_ENTER_EVENT);
}
 
 
int SO3WidgetExitEventCb(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetExitEventCb\n");
#endif
 
  return OBJaddreflex(m, SO3WIDGET, SO3_WIDGET_EXIT_EVENT);
}
 
 
int SO3WidgetMouseMoveEventCb(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetMouseMoveEventCb\n");
#endif
 
  return OBJaddreflex(m, SO3WIDGET, SO3_WIDGET_MOUSE_MOVE_EVENT);
}
 
 
int SO3WidgetMouseDownEventCb(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetMouseDownEventCb\n");
#endif
 
  return OBJaddreflex(m, SO3WIDGET, SO3_WIDGET_MOUSE_DOWN_EVENT);
}
 
 
int SO3WidgetMouseUpEventCb(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetMouseUpEventCb\n");
#endif
 
  return OBJaddreflex(m, SO3WIDGET, SO3_WIDGET_MOUSE_UP_EVENT);
}
 
 
int SO3WidgetMouseWheelEventCb(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetMouseWheelEventCb\n");
#endif
 
  return OBJaddreflex(m, SO3WIDGET, SO3_WIDGET_MOUSEWHEEL_EVENT);
}
 
 
int SO3WidgetTouchAddEventCb(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetTouchAddEventCb\n");
#endif
 
  return OBJaddreflex(m, SO3WIDGET, SO3_WIDGET_TOUCH_ADD_EVENT);
}
 
 
int SO3WidgetTouchRemoveEventCb(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetTouchRemoveEventCb\n");
#endif
 
  return OBJaddreflex(m, SO3WIDGET, SO3_WIDGET_TOUCH_REMOVE_EVENT);
}
 
 
int SO3WidgetTouchUpdateEventCb(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetTouchUpdateEventCb\n");
#endif
 
  return OBJaddreflex(m, SO3WIDGET, SO3_WIDGET_TOUCH_UPDATE_EVENT);
}
 
 
int SO3WidgetInputDownEventCb(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetInputDownEventCb\n");
#endif
 
  return OBJaddreflex(m, SO3WIDGET, SO3_WIDGET_INPUT_DOWN_EVENT);
}
 
 
int SO3WidgetInputUpEventCb(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetInputUpEventCb\n");
#endif
 
  return OBJaddreflex(m, SO3WIDGET, SO3_WIDGET_INPUT_UP_EVENT);
}
 
 
int SO3WidgetInputUpdateEventCb(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetInputUpdateEventCb\n");
#endif
 
  return OBJaddreflex(m, SO3WIDGET, SO3_WIDGET_INPUT_UPDATE_EVENT);
}
 
 
int SO3WidgetInputWheelEventCb(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetInputWheelEventCb\n");
#endif
 
  return OBJaddreflex(m, SO3WIDGET, SO3_WIDGET_INPUT_WHEEL_EVENT);
}
 
 
int SO3WidgetKeyDownEventCb(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetKeyDownEventCb\n");
#endif
 
  return OBJaddreflex(m, SO3WIDGET, SO3_WIDGET_KEY_DOWN_EVENT);
}
 
 
int SO3WidgetKeyUpEventCb(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetKeyUpEventCb\n");
#endif
 
  return OBJaddreflex(m, SO3WIDGET, SO3_WIDGET_KEY_UP_EVENT);
}
 
 
int SO3WidgetKeyEventCb(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetKeyEventCb\n");
#endif
 
  return OBJaddreflex(m, SO3WIDGET, SO3_WIDGET_KEY_EVENT);
}
 
int SO3WidgetFocusEventCb(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetFocusEventCb\n");
#endif
 
  return OBJaddreflex(m, SO3WIDGET, SO3_WIDGET_FOCUS_EVENT);
}
 
int SO3WidgetOnScriptEventCb(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetOnScriptEventCb\n");
#endif
 
  return OBJaddreflex(m, SO3WIDGET, SO3_WIDGET_SCRIPT_EVENT);
}
 
int SO3WidgetOnLoadStartEventCb(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetOnLoadStartEventCb\n");
#endif
 
  return OBJaddreflex(m, SO3WIDGET, SO3_WIDGET_ON_LOAD_START_EVENT);
}
 
int SO3WidgetOnLoadEndEventCb(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetOnLoadEndEventCb\n");
#endif
 
  return OBJaddreflex(m, SO3WIDGET, SO3_WIDGET_ON_LOAD_END_EVENT);
}
 
int SO3WidgetOnLoadErrorEventCb(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3WidgetOnLoadErrorEventCb\n");
#endif
 
  return OBJaddreflex(m, SO3WIDGET, SO3_WIDGET_ON_LOAD_ERROR_EVENT);
}
 
 
NativeDefinition natSO3Widget[] = {
  { "SO3WidgetGetType",                    1,  "fun [SO3_WIDGET] S",                                              SO3WidgetGetType                    },
  { "SO3WidgetGetMode",                    1,  "fun [SO3_WIDGET] I",                                              SO3WidgetGetMode                    },
  { "SO3WidgetSetStereo",                  2,  "fun [SO3_WIDGET I] SO3_WIDGET",                                   SO3WidgetSetStereo                  },
  { "SO3WidgetGetStereo",                  1,  "fun [SO3_WIDGET] I",                                              SO3WidgetGetStereo                  },
  { "SO3WidgetSetStereoEye",               2,  "fun [SO3_WIDGET I] SO3_WIDGET",                                   SO3WidgetSetStereoEye               },
  { "SO3WidgetLoadFile",                   2,  "fun [SO3_WIDGET P] I",                                                                                                                                                  SO3WidgetLoadFile                   },
  { "SO3WidgetLoadUrl",                    2,  "fun [SO3_WIDGET S] I",                                                                                                                                                  SO3WidgetLoadUrl                    },
  { "SO3WidgetDestroy",                    1,  "fun [SO3_WIDGET] I",                                                                                                                                                      SO3WidgetDestroy                    },
  { "SO3WidgetSetSize",                    3,  "fun [SO3_WIDGET I I] I",                                                                                                                                                SO3WidgetSetSize                    },
  { "SO3WidgetGetSize",                    1,  "fun [SO3_WIDGET] [I I]",                                                                                                                                                SO3WidgetGetSize                    },
  { "SO3WidgetSetPosition",                3,  "fun [SO3_WIDGET I I] I",                                          SO3WidgetSetPosition                },
  { "SO3WidgetGetPosition",                1,  "fun [SO3_WIDGET] [I I]",                                          SO3WidgetGetPosition                },
  { "SO3WidgetSetTextureRatio",            2,  "fun [SO3_WIDGET F] I",                                            SO3WidgetSetTextureRatio            },
  { "SO3WidgetGetTextureRatio",            1,  "fun [SO3_WIDGET] F",                                              SO3WidgetGetTextureRatio            },
  { "SO3WidgetGetName",                    1,  "fun [SO3_WIDGET] S",                                                                                                                                                      SO3WidgetGetName                    },
  { "SO3WidgetGetVisibility",              1,  "fun [SO3_WIDGET] I",                                              SO3WidgetGetVisibility              },
  { "SO3WidgetSetVisibility",              2,  "fun [SO3_WIDGET I] I",                                            SO3WidgetSetVisibility              },
  { "SO3WidgetGetTransparency",            1,  "fun [SO3_WIDGET] I",                                              SO3WidgetGetTransparency            },
  { "SO3WidgetSetTransparency",            2,  "fun [SO3_WIDGET I] I",                                            SO3WidgetSetTransparency            },
  { "SO3WidgetGetOpacity",                 1,  "fun [SO3_WIDGET] F",                                              SO3WidgetGetOpacity                 },
  { "SO3WidgetSetOpacity",                 2,  "fun [SO3_WIDGET F] I",                                            SO3WidgetSetOpacity                 },
  { "SO3WidgetGetIgnoreTransparentPixels", 1,  "fun [SO3_WIDGET] [I I]",                                          SO3WidgetGetIgnoreTransparentPixels },
  { "SO3WidgetSetIgnoreTransparentPixels", 3,  "fun [SO3_WIDGET I I] I",                                          SO3WidgetSetIgnoreTransparentPixels },
  { "SO3WidgetGetZOrder",                  1,  "fun [SO3_WIDGET] I",                                              SO3WidgetGetZOrder                  },
  { "SO3WidgetSetZOrder",                  2,  "fun [SO3_WIDGET  I] I",                                           SO3WidgetSetZOrder                  },
  { "SO3WidgetGetForeground",              1,  "fun [SO3_WIDGET] I",                                              SO3WidgetGetForeground              },
  { "SO3WidgetSetForeground",              2,  "fun [SO3_WIDGET I] I",                                            SO3WidgetSetForeground              },
  { "SO3WidgetHasFocus",                   1,  "fun [SO3_WIDGET] I",                                              SO3WidgetHasFocus                   },
  { "SO3WidgetSetFocus",                   1,  "fun [SO3_WIDGET] I",                                              SO3WidgetSetFocus                   },
  { "SO3WidgetUnFocus",                    1,  "fun [SO3_WIDGET] I",                                              SO3WidgetUnFocus                    },
  { "SO3WidgetGetTopOnFocus",              1,  "fun [SO3_WIDGET] I",                                              SO3WidgetGetTopOnFocus              },
  { "SO3WidgetSetTopOnFocus",              2,  "fun [SO3_WIDGET I] I",                                            SO3WidgetSetTopOnFocus              },
  { "SO3WidgetGetKeyboardEnable",          1,  "fun [SO3_WIDGET] I",                                              SO3WidgetGetKeyboardEnable          },
  { "SO3WidgetSetKeyboardEnable",          2,  "fun [SO3_WIDGET I] I",                                            SO3WidgetSetKeyboardEnable          },
  { "SO3WidgetGetMouseEnable",             1,  "fun [SO3_WIDGET] I",                                              SO3WidgetGetMouseEnable             },
  { "SO3WidgetSetMouseEnable",             2,  "fun [SO3_WIDGET I] I",                                            SO3WidgetSetMouseEnable             },
  { "SO3WidgetIsMouseOver",                1,  "fun [SO3_WIDGET] I",                                              SO3WidgetIsMouseOver                },
  { "SO3WidgetCallFunction",               3,  "fun [SO3_WIDGET S [S r1]] I",                                     SO3WidgetCallFunction               },
  { "SO3WidgetGetUpdateOnFocusOnly",       1,  "fun [SO3_WIDGET] I",                                              SO3WidgetGetUpdateOnFocusOnly       },
  { "SO3WidgetSetUpdateOnFocusOnly",       2,  "fun [SO3_WIDGET I] I",                                            SO3WidgetSetUpdateOnFocusOnly       },
  { "SO3WidgetEnterEventCb",               3,  "fun [SO3_WIDGET fun [SO3_WIDGET u0] u1 u0] SO3_WIDGET",                                   SO3WidgetEnterEventCb               },
  { "SO3WidgetExitEventCb",                3,  "fun [SO3_WIDGET fun [SO3_WIDGET u0] u1 u0] SO3_WIDGET",                                   SO3WidgetExitEventCb                },
  { "SO3WidgetMouseMoveEventCb",           3,  "fun [SO3_WIDGET fun [SO3_WIDGET u0 I I I] u1 u0] SO3_WIDGET",             SO3WidgetMouseMoveEventCb           },
  { "SO3WidgetMouseDownEventCb",           3,  "fun [SO3_WIDGET fun [SO3_WIDGET u0 I I I] u1 u0] SO3_WIDGET",             SO3WidgetMouseDownEventCb           },
  { "SO3WidgetMouseUpEventCb",             3,  "fun [SO3_WIDGET fun [SO3_WIDGET u0 I I I] u1 u0] SO3_WIDGET",             SO3WidgetMouseUpEventCb             },
  { "SO3WidgetMouseWheelEventCb",          3,  "fun [SO3_WIDGET fun [SO3_WIDGET u0 I I I] u1 u0] SO3_WIDGET",     SO3WidgetMouseWheelEventCb          },
  { "SO3WidgetTouchAddEventCb",            3,  "fun [SO3_WIDGET fun [SO3_WIDGET u0 I I I] u1 u0] SO3_WIDGET",             SO3WidgetTouchAddEventCb            },
  { "SO3WidgetTouchRemoveEventCb",         3,  "fun [SO3_WIDGET fun [SO3_WIDGET u0 I I I] u1 u0] SO3_WIDGET",             SO3WidgetTouchRemoveEventCb         },
  { "SO3WidgetTouchUpdateEventCb",         3,  "fun [SO3_WIDGET fun [SO3_WIDGET u0 I I I I I] u1 u0] SO3_WIDGET", SO3WidgetTouchUpdateEventCb         },
  { "SO3WidgetInputDownEventCb",           3,  "fun [SO3_WIDGET fun [SO3_WIDGET u0 I I I I] u1 u0] SO3_WIDGET",   SO3WidgetInputDownEventCb           },
  { "SO3WidgetInputUpEventCb",             3,  "fun [SO3_WIDGET fun [SO3_WIDGET u0 I I I I] u1 u0] SO3_WIDGET",         SO3WidgetInputUpEventCb             },
  { "SO3WidgetInputUpdateEventCb",         3,  "fun [SO3_WIDGET fun [SO3_WIDGET u0 I I I I] u1 u0] SO3_WIDGET",   SO3WidgetInputUpdateEventCb         },
  { "SO3WidgetInputWheelEventCb",          3,  "fun [SO3_WIDGET fun [SO3_WIDGET u0 I I I I] u1 u0] SO3_WIDGET",   SO3WidgetInputWheelEventCb          },
  { "SO3WidgetKeyDownEventCb",             3,  "fun [SO3_WIDGET fun [SO3_WIDGET u0 I I] u1 u0] SO3_WIDGET",                 SO3WidgetKeyDownEventCb             },
  { "SO3WidgetKeyUpEventCb",               3,  "fun [SO3_WIDGET fun [SO3_WIDGET u0 I] u1 u0] SO3_WIDGET",                     SO3WidgetKeyUpEventCb               },
  { "SO3WidgetKeyEventCb",                 3,  "fun [SO3_WIDGET fun [SO3_WIDGET u0 I I I] u1 u0] SO3_WIDGET",     SO3WidgetKeyEventCb                 },
  { "SO3WidgetFocusEventCb",               3,  "fun [SO3_WIDGET fun [SO3_WIDGET u0 I] u1 u0] SO3_WIDGET",                     SO3WidgetFocusEventCb               },
  { "SO3WidgetOnScriptEventCb",            3,  "fun [SO3_WIDGET fun [SO3_WIDGET u0 S [S r1]] u1 u0] SO3_WIDGET",  SO3WidgetOnScriptEventCb            },
  { "SO3WidgetOnLoadStartEventCb",         3,  "fun [SO3_WIDGET fun [SO3_WIDGET u0] u1 u0] SO3_WIDGET",           SO3WidgetOnLoadStartEventCb         },
  { "SO3WidgetOnLoadEndEventCb",           3,  "fun [SO3_WIDGET fun [SO3_WIDGET u0] u1 u0] SO3_WIDGET",           SO3WidgetOnLoadEndEventCb           },
  { "SO3WidgetOnLoadErrorEventCb",         3,  "fun [SO3_WIDGET fun [SO3_WIDGET u0 S] u1 u0] SO3_WIDGET",         SO3WidgetOnLoadErrorEventCb         }
};
 
 
ScolWidgetEventsListener* scolWidgetEventsListener = 0;
 
 
int SCOLloadWidget(mmachine m, cbmachine w)
{
  //ANDROID TODO manage window destruction
  scolWidgetEventsListener = new ScolWidgetEventsListener();
  assert(scolWidgetEventsListener != 0);
  SWidgetManager::getSingleton().AddWidgetListener(scolWidgetEventsListener);
 
  WIDGET_SCRIPT_EVENT = OBJgetUserEvent();
  OBJdefEvent(WIDGET_SCRIPT_EVENT, getWidgetCallbackOnScriptCallback);
 
  WIDGET_ENTER_EVENT = OBJgetUserEvent();
  OBJdefEvent(WIDGET_ENTER_EVENT, getWidgetCallbackOnEnterEvent);
 
  WIDGET_EXIT_EVENT = OBJgetUserEvent();
  OBJdefEvent(WIDGET_EXIT_EVENT, getWidgetCallbackOnExitEvent);
 
  WIDGET_MOUSEDOWN_EVENT = OBJgetUserEvent();
  OBJdefEvent(WIDGET_MOUSEDOWN_EVENT, getWidgetCallbackMouseDownEvent);
 
  WIDGET_MOUSEUP_EVENT = OBJgetUserEvent();
  OBJdefEvent(WIDGET_MOUSEUP_EVENT, getWidgetCallbackMouseUpEvent);
 
  WIDGET_MOUSEMOVE_EVENT = OBJgetUserEvent();
  OBJdefEvent(WIDGET_MOUSEMOVE_EVENT, getWidgetCallbackMouseMoveEvent);
 
  WIDGET_MOUSEWHEEL_EVENT = OBJgetUserEvent();
  OBJdefEvent(WIDGET_MOUSEWHEEL_EVENT, getWidgetCallbackMouseWheelEvent); 
 
  WIDGET_TOUCHADD_EVENT = OBJgetUserEvent();
  OBJdefEvent(WIDGET_TOUCHADD_EVENT, getWidgetCallbackTouchAddEvent);
 
  WIDGET_TOUCHREMOVE_EVENT = OBJgetUserEvent();
  OBJdefEvent(WIDGET_TOUCHREMOVE_EVENT, getWidgetCallbackTouchRemoveEvent);
 
  WIDGET_TOUCHUPDATE_EVENT = OBJgetUserEvent();
  OBJdefEvent(WIDGET_TOUCHUPDATE_EVENT, getWidgetCallbackTouchUpdateEvent);
 
  WIDGET_INPUTDOWN_EVENT = OBJgetUserEvent();
  OBJdefEvent(WIDGET_INPUTDOWN_EVENT, getWidgetCallbackInputDownEvent);
 
  WIDGET_INPUTUP_EVENT = OBJgetUserEvent();
  OBJdefEvent(WIDGET_INPUTUP_EVENT, getWidgetCallbackInputUpEvent);
 
  WIDGET_INPUTUPDATE_EVENT = OBJgetUserEvent();
  OBJdefEvent(WIDGET_INPUTUPDATE_EVENT, getWidgetCallbackInputUpdateEvent);
 
  WIDGET_INPUTWHEEL_EVENT = OBJgetUserEvent();
  OBJdefEvent(WIDGET_INPUTWHEEL_EVENT, getWidgetCallbackInputWheelEvent);
 
  WIDGET_KEY_DOWN_EVENT = OBJgetUserEvent();
  OBJdefEvent(WIDGET_KEY_DOWN_EVENT, getWidgetCallbackKeyDownEvent);
 
  WIDGET_KEY_UP_EVENT = OBJgetUserEvent();
  OBJdefEvent(WIDGET_KEY_UP_EVENT, getWidgetCallbackKeyUpEvent);
 
  WIDGET_KEY_EVENT = OBJgetUserEvent();
  OBJdefEvent(WIDGET_KEY_EVENT, getWidgetCallbackKeyEvent);
 
  WIDGET_FOCUS_EVENT = OBJgetUserEvent();
  OBJdefEvent(WIDGET_FOCUS_EVENT, getWidgetCallbackFocusEvent);
 
  WIDGET_ON_LOAD_START_EVENT = OBJgetUserEvent();
  OBJdefEvent(WIDGET_ON_LOAD_START_EVENT, getWidgetCallbackOnLoadStartEvent);
 
  WIDGET_ON_LOAD_END_EVENT = OBJgetUserEvent();
  OBJdefEvent(WIDGET_ON_LOAD_END_EVENT, getWidgetCallbackOnLoadEndEvent);
 
  WIDGET_ON_LOAD_ERROR_EVENT = OBJgetUserEvent();
  OBJdefEvent(WIDGET_ON_LOAD_ERROR_EVENT, getWidgetCallbackOnLoadErrorEvent);
 
  return PKhardpak2(m, "SO3Widget.pkg", sizeof(natSO3Widget) / sizeof(natSO3Widget[0]), natSO3Widget);
}
 
 
int SCOLfreeWidget()
{
  SWidgetManager::getSingleton().RemoveWidgetListener(scolWidgetEventsListener);
 
  try
  {
    SO3_SAFE_DELETE(scolWidgetEventsListener);
  }
  catch(Ogre::Exception &)
  {
 
  }
  return 0;
}