/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com

Copyright (c) 2011 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 "embeddedWebNavigatorManager.h"
#include "embeddedWebNavigator.h"
#include "scolEmbeddedWebNavigator.h"
#include "scolEmbeddedWebNavigatorDisplay.h"
#include "scolEmbeddedWebNavigatorFind.h"
#include "scolEmbeddedWebNavigatorV8ContextHandler.h"
#include "scolEmbeddedWebNavigatorLoad.h"
#include "scolEmbeddedWebNavigatorLifeSpan.h"

// Scol machine declaration for MM macros
cbmachine ww;
ScolWindowHandle HScol = NULL;	

// Object type variable declaration
int OBJWEBNAVIGATORSCOL;

// Windows messages variables declarations for asynchronous reflexives calls
int WEB_NAVIGATOR_LIFESPAN_ON_POPUP_WINMSG           = 0;
int WEB_NAVIGATOR_LIFESPAN_RUN_MODAL_WINMSG          = 0;
int WEB_NAVIGATOR_LIFESPAN_ON_BEFORE_CLOSE_WINMSG    = 0;
int WEB_NAVIGATOR_LOAD_ON_START_WINMSG               = 0;
int WEB_NAVIGATOR_LOAD_ON_END_WINMSG                 = 0;
int WEB_NAVIGATOR_LOAD_ON_ERROR_WINMSG               = 0;
int WEB_NAVIGATOR_DISPLAY_ON_NAV_STATE_CHANGE_WINMSG = 0;
int WEB_NAVIGATOR_DISPLAY_ON_ADDRESS_CHANGE_WINMSG   = 0;
int WEB_NAVIGATOR_DISPLAY_ON_TITLE_CHANGE_WINMSG     = 0;
int WEB_NAVIGATOR_DISPLAY_ON_TOOLTIP_WINMSG          = 0;
int WEB_NAVIGATOR_DISPLAY_ON_STATUS_MESSAGE_WINMSG   = 0;
int WEB_NAVIGATOR_DISPLAY_ON_CONSOLE_MESSAGE_WINMSG  = 0;
int WEB_NAVIGATOR_FIND_ON_RESULT_WINMSG              = 0;
int WEB_NAVIGATOR_JS_ON_EXTERNAL_CALL_WINMSG         = 0;
int WEB_NAVIGATOR_JS_ON_EXTERNAL_STR_CALL_WINMSG     = 0;

// Web navigator manager instance.
Scol::EmbeddedWebNavigator::WebNavigatorManager* webNavigatorManager;

/**
 * Scol CallBack for ObjWebNavigator destruction
 */
int destroyWebNavigatorObj(mmachine m, int handsys, int webNavigatorIndex) 
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "destroyWebNavigatorObj\n");
#endif

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }

  webNavigatorManager->DestroyNavigator(webNavigator);
  MMstore(m, MTOP(webNavigatorIndex), 0, NULL);
  return 0;
}

int WebNavigatorCreate(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorCreate\n");
#endif

  // Get parameters
  int scolUrl = MMpull(m);
  int scolHeight = MMpull(m);
  int scolWidth = MMpull(m);
  int scolPositionX = MMpull(m);
  int scolPositionY = MMpull(m);
  int scolParentWindow = MMpull(m);
  int scolChannel = MMget(m, 0);
  if ((scolChannel == NIL)||(scolParentWindow == NIL)||(scolPositionY==NIL)||(scolPositionX==NIL)||(scolWidth==NIL)||(scolHeight==NIL))
  { 
    MMechostr(MSKDEBUG, "WebNavigatorCreate: Invalid parameters!\n");	//Display Warning in Console
    MMset(m, 0, NIL);
    return 0;
  }

  // Get the parent window handle, and check that it's a valid one.
  PtrObjVoid OB = (PtrObjVoid) MMstart(m, MTOP(scolParentWindow));
  PtrObjWindow W = (PtrObjWindow) MMstart(m, OB->Buffer>>1);
  ScolWindowHandle parentWindowHandle = (ScolWindowHandle) W->WHandler;
  if(parentWindowHandle == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }

  // Load url
  std::string url = "";
  if(scolUrl != NIL)
    url = MMstartstr(m, MTOP(scolUrl));

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = webNavigatorManager->CreateNavigator(parentWindowHandle, MTOI(scolPositionY), MTOI(scolPositionY), MTOI(scolWidth), MTOI(scolHeight), url);
  if(webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorCreate: Error while creating a new embedded web navigator\n");
    MMset(m, 0, NIL);
    return 0;
  }

  // stack : channel
  int magmaNavigatorPointer = MMmalloc(m, 1, TYPETAB);
  if(magmaNavigatorPointer==NIL)	
  {
    webNavigatorManager->DestroyNavigator(webNavigator);
    return MERRMEM;
  }

  MMstore(m, magmaNavigatorPointer, 0, (int)webNavigator);
  MMpush(m, PTOM(magmaNavigatorPointer));

  // Create scol object
  return OBJcreate(m, OBJWEBNAVIGATORSCOL, (int)webNavigator, OBJtypebyname("OBJTYPWINDOW"), (int)parentWindowHandle);
}

int WebNavigatorCreateOffscreen(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorCreateOffscreen\n");
#endif

  // Get parameters
  int scolUrl = MMpull(m);
  int scolTransparency = MMpull(m);
  int scolHeight = MMpull(m);
  int scolWidth = MMpull(m);
  int scolParentWindow = MMpull(m);
  int scolChannel = MMget(m, 0);
  if ((scolChannel == NIL)||(scolWidth==NIL)||(scolHeight==NIL))
  { 
    MMechostr(MSKDEBUG, "WebNavigatorCreateOffscreen: Invalid parameters!\n");	//Display Warning in Console
    MMset(m, 0, NIL);
    return 0;
  }

  // Get the parent window handle, could be 0
  ScolWindowHandle parentWindowHandle = 0;
  if(scolParentWindow != NIL)
  {
    PtrObjVoid OB = (PtrObjVoid) MMstart(m, MTOP(scolParentWindow));
    PtrObjWindow W = (PtrObjWindow) MMstart(m, OB->Buffer>>1);
    parentWindowHandle = (ScolWindowHandle) W->WHandler;
    if(parentWindowHandle == 0)
    {
      MMset(m, 0, NIL);
      return 0;
    }
  }

  bool transparency = false;
  if(MTOI(scolTransparency) == 1)
    transparency = true;

  // Load url
  std::string url = "";
  if(scolUrl != NIL)
    url = MMstartstr(m, MTOP(scolUrl));

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = webNavigatorManager->CreateNavigator(parentWindowHandle, MTOI(scolWidth), MTOI(scolHeight), url, transparency);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorCreateOffscreen: Error while creating a new embedded web navigator\n");
    MMset(m, 0, NIL);
    return 0;
  }

  // stack : channel
  int magmaNavigatorPointer = MMmalloc(m, 1, TYPETAB);
  if(magmaNavigatorPointer==NIL)	
  {
    webNavigatorManager->DestroyNavigator(webNavigator);
    return MERRMEM;
  }

  MMstore(m, magmaNavigatorPointer, 0, (int)webNavigator);
  MMpush(m, PTOM(magmaNavigatorPointer));

  // Create scol object
  return OBJcreate(m, OBJWEBNAVIGATORSCOL, (int)webNavigator, OBJtypebyname("OBJTYPWINDOW"), (int)parentWindowHandle);
}

int WebNavigatorDestroy(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorDestroy\n");
#endif

  int webNavigatorIndex = MMget(m, 0);
  if(webNavigatorIndex==NIL)
  {
    MMechostr(MSKDEBUG, "WebNavigatorDestroy: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  OBJdelTM(m, OBJWEBNAVIGATORSCOL, webNavigatorIndex);
  MMset(m, 0, 0);

#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG,"ok\n");
#endif
  return 0;
}

int WebNavigatorLoadURL(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorLoadURL\n");
#endif

  int scolFrameName = MMpull(m);
  int scolUrl = MMpull(m);
  int webNavigatorIndex = MMget(m, 0);
  if ((webNavigatorIndex == NIL)||(scolUrl==NIL))
  {
    MMechostr(MSKDEBUG, "WebNavigatorLoadURL: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorLoadURL: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  // Get the url to load
  std::string url = MMstartstr(m, MTOP(scolUrl));

  // Get the optional frame name
  std::string frameName = "";
  if(scolFrameName != NIL)
    frameName = MMstartstr(m, MTOP(scolFrameName));

  webNavigator->LoadURL(url, frameName);
  MMset(m, 0, ITOM(1));
  return 0;
}

int WebNavigatorLoadFile(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorLoadFile\n");
#endif

  int scolFrameName = MMpull(m);
  int scolFileName = MMpull(m);
  int webNavigatorIndex = MMget(m, 0);
  if ((webNavigatorIndex == NIL)||(scolFileName==NIL))
  {
    MMechostr(MSKDEBUG, "WebNavigatorLoadFile: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorLoadFile: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  // Get the name of the file to load
  std::string fileName = MMstartstr(m, MTOP(scolFileName));

  // Get the optional frame name
  std::string frameName = "";
  if(scolFrameName != NIL)
    frameName = MMstartstr(m, MTOP(scolFrameName));

  webNavigator->LoadFile(fileName, frameName);
  MMset(m, 0, ITOM(1));
  return 0;
}

int WebNavigatorLoadHTML(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorLoadHTML\n");
#endif

  int scolFrameName = MMpull(m);
  int scolHtmlText = MMpull(m);
  int webNavigatorIndex = MMget(m, 0);
  if ((webNavigatorIndex == NIL)||(scolHtmlText==NIL))
  {
    MMechostr(MSKDEBUG, "WebNavigatorLoadHTML: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorLoadHTML: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  // Get the html content to load
  std::string htmlText = MMstartstr(m, MTOP(scolHtmlText));

  // Get the optional frame name
  std::string frameName = "";
  if(scolFrameName != NIL)
    frameName = MMstartstr(m, MTOP(scolFrameName));

  webNavigator->LoadHTML(htmlText, frameName);
  MMset(m, 0, ITOM(1));
  return 0;
}

int WebNavigatorActionUndo(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorActionUndo\n");
#endif

  int scolFrameName = MMpull(m);
  int webNavigatorIndex = MMget(m, 0);
  if (webNavigatorIndex == NIL)
  {
    MMechostr(MSKDEBUG, "WebNavigatorActionUndo: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorActionUndo: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  // Get the optional frame name
  std::string frameName = "";
  if(scolFrameName != NIL)
    frameName = MMstartstr(m, MTOP(scolFrameName));

  webNavigator->Undo(frameName);
  MMset(m, 0, ITOM(1));
  return 0;
}

int WebNavigatorActionRedo(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorActionRedo\n");
#endif

  int scolFrameName = MMpull(m);
  int webNavigatorIndex = MMget(m, 0);
  if (webNavigatorIndex == NIL)
  {
    MMechostr(MSKDEBUG, "WebNavigatorActionRedo: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorActionRedo: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  // Get the optional frame name
  std::string frameName = "";
  if(scolFrameName != NIL)
    frameName = MMstartstr(m, MTOP(scolFrameName));

  webNavigator->Redo(frameName);
  MMset(m, 0, ITOM(1));
  return 0;
}

int WebNavigatorActionCut(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorActionCut\n");
#endif

  int scolFrameName = MMpull(m);
  int webNavigatorIndex = MMget(m, 0);
  if (webNavigatorIndex == NIL)
  {
    MMechostr(MSKDEBUG, "WebNavigatorActionCut: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorActionCut: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  // Get the optional frame name
  std::string frameName = "";
  if(scolFrameName != NIL)
    frameName = MMstartstr(m, MTOP(scolFrameName));

  webNavigator->Cut(frameName);
  MMset(m, 0, ITOM(1));
  return 0;
}

int WebNavigatorActionCopy(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorActionCopy\n");
#endif

  int scolFrameName = MMpull(m);
  int webNavigatorIndex = MMget(m, 0);
  if (webNavigatorIndex == NIL)
  {
    MMechostr(MSKDEBUG, "WebNavigatorActionCopy: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorActionCopy: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  // Get the optional frame name
  std::string frameName = "";
  if(scolFrameName != NIL)
    frameName = MMstartstr(m, MTOP(scolFrameName));

  webNavigator->Copy(frameName);
  MMset(m, 0, ITOM(1));
  return 0;
}

int WebNavigatorActionPaste(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorActionPaste\n");
#endif

  int scolFrameName = MMpull(m);
  int webNavigatorIndex = MMget(m, 0);
  if (webNavigatorIndex == NIL)
  {
    MMechostr(MSKDEBUG, "WebNavigatorActionPaste: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorActionPaste: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  // Get the optional frame name
  std::string frameName = "";
  if(scolFrameName != NIL)
    frameName = MMstartstr(m, MTOP(scolFrameName));

  webNavigator->Paste(frameName);
  MMset(m, 0, ITOM(1));
  return 0;
}

int WebNavigatorActionDelete(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorActionDelete\n");
#endif

  int scolFrameName = MMpull(m);
  int webNavigatorIndex = MMget(m, 0);
  if (webNavigatorIndex == NIL)
  {
    MMechostr(MSKDEBUG, "WebNavigatorActionDelete: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorActionDelete: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  // Get the optional frame name
  std::string frameName = "";
  if(scolFrameName != NIL)
    frameName = MMstartstr(m, MTOP(scolFrameName));

  webNavigator->Delete(frameName);
  MMset(m, 0, ITOM(1));
  return 0;
}

int WebNavigatorActionSelectAll(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorActionSelectAll\n");
#endif

  int scolFrameName = MMpull(m);
  int webNavigatorIndex = MMget(m, 0);
  if (webNavigatorIndex == NIL)
  {
    MMechostr(MSKDEBUG, "WebNavigatorActionSelectAll: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorActionSelectAll: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  // Get the optional frame name
  std::string frameName = "";
  if(scolFrameName != NIL)
    frameName = MMstartstr(m, MTOP(scolFrameName));

  webNavigator->SelectAll(frameName);
  MMset(m, 0, ITOM(1));
  return 0;
}

int WebNavigatorPrint(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorPrint\n");
#endif

  int scolFrameName = MMpull(m);
  int webNavigatorIndex = MMget(m, 0);
  if (webNavigatorIndex == NIL)
  {
    MMechostr(MSKDEBUG, "WebNavigatorPrint: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorPrint: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  // Get the optional frame name
  std::string frameName = "";
  if(scolFrameName != NIL)
    frameName = MMstartstr(m, MTOP(scolFrameName));

  webNavigator->Print(frameName);
  MMset(m, 0, ITOM(1));
  return 0;
}

int WebNavigatorViewSource(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorViewSource\n");
#endif

  int scolFrameName = MMpull(m);
  int webNavigatorIndex = MMget(m, 0);
  if (webNavigatorIndex == NIL)
  {
    MMechostr(MSKDEBUG, "WebNavigatorViewSource: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorViewSource: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  // Get the optional frame name
  std::string frameName = "";
  if(scolFrameName != NIL)
    frameName = MMstartstr(m, MTOP(scolFrameName));

  webNavigator->ViewSource(frameName);
  MMset(m, 0, ITOM(1));
  return 0;
}

int WebNavigatorGetSource(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorGetSource\n");
#endif

  int scolFrameName = MMpull(m);
  int webNavigatorIndex = MMpull(m);
  if (webNavigatorIndex == NIL)
  {
    MMechostr(MSKDEBUG, "WebNavigatorGetSource: Invalid parameters!\n");
    MMpush(m, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorGetSource: Invalid parameters!\n");
    MMpush(m, NIL);
    return 0;
  }

  // Get the optional frame name
  std::string frameName = "";
  if(scolFrameName != NIL)
    frameName = MMstartstr(m, MTOP(scolFrameName));

  std::string frameSource = webNavigator->GetSource(frameName);
  return Mpushstrbloc(m, (char*)(frameSource.c_str()));
  return 0;
}

int WebNavigatorGetText(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorGetText\n");
#endif

  int scolFrameName = MMpull(m);
  int webNavigatorIndex = MMpull(m);
  if (webNavigatorIndex == NIL)
  {
    MMechostr(MSKDEBUG, "WebNavigatorGetText: Invalid parameters!\n");
    MMpush(m, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorGetText: Invalid parameters!\n");
    MMpush(m, NIL);
    return 0;
  }

  // Get the optional frame name
  std::string frameName = "";
  if(scolFrameName != NIL)
    frameName = MMstartstr(m, MTOP(scolFrameName));

  std::string frameText = webNavigator->GetText(frameName);
  return Mpushstrbloc(m, (char*)(frameText.c_str()));
  return 0;
}

int WebNavigatorExecuteJavaScript(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorExecuteJavaScript\n");
#endif

  int scolFrameName = MMpull(m);
  int scolLigneNumber = MMpull(m);
  int scolUrl = MMpull(m);
  int scolJavascript = MMpull(m);
  int webNavigatorIndex = MMget(m, 0);
  if ((webNavigatorIndex == NIL) || (scolJavascript == NIL))
  {
    MMechostr(MSKDEBUG, "WebNavigatorExecuteJavaScript: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorExecuteJavaScript: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  // Get the javascript code
  std::string javascriptCode = MMstartstr(m, MTOP(scolJavascript));

  // Get the optional url
  std::string url = "";
  if(scolUrl != NIL)
    url = MMstartstr(m, MTOP(scolUrl));

  // Get the optional line number
  int ligneNumber = 0;
  if(scolLigneNumber != NIL)
    ligneNumber = MTOI(scolLigneNumber);

  // Get the optional frame name
  std::string frameName = "";
  if(scolFrameName != NIL)
    frameName = MMstartstr(m, MTOP(scolFrameName));

  webNavigator->ExecuteJavaScript(javascriptCode, url, ligneNumber, frameName);
  MMset(m, 0, ITOM(1));
  return 0;
}

int WebNavigatorGetURL(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorGetURL\n");
#endif

  int scolFrameName = MMpull(m);
  int webNavigatorIndex = MMpull(m);
  if (webNavigatorIndex == NIL)
  {
    MMechostr(MSKDEBUG, "WebNavigatorGetURL: Invalid parameters!\n");
    MMpush(m, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorGetURL: Invalid parameters!\n");
    MMpush(m, NIL);
    return 0;
  }

  // Get the optional frame name
  std::string frameName = "";
  if(scolFrameName != NIL)
    frameName = MMstartstr(m, MTOP(scolFrameName));

  std::string url = webNavigator->GetURL(frameName);
  return Mpushstrbloc(m, (char*)(url.c_str()));
  return 0;
}

int WebNavigatorCanGoBack(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorCanGoBack\n");
#endif

  int webNavigatorIndex = MMget(m, 0);
  if (webNavigatorIndex == NIL)
  {
    MMechostr(MSKDEBUG, "WebNavigatorCanGoBack: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorCanGoBack: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  if(webNavigator->CanGoBack())
    MMset(m, 0, ITOM(1));
  else
    MMset(m, 0, ITOM(0));
  return 0;
}

int WebNavigatorGoBack(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorGoBack\n");
#endif

  int webNavigatorIndex = MMget(m, 0);
  if (webNavigatorIndex == NIL)
  {
    MMechostr(MSKDEBUG, "WebNavigatorGoBack: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorGoBack: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  webNavigator->GoBack();
  MMset(m, 0, ITOM(1));
  return 0;
}

int WebNavigatorCanGoForward(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorCanGoForward\n");
#endif

  int webNavigatorIndex = MMget(m, 0);
  if (webNavigatorIndex == NIL)
  {
    MMechostr(MSKDEBUG, "WebNavigatorCanGoForward: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorCanGoForward: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  if(webNavigator->CanGoForward())
    MMset(m, 0, ITOM(1));
  else
    MMset(m, 0, ITOM(0));
  return 0;
}

int WebNavigatorGoForward(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorGoForward\n");
#endif

  int webNavigatorIndex = MMget(m, 0);
  if (webNavigatorIndex == NIL)
  {
    MMechostr(MSKDEBUG, "WebNavigatorGoForward: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorGoForward: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  webNavigator->GoForward();
  MMset(m, 0, ITOM(1));
  return 0;
}

int WebNavigatorReload(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorReload\n");
#endif

  int webNavigatorIndex = MMget(m, 0);
  if (webNavigatorIndex == NIL)
  {
    MMechostr(MSKDEBUG, "WebNavigatorReload: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorReload: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  webNavigator->Reload();
  MMset(m, 0, ITOM(1));
  return 0;
}

int WebNavigatorReloadIgnoreCache(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorReloadIgnoreCache\n");
#endif

  int webNavigatorIndex = MMget(m, 0);
  if (webNavigatorIndex == NIL)
  {
    MMechostr(MSKDEBUG, "WebNavigatorReloadIgnoreCache: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorReloadIgnoreCache: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  webNavigator->ReloadIgnoreCache();
  MMset(m, 0, ITOM(1));
  return 0;
}

int WebNavigatorStopLoad(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorStopLoad\n");
#endif

  int webNavigatorIndex = MMget(m, 0);
  if (webNavigatorIndex == NIL)
  {
    MMechostr(MSKDEBUG, "WebNavigatorStopLoad: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorStopLoad: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  webNavigator->StopLoad();
  MMset(m, 0, ITOM(1));
  return 0;
}

int WebNavigatorFind(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorFind\n");
#endif

  int scolFirstSearch = MMpull(m);
  int scolCaseSensitive = MMpull(m);
  int scolSearchForward = MMpull(m);
  int scolSearchedText = MMpull(m);
  int scolSearchIdentifier = MMpull(m);
  int webNavigatorIndex = MMget(m, 0);
  if ((webNavigatorIndex == NIL) || (scolSearchedText == NIL) || (scolSearchIdentifier == NIL))
  {
    MMechostr(MSKDEBUG, "WebNavigatorFind: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorFind: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  // Get the search index
  int searchIdentifier = MTOI(scolSearchIdentifier);

  // Get text to search
  std::string searchedText = MMstartstr(m, MTOP(scolSearchedText));

  // Search forward?
  bool searchForward = true;
  if(scolSearchForward != NIL)
    if(MTOI(scolSearchForward) == 0)
      searchForward = false;

  // Case sensitive?
  bool caseSensitive = false;
  if(scolCaseSensitive != NIL)
    if(MTOI(scolCaseSensitive) == 0)
      caseSensitive = true;

  // First search or follow up?
  bool firstSearch = true;
  if(scolFirstSearch != NIL)
    if(MTOI(scolFirstSearch) == 0)
      firstSearch = false;

  // Launch search, response will be sent in the dedicated callback
  webNavigator->Find(searchIdentifier, searchedText, searchForward, caseSensitive, firstSearch);
  MMset(m, 0, ITOM(1));
  return 0;
}

int WebNavigatorStopFinding(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorStopFinding\n");
#endif

  int scolClearSelection = MMpull(m);
  int webNavigatorIndex = MMget(m, 0);
  if (webNavigatorIndex == NIL)
  {
    MMechostr(MSKDEBUG, "WebNavigatorStopFinding: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorStopFinding: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  bool clearSelection = false;
  if(scolClearSelection != NIL)
    if(MTOI(scolClearSelection) == 1)
      clearSelection = true;

  webNavigator->StopFinding(clearSelection);
  MMset(m, 0, ITOM(1));
  return 0;
}

int WebNavigatorGetZoomLevel(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorGetZoomLevel\n");
#endif

  int webNavigatorIndex = MMget(m, 0);
  if (webNavigatorIndex == NIL)
  {
    MMechostr(MSKDEBUG, "WebNavigatorGetZoomLevel: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorGetZoomLevel: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  float zoomLevel = static_cast<float>(webNavigator->GetZoomLevel());
  MMset(m, 0, FTOM(zoomLevel));
  return 0;
}

int WebNavigatorSetZoomLevel(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorSetZoomLevel\n");
#endif

  int scolZoomLevel = MMpull(m);
  int webNavigatorIndex = MMget(m, 0);
  if ((webNavigatorIndex == NIL) || (scolZoomLevel == NIL))
  {
    MMechostr(MSKDEBUG, "WebNavigatorSetZoomLevel: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorSetZoomLevel: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  float zoomLevel = MTOF(scolZoomLevel);
  webNavigator->SetZoomLevel(static_cast<double>(zoomLevel));
  MMset(m, 0, ITOM(1));
  return 0;
}

int WebNavigatorClearHistory(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorClearHistory\n");
#endif

  int webNavigatorIndex = MMget(m, 0);
  if (webNavigatorIndex == NIL)
  {
    MMechostr(MSKDEBUG, "WebNavigatorClearHistory: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorClearHistory: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  webNavigator->ClearHistory();
  MMset(m, 0, ITOM(1));
  return 0;
}

int WebNavigatorShowDevTools(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorShowDevTools\n");
#endif

  int webNavigatorIndex = MMget(m, 0);
  if (webNavigatorIndex == NIL)
  {
    MMechostr(MSKDEBUG, "WebNavigatorShowDevTools: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorShowDevTools: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  webNavigator->ShowDevTools();
  MMset(m, 0, ITOM(1));
  return 0;
}

int WebNavigatorCloseDevTools(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorCloseDevTools\n");
#endif
  int webNavigatorIndex = MMget(m, 0);
  if (webNavigatorIndex == NIL)
  {
    MMechostr(MSKDEBUG, "WebNavigatorCloseDevTools: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorCloseDevTools: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  webNavigator->CloseDevTools();
  MMset(m, 0, ITOM(1));
  return 0;
}

int WebNavigatorGetSize(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorGetSize\n");
#endif

  int webNavigatorIndex = MMget(m, 0);
  if (webNavigatorIndex == NIL)
  {
    MMechostr(MSKDEBUG, "WebNavigatorGetSize: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorGetSize: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  // Create the 'size' return tuple
  int scolSize = MMmalloc(m, 2, TYPETAB);
  if(scolSize==NIL)
    return MERRMEM;

  // Store the size
  std::pair<int, int> size = webNavigator->GetSize();
  MMstore(m, scolSize, 1, ITOM(size.first));
  MMstore(m, scolSize, 0, ITOM(size.second));
  MMset(m, 0, PTOM(scolSize));
  return 0;
}

int WebNavigatorSetSize(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorSetSize\n");
#endif

  int scolHeight = MMpull(m);
  int scolWidth = MMpull(m);
  int webNavigatorIndex = MMget(m, 0);
  if ((webNavigatorIndex == NIL)||(scolWidth==NIL)||(scolHeight==NIL))
  {
    MMechostr(MSKDEBUG, "WebNavigatorSetSize: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorSetSize: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  webNavigator->SetSize(std::pair<int,int>(MTOI(scolWidth), MTOI(scolHeight)));
  MMset(m, 0, ITOM(1));
  return 0;
}

int WebNavigatorGetPosition(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorGetPosition\n");
#endif

  int webNavigatorIndex = MMget(m, 0);
  if (webNavigatorIndex == NIL)
  {
    MMechostr(MSKDEBUG, "WebNavigatorGetPosition: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorGetPosition: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  // Create the 'size' return tuple
  int scolPosition = MMmalloc(m, 2, TYPETAB);
  if(scolPosition==NIL)
    return MERRMEM;

  // Store the position
  std::pair<int, int> position = webNavigator->GetPosition();
  MMstore(m, scolPosition, 1, ITOM(position.first));
  MMstore(m, scolPosition, 0, ITOM(position.second));
  MMset(m, 0, PTOM(scolPosition));
  return 0;
}

int WebNavigatorSetPosition(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorSetPosition\n");
#endif

  int scolYPos = MMpull(m);
  int scolXPos = MMpull(m);
  int webNavigatorIndex = MMget(m, 0);
  if ((webNavigatorIndex == NIL)||(scolXPos==NIL)||(scolYPos==NIL))
  {
    MMechostr(MSKDEBUG, "WebNavigatorSetPosition: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorSetPosition: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  webNavigator->SetPosition(std::pair<int,int>(MTOI(scolXPos), MTOI(scolYPos)));
  MMset(m, 0, ITOM(1));
  return 0;
}

int WebNavigatorBlitOffscreen(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorBlitOffscreen\n");
#endif

  int scolTargetBitmap = MMpull(m);
  int webNavigatorIndex = MMget(m, 0);
  if ((webNavigatorIndex == NIL)||(scolTargetBitmap==NIL))
  {
    MMechostr(MSKDEBUG, "WebNavigatorBlitOffscreen: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorBlitOffscreen: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  if(!webNavigator->IsOffscreen())
  {
    MMechostr(MSKDEBUG, "WebNavigatorBlitOffscreen: Not an offscreen rendered web navigator!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  // Get the target buffer
  PtrObjVoid OB = (PtrObjVoid) MMstart(m, MTOP(scolTargetBitmap));
  PtrObjBitmap B = (PtrObjBitmap) MMstart(m, MTOP(OB->Buffer));

  // Copy buffer
  bool sucess = webNavigator->GetWebNavigatorClient()->BlitOffscreenBitmap(B->bits, B->TailleW, B->TailleH, B->BytesPP, B->BPL);
  if(!sucess)
  {
    MMechostr(MSKDEBUG, "WebNavigatorBlitOffscreen: the target bitmap don't have the same size!\n");
    MMset(m, 0, NIL);
    return 0;
  }
  else
  {
	  MMset(m, 0, PTOM(scolTargetBitmap));	
    return 0;
  }
}

int WebNavigatorBlitOffscreenAlpha(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorBlitOffscreenAlpha\n");
#endif

  int scolTargetAlphaBitmap = MMpull(m);
  int webNavigatorIndex = MMget(m, 0);
  if ((webNavigatorIndex == NIL)||(scolTargetAlphaBitmap==NIL))
  {
    MMechostr(MSKDEBUG, "WebNavigatorBlitOffscreenAlpha: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorBlitOffscreenAlpha: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  if(!webNavigator->IsOffscreen())
  {
    MMechostr(MSKDEBUG, "WebNavigatorBlitOffscreenAlpha: Not an offscreen rendered web navigator!\n");
    MMset(m, 0, NIL);
    return 0;
  }

	// Get alphabitmap content
  int scolColorLayer = MMfetch(m, MTOP(scolTargetAlphaBitmap), 0);
  int scolAlphaLayer = MMfetch(m, MTOP(scolTargetAlphaBitmap), 1);

  // Get color layer bitmap
  PtrObjVoid scolVoidPointerBmp = (PtrObjVoid) MMstart(m, MTOP(scolColorLayer));
  if(scolVoidPointerBmp->Type != OBJ_TYPE_BITMAP << 1)
  {
    MMechostr(MSKDEBUG, "WebNavigatorBlitOffscreenAlpha: Invalid alphabitmap color layer!\n");
    MMset(m, 0, NIL);
    return 0;
  }
  PtrObjBitmap targetBitmapColor = (PtrObjBitmap) MMstart(m, MTOP(scolVoidPointerBmp->Buffer));
  
  // Get alpha layer bitmap
  PtrObjBitmap targetBitmapAlpha = 0;
  if (scolAlphaLayer != NIL)
  {
    PtrObjVoid scolVoidPointerAlpha = (PtrObjVoid) MMstart(m, MTOP(scolAlphaLayer));

    // Get alpha layer bitmap
    if(scolVoidPointerAlpha->Type != OBJ_TYPE_BITMAP << 1)
    {
      MMechostr(MSKDEBUG, "WebNavigatorBlitOffscreenAlpha: Invalid alphabitmap alpha layer!\n");
      MMset(m, 0, NIL);
      return 0;
    }
    targetBitmapAlpha = (PtrObjBitmap) MMstart(m, MTOP(scolVoidPointerAlpha->Buffer));
  }

  // Copy buffer
  bool success = false;
  if(targetBitmapAlpha == 0)
  {
    success = webNavigator->GetWebNavigatorClient()->BlitOffscreenBitmap(targetBitmapColor->bits, targetBitmapColor->TailleW, targetBitmapColor->TailleH, targetBitmapColor->BytesPP, targetBitmapColor->BPL);
  }
  else
  {
    if((targetBitmapColor->TailleW != targetBitmapAlpha->TailleW) || (targetBitmapColor->TailleH != targetBitmapAlpha->TailleH))
    {
      MMechostr(MSKDEBUG, "WebNavigatorBlitOffscreenAlpha: the target alphabitmap color layer have a different size than the alpha layer!\n");
      MMset(m, 0, NIL);
      return 0;
    }

    success = webNavigator->GetWebNavigatorClient()->BlitOffscreenAlphaBitmap(targetBitmapColor->bits, targetBitmapAlpha->bits, targetBitmapColor->TailleW, targetBitmapColor->TailleH, targetBitmapColor->BytesPP, targetBitmapColor->BPL);
  }

  // Result
  if(!success)
  {
    MMechostr(MSKDEBUG, "WebNavigatorBlitOffscreenAlpha: the target alphabitmap don't have the same size!\n");
    MMset(m, 0, NIL);
    return 0;
  }
  else
  {
	  MMset(m, 0, PTOM(scolTargetAlphaBitmap));	
    return 0;
  }
}

int WebNavigatorInjectKeyDown(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorInjectKeyDown\n");
#endif

  int scolKeyData = MMpull(m);
  int scolScanCode = MMpull(m);
  int webNavigatorIndex = MMget(m, 0);
  if ((webNavigatorIndex == NIL)||(scolScanCode==NIL))
  {
    MMechostr(MSKDEBUG, "WebNavigatorInjectKeyDown: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorInjectKeyDown: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  webNavigator->InjectKey(MTOI(scolScanCode), MTOI(scolKeyData), true);
  webNavigator->InjectChar(MTOI(scolScanCode), MTOI(scolKeyData));
  MMset(m, 0, ITOM(1));
  return 0;
}

int WebNavigatorInjectKeyUp(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorInjectKeyUp\n");
#endif

  int scolScanCode = MMpull(m);
  int webNavigatorIndex = MMget(m, 0);
  if ((webNavigatorIndex == NIL)||(scolScanCode==NIL))
  {
    MMechostr(MSKDEBUG, "WebNavigatorInjectKeyUp: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorInjectKeyUp: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  webNavigator->InjectKey(MTOI(scolScanCode), 0, false);
  MMset(m, 0, ITOM(1));
  return 0;
}

int WebNavigatorInjectKeyMessage(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorInjectKeyMessage\n");
#endif

  int scolWparam = MMpull(m);
  int scolLparam = MMpull(m);
  int scolMsg = MMpull(m);
  int webNavigatorIndex = MMget(m, 0);
  if ((webNavigatorIndex == NIL)||(scolMsg==NIL))
  {
    MMechostr(MSKDEBUG, "WebNavigatorInjectKeyMessage: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorInjectKeyMessage: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  webNavigator->InjectKeyMsg(MTOI(scolMsg), MTOI(scolLparam), MTOI(scolWparam));
  MMset(m, 0, ITOM(1));
  return 0;
}

int WebNavigatorInjectMouseClick(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorInjectMouseClick\n");
#endif

  int scolButton = MMpull(m);
  int scolYPos = MMpull(m);
  int scolXPos = MMpull(m);
  int webNavigatorIndex = MMget(m, 0);
  if ((webNavigatorIndex == NIL)||(scolXPos==NIL)||(scolYPos==NIL)||(scolButton==NIL))
  {
    MMechostr(MSKDEBUG, "WebNavigatorInjectMouseClick: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorInjectMouseClick: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  webNavigator->InjectMouseClick(MTOI(scolXPos), MTOI(scolYPos), MTOI(scolButton), false, 1);
  MMset(m, 0, ITOM(1));
  return 0;
}

int WebNavigatorInjectMouseUnClick(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorInjectMouseUnClick\n");
#endif

  int scolButton = MMpull(m);
  int scolYPos = MMpull(m);
  int scolXPos = MMpull(m);
  int webNavigatorIndex = MMget(m, 0);
  if ((webNavigatorIndex == NIL)||(scolXPos==NIL)||(scolYPos==NIL)||(scolButton==NIL))
  {
    MMechostr(MSKDEBUG, "WebNavigatorInjectMouseUnClick: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorInjectMouseUnClick: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  webNavigator->InjectMouseClick(MTOI(scolXPos), MTOI(scolYPos), MTOI(scolButton), true, 1);
  MMset(m, 0, ITOM(1));
  return 0;
}

int WebNavigatorInjectMouseMove(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorInjectMouseMove\n");
#endif

  int scolYPos = MMpull(m);
  int scolXPos = MMpull(m);
  int webNavigatorIndex = MMget(m, 0);
  if ((webNavigatorIndex == NIL)||(scolXPos==NIL)||(scolYPos==NIL))
  {
    MMechostr(MSKDEBUG, "WebNavigatorInjectMouseMove: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorInjectMouseMove: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  webNavigator->InjectMouseMove(MTOI(scolXPos), MTOI(scolYPos), false);
  MMset(m, 0, ITOM(1));
  return 0;
}

int WebNavigatorInjectMouseWheel(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorInjectMouseWheel\n");
#endif

  int scolDelta = MMpull(m);
  int scolYPos = MMpull(m);
  int scolXPos = MMpull(m);
  int webNavigatorIndex = MMget(m, 0);
  if ((webNavigatorIndex == NIL)||(scolXPos==NIL)||(scolYPos==NIL)||(scolDelta==NIL))
  {
    MMechostr(MSKDEBUG, "WebNavigatorInjectMouseWheel: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorInjectMouseWheel: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  webNavigator->InjectMouseWheel(MTOI(scolXPos), MTOI(scolYPos), MTOI(scolDelta));
  MMset(m, 0, ITOM(1));
  return 0;
}

int WebNavigatorInjectFocus(mmachine m)
{
#ifdef SCOL_DEBUG
  MMechostr(MSKDEBUG, "WebNavigatorInjectFocus\n");
#endif

  int scolFocus = MMpull(m);
  int webNavigatorIndex = MMget(m, 0);
  if ((webNavigatorIndex == NIL)||(scolFocus==NIL))
  {
    MMechostr(MSKDEBUG, "WebNavigatorInjectFocus: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  Scol::EmbeddedWebNavigator::WebNavigator* webNavigator = (Scol::EmbeddedWebNavigator::WebNavigator*) MMfetch(m, MTOP(webNavigatorIndex), 0);
  if (webNavigator == 0)
  {
    MMechostr(MSKDEBUG, "WebNavigatorInjectFocus: Invalid parameters!\n");
    MMset(m, 0, NIL);
    return 0;
  }

  if(MTOI(scolFocus) == 1)
    webNavigator->InjectFocus(true);
  else
    webNavigator->InjectFocus(false);
  MMset(m, 0, ITOM(1));
  return 0;
}


// Nb of Scol functions or types
#define WebNavigatorScolFunctionsNb 48

/**
 * Scol function names
 */
char* WebNavigatorScolFunctionsNames[WebNavigatorScolFunctionsNb] =
{
  "ObjWebNavigator",
  "WebNavigatorCreate",
  "WebNavigatorCreateOffscreen",
  "WebNavigatorDestroy",
  "WebNavigatorLoadURL",
  "WebNavigatorLoadFile",
  "WebNavigatorLoadHTML",
  "WebNavigatorActionUndo",
  "WebNavigatorActionRedo",
  "WebNavigatorActionCut",
  "WebNavigatorActionCopy",
  "WebNavigatorActionPaste",
  "WebNavigatorActionDelete",
  "WebNavigatorActionSelectAll",
  "WebNavigatorPrint",
  "WebNavigatorViewSource",
  "WebNavigatorGetSource",
  "WebNavigatorGetText",
  "WebNavigatorGetURL",
  "WebNavigatorExecuteJavaScript",
  "WebNavigatorCanGoBack",
  "WebNavigatorGoBack",
  "WebNavigatorCanGoForward",
  "WebNavigatorGoForward",
  "WebNavigatorReload",
  "WebNavigatorReloadIgnoreCache",
  "WebNavigatorStopLoad",
  "WebNavigatorFind",
  "WebNavigatorStopFinding",
  "WebNavigatorGetZoomLevel",
  "WebNavigatorSetZoomLevel",
  "WebNavigatorClearHistory",
  "WebNavigatorShowDevTools",
  "WebNavigatorCloseDevTools",
  "WebNavigatorGetSize",
  "WebNavigatorSetSize",
  "WebNavigatorGetPosition",
  "WebNavigatorSetPosition",
  "WebNavigatorBlitOffscreen",
  "WebNavigatorBlitOffscreenAlpha",
  "WebNavigatorInjectKeyDown",
  "WebNavigatorInjectKeyUp",
  "WebNavigatorInjectKeyMessage",
  "WebNavigatorInjectMouseClick",
  "WebNavigatorInjectMouseUnClick",
  "WebNavigatorInjectMouseMove",
  "WebNavigatorInjectMouseWheel",
  "WebNavigatorInjectFocus"
};

/**
 * Pointers to C functions that manipulate the VM for each scol function previously defined
 */
int (*WebNavigatorScolFunctionsPtr[WebNavigatorScolFunctionsNb])(mmachine m)=
{
  NULL,			
  WebNavigatorCreate,
  WebNavigatorCreateOffscreen,
  WebNavigatorDestroy,
  WebNavigatorLoadURL,
  WebNavigatorLoadFile,
  WebNavigatorLoadHTML,
  WebNavigatorActionUndo,
  WebNavigatorActionRedo,
  WebNavigatorActionCut,
  WebNavigatorActionCopy,
  WebNavigatorActionPaste,
  WebNavigatorActionDelete,
  WebNavigatorActionSelectAll,
  WebNavigatorPrint,
  WebNavigatorViewSource,
  WebNavigatorGetSource,
  WebNavigatorGetText,
  WebNavigatorGetURL,
  WebNavigatorExecuteJavaScript,
  WebNavigatorCanGoBack,
  WebNavigatorGoBack,
  WebNavigatorCanGoForward,
  WebNavigatorGoForward,
  WebNavigatorReload,
  WebNavigatorReloadIgnoreCache,
  WebNavigatorStopLoad,
  WebNavigatorFind,
  WebNavigatorStopFinding,
  WebNavigatorGetZoomLevel,
  WebNavigatorSetZoomLevel,
  WebNavigatorClearHistory,
  WebNavigatorShowDevTools,
  WebNavigatorCloseDevTools,
  WebNavigatorGetSize,
  WebNavigatorSetSize,
  WebNavigatorGetPosition,
  WebNavigatorSetPosition,
  WebNavigatorBlitOffscreen,
  WebNavigatorBlitOffscreenAlpha,
  WebNavigatorInjectKeyDown,
  WebNavigatorInjectKeyUp,
  WebNavigatorInjectKeyMessage,
  WebNavigatorInjectMouseClick,
  WebNavigatorInjectMouseUnClick,
  WebNavigatorInjectMouseMove,
  WebNavigatorInjectMouseWheel,
  WebNavigatorInjectFocus
};

/**
 * Nb of arguments of each scol function
 */
int WebNavigatorScolFunctionsNbArgs[WebNavigatorScolFunctionsNb]=
{
  TYPTYPE,                                  // ObjWebNavigator
  7,	                                      // WebNavigatorCreate
  6,	                                      // WebNavigatorCreateOffscreen
  1,	                                      // WebNavigatorDestroy
  3,                                        // WebNavigatorLoadURL
  3,                                        // WebNavigatorLoadFile
  3,                                        // WebNavigatorLoadHTML
  2,                                        // WebNavigatorActionUndo
  2,                                        // WebNavigatorActionRedo
  2,                                        // WebNavigatorActionCut
  2,                                        // WebNavigatorActionCopy
  2,                                        // WebNavigatorActionPaste
  2,                                        // WebNavigatorActionDelete
  2,                                        // WebNavigatorActionSelectAll
  2,                                        // WebNavigatorPrint
  2,                                        // WebNavigatorViewSource
  2,                                        // WebNavigatorGetSource
  2,                                        // WebNavigatorGetText
  2,                                        // WebNavigatorGetURL
  5,                                        // WebNavigatorExecuteJavaScript
  1,                                        // WebNavigatorCanGoBack
  1,                                        // WebNavigatorGoBack
  1,                                        // WebNavigatorCanGoForward
  1,                                        // WebNavigatorGoForward
  1,                                        // WebNavigatorReload
  1,                                        // WebNavigatorReloadIgnoreCache
  1,                                        // WebNavigatorStopLoad
  6,                                        // WebNavigatorFind
  2,                                        // WebNavigatorStopFinding
  1,                                        // WebNavigatorGetZoomLevel
  2,                                        // WebNavigatorSetZoomLevel
  1,                                        // WebNavigatorClearHistory
  1,                                        // WebNavigatorShowDevTools
  1,                                        // WebNavigatorCloseDevTools
  1,                                        // WebNavigatorGetSize
  3,                                        // WebNavigatorSetSize
  1,                                        // WebNavigatorGetPosition
  3,                                        // WebNavigatorSetPosition
  2,                                        // WebNavigatorBlitOffscreen
  2,                                        // WebNavigatorBlitOffscreenAlpha
  3,                                        // WebNavigatorInjectKeyDown,
  2,                                        // WebNavigatorInjectKeyUp,
  4,                                        // WebNavigatorInjectKeyMessage,
  4,                                        // WebNavigatorInjectMouseClick,
  4,                                        // WebNavigatorInjectMouseUnClick,
  3,                                        // WebNavigatorInjectMouseMove,
  4,                                        // WebNavigatorInjectMouseWheel,
  2                                         // WebNavigatorInjectFocus
};

/**
 * Prototypes of the scol functions
 */
char* WebNavigatorScolFunctionsType[WebNavigatorScolFunctionsNb]=
{
  NULL,                                                                       // ObjWebNavigator
  "fun [Chn ObjWin I I I I S] ObjWebNavigator",                               // WebNavigatorCreate
  "fun [Chn ObjWin I I I S] ObjWebNavigator",                                 // WebNavigatorCreateOffscreen
  "fun [ObjWebNavigator] I",                                                  // WebNavigatorDestroy
  "fun [ObjWebNavigator S S] I",                                              // WebNavigatorLoadURL
  "fun [ObjWebNavigator P S] I",                                              // WebNavigatorLoadFile
  "fun [ObjWebNavigator S S] I",                                              // WebNavigatorLoadHTML
  "fun [ObjWebNavigator S] I",                                                // WebNavigatorActionUndo
  "fun [ObjWebNavigator S] I",                                                // WebNavigatorActionRedo
  "fun [ObjWebNavigator S] I",                                                // WebNavigatorActionCut
  "fun [ObjWebNavigator S] I",                                                // WebNavigatorActionCopy
  "fun [ObjWebNavigator S] I",                                                // WebNavigatorActionPaste
  "fun [ObjWebNavigator S] I",                                                // WebNavigatorActionDelete
  "fun [ObjWebNavigator S] I",                                                // WebNavigatorActionSelectAll
  "fun [ObjWebNavigator S] I",                                                // WebNavigatorPrint
  "fun [ObjWebNavigator S] I",                                                // WebNavigatorViewSource
  "fun [ObjWebNavigator S] S",                                                // WebNavigatorGetSource
  "fun [ObjWebNavigator S] S",                                                // WebNavigatorGetText
  "fun [ObjWebNavigator S] S",                                                // WebNavigatorGetURL
  "fun [ObjWebNavigator S S I S] I",                                          // WebNavigatorExecuteJavaScript
  "fun [ObjWebNavigator] I",                                                  // WebNavigatorCanGoBack
  "fun [ObjWebNavigator] I",                                                  // WebNavigatorGoBack
  "fun [ObjWebNavigator] I",                                                  // WebNavigatorCanGoForward
  "fun [ObjWebNavigator] I",                                                  // WebNavigatorGoForward
  "fun [ObjWebNavigator] I",                                                  // WebNavigatorReload
  "fun [ObjWebNavigator] I",                                                  // WebNavigatorReloadIgnoreCache
  "fun [ObjWebNavigator] I",                                                  // WebNavigatorStopLoad
  "fun [ObjWebNavigator I S I I I] I",                                        // WebNavigatorFind
  "fun [ObjWebNavigator I] I",                                                // WebNavigatorStopFinding
  "fun [ObjWebNavigator] F",                                                  // WebNavigatorGetZoomLevel
  "fun [ObjWebNavigator F] I",                                                // WebNavigatorSetZoomLevel
  "fun [ObjWebNavigator] I",                                                  // WebNavigatorClearHistory
  "fun [ObjWebNavigator] I",                                                  // WebNavigatorShowDevTools
  "fun [ObjWebNavigator] I",                                                  // WebNavigatorCloseDevTools
  "fun [ObjWebNavigator] [I I]",                                              // WebNavigatorGetSize
  "fun [ObjWebNavigator I I] I",                                              // WebNavigatorSetSize
  "fun [ObjWebNavigator] [I I]",                                              // WebNavigatorGetPosition
  "fun [ObjWebNavigator I I] I",                                              // WebNavigatorSetPosition
  "fun [ObjWebNavigator ObjBitmap] ObjBitmap",                                // WebNavigatorBlitOffscreen
  "fun [ObjWebNavigator AlphaBitmap] AlphaBitmap",                            // WebNavigatorBlitOffscreenAlpha
  "fun [ObjWebNavigator I I] I",                                              // WebNavigatorInjectKeyDown,
  "fun [ObjWebNavigator I] I",                                                // WebNavigatorInjectKeyUp,
  "fun [ObjWebNavigator I I I] I",                                            // WebNavigatorInjectKeyMessage,
  "fun [ObjWebNavigator I I I] I",                                            // WebNavigatorInjectMouseClick,
  "fun [ObjWebNavigator I I I] I",                                            // WebNavigatorInjectMouseUnClick,
  "fun [ObjWebNavigator I I] I",                                              // WebNavigatorInjectMouseMove,
  "fun [ObjWebNavigator I I I] I",                                            // WebNavigatorInjectMouseWheel,
  "fun [ObjWebNavigator I] I"                                                 // WebNavigatorinjectFocus
};

// Everything inside _cond and _endcond is ignored by doxygen
//! \cond

/**
 * \brief Load the WebNavigatorCore package in Scol virtual machine
 * \param mmachine : the scol machine
 */
int LoadWebNavigator(mmachine m)
{
  // Get the handle of the main scol window (for windows messages dispatching).
  HScol = (ScolWindowHandle)SCgetExtra("hscol");

  // Get the first partition as cache directory
  packdir mypack = (packdir)SCgetExtra("FirstPack");
  std::string cacheDirectory = mypack->path;
  cacheDirectory += "tmp/CefCache";

  // Add a subdirectory for the cache, in order to avoid messy files to go in the root partition dir
  CreateDirectory(cacheDirectory.c_str(), 0);

  // Create the web navigator manager.
  webNavigatorManager = new Scol::EmbeddedWebNavigator::WebNavigatorManager(HScol, cacheDirectory);

  // Scol type declaration
  OBJWEBNAVIGATORSCOL = OBJregister(WEB_NAVIGATOR_MAX_CB, 1, destroyWebNavigatorObj, "OBJWEBNAVIGATORSCOL");

  // Define callbacks
  // ****************

  // Display callbacks
  WEB_NAVIGATOR_DISPLAY_ON_NAV_STATE_CHANGE_WINMSG = OBJgetUserEvent();
  OBJdefEvent(WEB_NAVIGATOR_DISPLAY_ON_NAV_STATE_CHANGE_WINMSG, (int (__cdecl *)(mmachine, ScolWindowHandle, unsigned int, UINT, LONG, int*))FireWebNavigatorReflexiveOnNavStateChange);
  WEB_NAVIGATOR_DISPLAY_ON_ADDRESS_CHANGE_WINMSG = OBJgetUserEvent();
  OBJdefEvent(WEB_NAVIGATOR_DISPLAY_ON_ADDRESS_CHANGE_WINMSG, (int (__cdecl *)(mmachine, ScolWindowHandle, unsigned int, UINT, LONG, int*))FireWebNavigatorReflexiveOnAddressChange);
  WEB_NAVIGATOR_DISPLAY_ON_TITLE_CHANGE_WINMSG = OBJgetUserEvent();
  OBJdefEvent(WEB_NAVIGATOR_DISPLAY_ON_TITLE_CHANGE_WINMSG, (int (__cdecl *)(mmachine, ScolWindowHandle, unsigned int, UINT, LONG, int*))FireWebNavigatorReflexiveOnTitleChange);
  WEB_NAVIGATOR_DISPLAY_ON_TOOLTIP_WINMSG = OBJgetUserEvent();
  OBJdefEvent(WEB_NAVIGATOR_DISPLAY_ON_TOOLTIP_WINMSG, (int (__cdecl *)(mmachine, ScolWindowHandle, unsigned int, UINT, LONG, int*))FireWebNavigatorReflexiveOnTooltip);
  WEB_NAVIGATOR_DISPLAY_ON_STATUS_MESSAGE_WINMSG = OBJgetUserEvent();
  OBJdefEvent(WEB_NAVIGATOR_DISPLAY_ON_STATUS_MESSAGE_WINMSG, (int (__cdecl *)(mmachine, ScolWindowHandle, unsigned int, UINT, LONG, int*))FireWebNavigatorReflexiveOnStatusMessage);
  WEB_NAVIGATOR_DISPLAY_ON_CONSOLE_MESSAGE_WINMSG = OBJgetUserEvent();
  OBJdefEvent(WEB_NAVIGATOR_DISPLAY_ON_CONSOLE_MESSAGE_WINMSG, (int (__cdecl *)(mmachine, ScolWindowHandle, unsigned int, UINT, LONG, int*))FireWebNavigatorReflexiveOnConsoleMessage);

  // LifeSpan callbacks
  WEB_NAVIGATOR_LIFESPAN_ON_POPUP_WINMSG = OBJgetUserEvent();
  OBJdefEvent(WEB_NAVIGATOR_LIFESPAN_ON_POPUP_WINMSG, (int (__cdecl *)(mmachine, ScolWindowHandle, unsigned int, UINT, LONG, int*))FireWebNavigatorReflexiveOnPopup);
  WEB_NAVIGATOR_LIFESPAN_RUN_MODAL_WINMSG = OBJgetUserEvent();
  OBJdefEvent(WEB_NAVIGATOR_LIFESPAN_RUN_MODAL_WINMSG, (int (__cdecl *)(mmachine, ScolWindowHandle, unsigned int, UINT, LONG, int*))FireWebNavigatorReflexiveRunModal);

  // Load callbacks
  WEB_NAVIGATOR_LOAD_ON_START_WINMSG = OBJgetUserEvent();
  OBJdefEvent(WEB_NAVIGATOR_LOAD_ON_START_WINMSG, (int (__cdecl *)(mmachine, ScolWindowHandle, unsigned int, UINT, LONG, int*))FireWebNavigatorReflexiveOnLoadStart);
  WEB_NAVIGATOR_LOAD_ON_END_WINMSG = OBJgetUserEvent();
  OBJdefEvent(WEB_NAVIGATOR_LOAD_ON_END_WINMSG, (int (__cdecl *)(mmachine, ScolWindowHandle, unsigned int, UINT, LONG, int*))FireWebNavigatorReflexiveOnLoadEnd);
  WEB_NAVIGATOR_LOAD_ON_ERROR_WINMSG = OBJgetUserEvent();
  OBJdefEvent(WEB_NAVIGATOR_LOAD_ON_ERROR_WINMSG, (int (__cdecl *)(mmachine, ScolWindowHandle, unsigned int, UINT, LONG, int*))FireWebNavigatorReflexiveOnLoadError);

  // Find callback
  WEB_NAVIGATOR_FIND_ON_RESULT_WINMSG = OBJgetUserEvent();
  OBJdefEvent(WEB_NAVIGATOR_FIND_ON_RESULT_WINMSG, (int (__cdecl *)(mmachine, ScolWindowHandle, unsigned int, UINT, LONG, int*))FireWebNavigatorReflexiveOnFindResult);

  // JS binding callback
  WEB_NAVIGATOR_JS_ON_EXTERNAL_CALL_WINMSG = OBJgetUserEvent();
  OBJdefEvent(WEB_NAVIGATOR_JS_ON_EXTERNAL_CALL_WINMSG, (int (__cdecl *)(mmachine, ScolWindowHandle, unsigned int, UINT, LONG, int*))FireWebNavigatorReflexiveOnExternalCall);

  // JS binding str callback
  WEB_NAVIGATOR_JS_ON_EXTERNAL_STR_CALL_WINMSG = OBJgetUserEvent();
  OBJdefEvent(WEB_NAVIGATOR_JS_ON_EXTERNAL_STR_CALL_WINMSG, (int (__cdecl *)(mmachine, ScolWindowHandle, unsigned int, UINT, LONG, int*))FireWebNavigatorReflexiveOnExternalCallStr);


  // TODO Other callbacks...
  // ...

  // Load OBJWEBNAVIGATORSCOL scol functions
  int k = PKhardpak(m, "WebNavigatorCore", WebNavigatorScolFunctionsNb, WebNavigatorScolFunctionsNames, WebNavigatorScolFunctionsPtr, WebNavigatorScolFunctionsNbArgs, WebNavigatorScolFunctionsType);

  // Load scol callbacks functions
  LoadWebNavigatorDisplay(m);
  LoadWebNavigatorFind(m);
  LoadWebNavigatorJSBinding(m);
  LoadWebNavigatorLifeSpan(m);
  LoadWebNavigatorLoad(m);

  // Return error.
  return k;
}

/** 
 * \brief Starting point of the DLL
 * Function to add in Scol usm.ini for loading dll
 */
extern "C" __declspec (dllexport) int ScolLoadPlugin(mmachine m, cbmachine w)
{
  SCOLinitplugin(w);
  LoadWebNavigator(m);
  return 0;
}

/** 
 * \brief Ending point of the DLL
 * Function to add in Scol usm.ini for free dll
 */
extern "C" __declspec (dllexport) int ScolUnloadPlugin()
{
  delete(webNavigatorManager);
  webNavigatorManager = 0;
  return 0;
}

//! \endcond