SO3WidgetManager.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 "SO3Renderer/SO3Root.h"
#include "SO3Renderer/SO3WidgetManager.h"
#include "SO3SceneGraph/SO3Scene.h"
#include "SO3Renderer/SO3Window.h"
#include "SO3Renderer/SO3ViewPort.h"
#include "SO3Material/SO3Material.h"
#include <Ogre.h>
 
namespace Ogre
{
  //Singleton instance
  template<> SO3::SWidgetManager* Ogre::Singleton<SO3::SWidgetManager>::msSingleton = 0;
}
 
namespace SO3
{
 
SWidgetManager* SWidgetManager::getSingletonPtr()
{
        return msSingleton;
}
 
SWidgetManager& SWidgetManager::getSingleton()
{
        assert(msSingleton);
  return (*msSingleton);
}
 
SWidgetManager::SWidgetManager()
{
  focusedWidget = 0;
}
 
SWidgetManager::~SWidgetManager()
{
  focusedWidget = 0;
 
  // Factories instance are not deleted, it's the wanted behavior.
  WidgetFactoryList widgetFactoryListCopy = widgetFactoryList;
  WidgetFactoryList::iterator iWidgetFactoryList = widgetFactoryListCopy.begin();
  while (iWidgetFactoryList != widgetFactoryListCopy.end())
  {
    RemoveWidgetFactory(iWidgetFactoryList->second);
    iWidgetFactoryList++;
  }
  widgetFactoryList.clear();
}
 
SWidgetManager::WidgetList SWidgetManager::GetWidgetList()
{
  return widgetList;
}
 
void SWidgetManager::AddWidgetFactory(SWidgetFactory* newWidgetFactory)
{
  WidgetFactoryList::iterator iWidgetFactorySearched = widgetFactoryList.find(newWidgetFactory->GetType());
  if(iWidgetFactorySearched == widgetFactoryList.end())
    widgetFactoryList.insert(WidgetFactoryList::value_type(newWidgetFactory->GetType(), newWidgetFactory));
  else
    OGRE_EXCEPT(Ogre::Exception::ERR_DUPLICATE_ITEM, "Cannot add factory for widget \""+ newWidgetFactory->GetType() +"\", factory already exists in widget manager!", "SWidgetManager::AddWidgetFactory");
}
 
void SWidgetManager::RemoveWidgetFactory(SWidgetFactory* existingWidgetFactory)
{
  RemoveWidgetFactory(existingWidgetFactory->GetType());
}
 
void SWidgetManager::RemoveWidgetFactory(const std::string& existingWidgetFactoryName)
{
  WidgetFactoryList::iterator iWidgetFactorySearched = widgetFactoryList.find(existingWidgetFactoryName);
  if(iWidgetFactorySearched != widgetFactoryList.end())
    widgetFactoryList.erase(iWidgetFactorySearched);
  else
    OGRE_EXCEPT(Ogre::Exception::ERR_ITEM_NOT_FOUND, "Cannot remove factory for widget \""+ existingWidgetFactoryName +"\", factory does not exists in widget manager!", "SWidgetManager::RemoveWidgetFactory");
}
 
SWidget* SWidgetManager::CreateWidget(SScene* targetScene, const std::string& widgetName, const int& xPos, const int& yPos, const unsigned short& width, const unsigned short& height, SViewPort* targetViewport, const unsigned int& widgetZOrder, const std::string& widgetType)
{
  SWidget* newWidget = 0;
  WidgetFactoryList::iterator iWidgetFactorySearched = widgetFactoryList.find(widgetType);
  if(iWidgetFactorySearched != widgetFactoryList.end())
  {
    WidgetList::iterator iWidgetSearched = widgetList.find(widgetName);
    if(iWidgetSearched == widgetList.end())
    {
      newWidget = iWidgetFactorySearched->second->CreateWidget(targetScene, widgetName, xPos, yPos, width, height, targetViewport, widgetZOrder);
      widgetList.insert(WidgetList::value_type(widgetName, newWidget));
      overlayedWidgetList.insert(WidgetList::value_type(widgetName, newWidget));
 
      // Update zOrder of all overlayed widgets
      UpdateWidgetsZOrder();
    }
    else
      OGRE_EXCEPT(Ogre::Exception::ERR_DUPLICATE_ITEM, "Cannot create a widget named \""+ widgetName +"\", a widget with the same name already exists!", "SWidgetManager::CreateWidget");
  }
  else
    OGRE_EXCEPT(Ogre::Exception::ERR_ITEM_NOT_FOUND, "Cannot create a widget with factory \""+ widgetType +"\", factory does not exists in widget manager!", "SWidgetManager::CreateWidget");
 
  return newWidget;
}
 
SWidget* SWidgetManager::CreateWidget(SScene* targetScene, const std::string& widgetName, const int& xPos, const int& yPos, const unsigned short& width, const unsigned short& height, SViewPort* targetViewport, const std::string& widgetType)
{
  SWidget* newWidget = 0;
  WidgetFactoryList::iterator iWidgetFactorySearched = widgetFactoryList.find(widgetType);
  if(iWidgetFactorySearched != widgetFactoryList.end())
  {
    WidgetList::iterator iWidgetSearched = widgetList.find(widgetName);
    if(iWidgetSearched == widgetList.end())
    {
      newWidget = iWidgetFactorySearched->second->CreateWidget(targetScene, widgetName, xPos, yPos, width, height, targetViewport);
      widgetList.insert(WidgetList::value_type(widgetName, newWidget));
    }
    else
      OGRE_EXCEPT(Ogre::Exception::ERR_DUPLICATE_ITEM, "Cannot create a widget named \""+ widgetName +"\", a widget with the same name already exists!", "SWidgetManager::CreateWidget");
  }
  else
    OGRE_EXCEPT(Ogre::Exception::ERR_ITEM_NOT_FOUND, "Cannot create a widget with factory \""+ widgetType +"\", factory does not exists in widget manager!", "SWidgetManager::CreateWidget");
 
  return newWidget;
}
 
SWidget* SWidgetManager::CreateWidget(SScene* targetScene, const std::string& widgetName, const unsigned short& width, const unsigned short& height, SMaterial* targetMaterial, const unsigned short& targetTechnique, const unsigned short& targetPass, const unsigned short& targetTextureUnit, const std::string& widgetType)
{
  SWidget* newWidget = 0;
  WidgetFactoryList::iterator iWidgetFactorySearched = widgetFactoryList.find(widgetType);
  if(iWidgetFactorySearched != widgetFactoryList.end())
  {
    WidgetList::iterator iWidgetSearched = widgetList.find(widgetName);
    if(iWidgetSearched == widgetList.end())
    {
      newWidget = iWidgetFactorySearched->second->CreateWidget(targetScene, widgetName, width, height, targetMaterial, targetTechnique, targetPass, targetTextureUnit);
      widgetList.insert(WidgetList::value_type(widgetName, newWidget));
    }
    else
      OGRE_EXCEPT(Ogre::Exception::ERR_DUPLICATE_ITEM, "Cannot create a widget named \""+ widgetName +"\", a widget with the same name already exists!", "SWidgetManager::CreateWidget");
  }
  else
    OGRE_EXCEPT(Ogre::Exception::ERR_ITEM_NOT_FOUND, "Cannot create a widget with factory \""+ widgetType +"\", factory does not exists in widget manager!", "SWidgetManager::CreateWidget");
 
  return newWidget;
}
 
void SWidgetManager::DeleteWidget(SWidget* existingWidget)
{
  WidgetFactoryList::iterator iWidgetFactorySearched = widgetFactoryList.find(existingWidget->GetType());
  if(iWidgetFactorySearched != widgetFactoryList.end())
  {
    std::string widgetName = existingWidget->GetName();
    WidgetList::iterator iWidgetSearched = widgetList.find(widgetName);
    if(iWidgetSearched != widgetList.end())
    {
      // Check if our widget is an overlayed widget
      WidgetList::iterator iOverlayedWidgetSearched = overlayedWidgetList.find(widgetName);
      if(iOverlayedWidgetSearched != overlayedWidgetList.end())
        overlayedWidgetList.erase(iOverlayedWidgetSearched);
 
      // Unfocus this widget if it's the last focused.
      if(focusedWidget == existingWidget)
        UpdateFocusedWidget(0);
 
      WidgetInputList::iterator iInputList = inputList.begin();
      while (iInputList != inputList.end())
      {
        if (iInputList->second.widget == existingWidget)
          iInputList = inputList.erase(iInputList);
        else
          iInputList++;
      }
 
      // SWidget destructor should call UpdateWidgetsZOrder if needed (if widget is overlayed).
      iWidgetFactorySearched->second->DeleteWidget(existingWidget);
      widgetList.erase(widgetName);
    }
    else
      OGRE_EXCEPT(Ogre::Exception::ERR_ITEM_NOT_FOUND, "Cannot delete a widget named \""+ widgetName +"\", widget not found!", "SWidgetManager::DeleteWidget");
  }
  else
    OGRE_EXCEPT(Ogre::Exception::ERR_ITEM_NOT_FOUND, "Cannot delete a widget with factory \""+ existingWidget->GetType() +"\", factory does not exists in widget manager!", "SWidgetManager::DeleteWidget");
}
 
void SWidgetManager::InjectMouseMove(SWindow* originWindow, const int& xPos, const int& yPos, const MouseButtonId& button)
{
  int px = xPos;
  int py = yPos;
 
  originWindow->ToPixelPos(px, py);
 
  // Focus 3D widget (not overlayed) when mouse is over automaticaly.
  SWidget* widgetUnder = GetWidgetUnder(originWindow, px, py);
 
  if (widgetUnder != 0)
  {
    if (widgetUnder->GetMouseEnable())
    {
      if (widgetUnder->isOverlayed || widgetUnder->is2DRect)
      {
        SPointInt widgetPosition = widgetUnder->GetPosition();
        widgetUnder->InjectMouseMove(px - widgetPosition.x, py - widgetPosition.y, button);
 
        //MMechostr(MSKDEBUG, ">> InjectMouseMove from %i : %i to %i : %i\n", xPos, yPos, px - widgetPosition.x, py - widgetPosition.y);
        _FireMouseMoveWidgetEvent(widgetUnder, px - widgetPosition.x, py - widgetPosition.y, button);
      }
      else
      {
        SRaycastResult raycast = originWindow->GetLastRayCast();
        SPointInt injectPosition = ConvertTextureUvToWidgetCoordinates(widgetUnder, raycast.uvResult.x, raycast.uvResult.y);
        widgetUnder->InjectMouseMove(injectPosition.x, injectPosition.y, button);
 
        _FireMouseMoveWidgetEvent(widgetUnder, injectPosition.x, injectPosition.y, button);
      }
    }
  }
 
  // We want to inject mouse move to all overlayed widget, even if they are not focused.
  WidgetList::iterator iWidgetList = overlayedWidgetList.begin();
  while(iWidgetList != overlayedWidgetList.end())
  {
    // Ignore widgetUnder, cause we already sent event.
    if((iWidgetList->second != widgetUnder) && (iWidgetList->second->GetMouseEnable()))
    {
      SPointInt widgetPosition = iWidgetList->second->GetPosition();
      iWidgetList->second->InjectMouseMove(px - widgetPosition.x, py - widgetPosition.y, button);
 
      _FireMouseMoveWidgetEvent(iWidgetList->second, px - widgetPosition.x, py - widgetPosition.y, button);
    }
 
    iWidgetList++;
  }
}
 
void SWidgetManager::InjectMouseWheel(SWindow* originWindow, const int& scrollX, const int& scrollY, const int& relativeScroll)
{
  if(focusedWidget != 0)
    if(focusedWidget->GetMouseEnable())
    {
      // Point(0,0) is returned if it's not an overlayed widget, so it's safe to call GetPosition everytime.
      SPointInt widgetPosition = focusedWidget->GetPosition();
      focusedWidget->InjectMouseWheel(scrollX - widgetPosition.x, scrollY - widgetPosition.y, relativeScroll);
      _FireMouseWheelWidgetEvent(focusedWidget, scrollX - widgetPosition.x, scrollY - widgetPosition.y, relativeScroll);
    }
}
 
void SWidgetManager::InjectMouseDown(SWindow* originWindow, const int& xPos, const int& yPos, const MouseButtonId& button)
{
  int px = xPos;
  int py = yPos;
 
  originWindow->ToPixelPos(px, py);
 
  // Verify focused widget
  UpdateFocusedWidget(GetWidgetUnder(originWindow, px, py));
 
  if (focusedWidget != 0)
  {
    if (focusedWidget->GetMouseEnable())
    {
      int xRealPos = 0;
      int yRealPos = 0;
      if (focusedWidget->isOverlayed || focusedWidget->is2DRect)
      {
        SPointInt widgetPosition = focusedWidget->GetPosition();
        focusedWidget->InjectMouseDown(px - widgetPosition.x, py - widgetPosition.y, button);
 
        //MMechostr(MSKDEBUG, ">> InjectMouseDown from %i : %i to %i : %i\n", xPos, yPos, px - widgetPosition.x, py - widgetPosition.y);
        _FireMouseDownWidgetEvent(focusedWidget, px - widgetPosition.x, py - widgetPosition.y, button);
      }
      else
      {
        SRaycastResult raycast = originWindow->GetLastRayCast();
        SPointInt injectPosition = ConvertTextureUvToWidgetCoordinates(focusedWidget, raycast.uvResult.x, raycast.uvResult.y);
        focusedWidget->InjectMouseDown(injectPosition.x, injectPosition.y, button);
        _FireMouseDownWidgetEvent(focusedWidget, injectPosition.x, injectPosition.y, button);
      }
    }
  }
}
 
void SWidgetManager::InjectMouseUp(SWindow* originWindow, const int& xPos, const int& yPos, const MouseButtonId& button)
{
  int px = xPos;
  int py = yPos;
 
  originWindow->ToPixelPos(px, py);
 
  if (focusedWidget != 0)
  {
    if (focusedWidget->GetMouseEnable())
    {
      if (focusedWidget->isOverlayed || focusedWidget->is2DRect)
      {
        SPointInt widgetPosition = focusedWidget->GetPosition();
        focusedWidget->InjectMouseUp(px - widgetPosition.x, py - widgetPosition.y, button);
 
        //MMechostr(MSKDEBUG, ">> InjectMouseUp from %i : %i to %i : %i\n", xPos, yPos, px - widgetPosition.x, py - widgetPosition.y);
        _FireMouseUpWidgetEvent(focusedWidget, px - widgetPosition.x, py - widgetPosition.y, button);
      }
      else
      {
        SRaycastResult raycast = originWindow->GetLastRayCast();
        SPointInt injectPosition = ConvertTextureUvToWidgetCoordinates(focusedWidget, raycast.uvResult.x, raycast.uvResult.y);
        focusedWidget->InjectMouseUp(injectPosition.x, injectPosition.y, button);
        _FireMouseUpWidgetEvent(focusedWidget, injectPosition.x, injectPosition.y, button);
      }
    }
  }
}
 
void SWidgetManager::InjectTouchAdd(SWindow* originWindow, const int& xPos, const int& yPos, const int& touchid)
{
  int px = xPos;
  int py = yPos;
 
  originWindow->ToPixelPos(px, py);
 
  // Verify focused widget
  UpdateFocusedWidget(GetWidgetUnder(originWindow, px, py, touchid));
 
  WidgetInputList::iterator iTouchListSearched = inputList.find(touchid);
  if (iTouchListSearched == inputList.end())
    inputList.insert(WidgetInputList::value_type(touchid, INPUTInfo(touchid, px, py, focusedWidget)));
  else
  {
    iTouchListSearched->second.x = px;
    iTouchListSearched->second.y = py;
    iTouchListSearched->second.widget = focusedWidget;    
  }
 
  if (focusedWidget != 0)
  {
    if (focusedWidget->GetMouseEnable())
    {
      if (focusedWidget->isOverlayed || focusedWidget->is2DRect)
      {
        SPointInt widgetPosition = focusedWidget->GetPosition();
        focusedWidget->InjectTouchAdd(px - widgetPosition.x, py - widgetPosition.y, touchid);
        _FireTouchAddWidgetEvent(focusedWidget, px - widgetPosition.x, py - widgetPosition.y, touchid);
      }
      else
      {
        SRaycastResult raycast = originWindow->IndRayCast(px, py);
        SPointInt injectPosition = ConvertTextureUvToWidgetCoordinates(focusedWidget, raycast.uvResult.x, raycast.uvResult.y);
        focusedWidget->InjectTouchAdd(injectPosition.x, injectPosition.y, touchid);
        _FireTouchAddWidgetEvent(focusedWidget, injectPosition.x, injectPosition.y, touchid);
      }
    }
  }
}
 
void SWidgetManager::InjectTouchRemove(SWindow* originWindow, const int& touchid)
{
  WidgetInputList::iterator iTouchListSearched = inputList.find(touchid);
  if (iTouchListSearched == inputList.end())
    return;
  else
  {
    if (iTouchListSearched->second.widget != 0)
    {
      if (iTouchListSearched->second.widget->GetMouseEnable())
      {
        if (iTouchListSearched->second.widget->isOverlayed || iTouchListSearched->second.widget->is2DRect)
        {
          SPointInt widgetPosition = iTouchListSearched->second.widget->GetPosition();
          iTouchListSearched->second.widget->InjectTouchRemove(touchid);
          _FireTouchRemoveWidgetEvent(iTouchListSearched->second.widget, iTouchListSearched->second.x - widgetPosition.x, iTouchListSearched->second.y - widgetPosition.y, touchid);
        }
        else
        {
          SRaycastResult raycast = originWindow->IndRayCast(iTouchListSearched->second.x, iTouchListSearched->second.y);
          SPointInt injectPosition = ConvertTextureUvToWidgetCoordinates(focusedWidget, raycast.uvResult.x, raycast.uvResult.y);
 
          iTouchListSearched->second.widget->InjectTouchRemove(touchid);
          _FireTouchRemoveWidgetEvent(iTouchListSearched->second.widget, injectPosition.x, injectPosition.y, touchid);
        }
      }
 
      inputList.erase(iTouchListSearched);
    }
  }
}
 
void SWidgetManager::InjectTouchUpdate(SWindow* originWindow, const int& xPos, const int& yPos, const int& vx, const int& vy, const int& touchid)
{
  int px = xPos;
  int py = yPos;
 
  originWindow->ToPixelPos(px, py);
 
  WidgetInputList::iterator iTouchListSearched = inputList.find(touchid);
  if (iTouchListSearched == inputList.end())
    return;
  else
  {
    iTouchListSearched->second.x = px;
    iTouchListSearched->second.y = py;
    SWidget* widgetUnder = iTouchListSearched->second.widget;
 
    if (widgetUnder != 0)
    {
      if (widgetUnder->GetMouseEnable())
      {
        if (widgetUnder->isOverlayed || widgetUnder->is2DRect)
        {
          SPointInt widgetPosition = widgetUnder->GetPosition();
          widgetUnder->InjectTouchUpdate(px - widgetPosition.x, py - widgetPosition.y, vx, vy, touchid);
          _FireTouchUpdateWidgetEvent(widgetUnder, px - widgetPosition.x, py - widgetPosition.y, vx, vy, touchid);
        }
        else
        {
          SRaycastResult raycast = originWindow->IndRayCast(px, py);
          SPointInt injectPosition = ConvertTextureUvToWidgetCoordinates(widgetUnder, raycast.uvResult.x, raycast.uvResult.y);
          widgetUnder->InjectTouchUpdate(injectPosition.x, injectPosition.y, vx, vy, touchid);
          _FireTouchUpdateWidgetEvent(widgetUnder, injectPosition.x, injectPosition.y, vx, vy, touchid);
        }
      }
    }
  }
}
 
void SWidgetManager::InjectMouseMove(SWidget* widget, const SRaycastResult& raycast, const MouseButtonId& button, const int& id)
{
  // Manage enter/in events
  WidgetList::iterator iWidgetGlobalList = widgetList.begin();
  while (iWidgetGlobalList != widgetList.end())
  {
    SWidget* currentWidget = iWidgetGlobalList->second;
    if (!currentWidget->isOverlayed)
    {
      if ((widget == currentWidget)
        && (currentWidget->GetVisible())
        && (currentWidget->GetMouseEnable()))
      {
        // Manage enter/in events
        if (!currentWidget->GetInputOver(id))
          _FireEnterWidgetEvent(currentWidget, id);
        else
          _FireInsideWidgetEvent(currentWidget, id);
      }
      else if (currentWidget->GetInputOver(id))
      {
        _FireExitWidgetEvent(currentWidget, id);
      }
      else
      {
        // Manage exit events
        if (currentWidget->GetInputOver(id))
          _FireExitWidgetEvent(currentWidget, id);
      }
    }
    iWidgetGlobalList++;
  }
 
  if (widget && widget->GetMouseEnable() && !widget->isOverlayed && !widget->is2DRect)
  {
    SPointInt injectPosition = ConvertTextureUvToWidgetCoordinates(widget, raycast.uvResult.x, raycast.uvResult.y);
    widget->InjectMouseMove(injectPosition.x, injectPosition.y, button);
 
    _FireMouseMoveWidgetEvent(widget, injectPosition.x, injectPosition.y, button, id);
  }
}
 
void SWidgetManager::InjectMouseDown(SWidget* widget, const SRaycastResult& raycast, const MouseButtonId& button, const int& id)
{
  // Verify focused widget
  UpdateFocusedWidget(widget);
 
  if (focusedWidget != 0)
    if (focusedWidget->GetMouseEnable() && !focusedWidget->isOverlayed && !focusedWidget->is2DRect)
    {
      SPointInt injectPosition = ConvertTextureUvToWidgetCoordinates(focusedWidget, raycast.uvResult.x, raycast.uvResult.y);
 
      WidgetInputList::iterator iTouchListSearched = inputList.find(id);
      if (iTouchListSearched == inputList.end())
        inputList.insert(WidgetInputList::value_type(id, INPUTInfo(id, injectPosition.x, injectPosition.y, focusedWidget)));
      else
      {
        iTouchListSearched->second.x = injectPosition.x;
        iTouchListSearched->second.y = injectPosition.y;
        iTouchListSearched->second.widget = focusedWidget;
      }
 
      focusedWidget->InjectMouseDown(injectPosition.x, injectPosition.y, button);
      _FireMouseDownWidgetEvent(focusedWidget, injectPosition.x, injectPosition.y, button, id);
    }
}
 
void SWidgetManager::InjectMouseWheel(SWidget* widget, const SRaycastResult& raycast, const int& relativeScroll, const int& id)
{
  // Verify focused widget
  UpdateFocusedWidget(widget);
 
  if (focusedWidget != 0)
    if (focusedWidget->GetMouseEnable())
    {
      SPointInt injectPosition = ConvertTextureUvToWidgetCoordinates(focusedWidget, raycast.uvResult.x, raycast.uvResult.y);
      focusedWidget->InjectMouseWheel(injectPosition.x, injectPosition.y, relativeScroll);
      _FireMouseWheelWidgetEvent(focusedWidget, injectPosition.x, injectPosition.y, relativeScroll, id);
    }
}
 
void SWidgetManager::InjectMouseUp(const SRaycastResult& raycast, const MouseButtonId& button, const int& id)
{
  WidgetInputList::iterator iTouchListSearched = inputList.find(id);
  if (iTouchListSearched == inputList.end())
    return;
  else
  {
    SWidget* widgetUnder = iTouchListSearched->second.widget;
    if (widgetUnder != 0)
      if (widgetUnder->GetMouseEnable() && !widgetUnder->isOverlayed && !widgetUnder->is2DRect)
      {
        SPointInt injectPosition = ConvertTextureUvToWidgetCoordinates(widgetUnder, raycast.uvResult.x, raycast.uvResult.y);
        widgetUnder->InjectMouseUp(injectPosition.x, injectPosition.y, button);
        _FireMouseUpWidgetEvent(widgetUnder, injectPosition.x, injectPosition.y, button, id);
      }
    inputList.erase(iTouchListSearched);
  }
}
 
void SWidgetManager::InjectTouchAdd(SWidget* widget, const SRaycastResult& raycast, const int& touchid)
{
  // Verify focused widget
  UpdateFocusedWidget(widget);
 
  if (focusedWidget != 0)
    if (focusedWidget->GetMouseEnable() && !focusedWidget->isOverlayed && !focusedWidget->is2DRect)
    {
      SPointInt injectPosition = ConvertTextureUvToWidgetCoordinates(focusedWidget, raycast.uvResult.x, raycast.uvResult.y);
      focusedWidget->InjectTouchAdd(injectPosition.x, injectPosition.y, touchid);
      _FireTouchAddWidgetEvent(focusedWidget, injectPosition.x, injectPosition.y, touchid);
    }
}
 
void SWidgetManager::InjectTouchRemove(SWidget* widget, const SRaycastResult& raycast, const int& touchid)
{
  if (focusedWidget != 0)
    if (focusedWidget->GetMouseEnable() && !focusedWidget->isOverlayed && !focusedWidget->is2DRect)
    {
      SPointInt injectPosition = ConvertTextureUvToWidgetCoordinates(focusedWidget, raycast.uvResult.x, raycast.uvResult.y);
      focusedWidget->InjectTouchRemove(touchid);
      _FireTouchRemoveWidgetEvent(focusedWidget, injectPosition.x, injectPosition.y, touchid);
    }
}
 
void SWidgetManager::InjectTouchUpdate(SWidget* widget, const SRaycastResult& raycast, const int& touchid)
{
  // Manage enter/in events
  WidgetList::iterator iWidgetGlobalList = widgetList.begin();
  while (iWidgetGlobalList != widgetList.end())
  {
    SWidget* currentWidget = iWidgetGlobalList->second;
    if (!currentWidget->isOverlayed)
    {
      if ((widget == currentWidget)
        && (currentWidget->GetVisible())
        && (currentWidget->GetMouseEnable()))
      {
        // Manage enter/in events
        if (!currentWidget->GetInputOver(touchid))
          _FireEnterWidgetEvent(currentWidget, touchid);
        else
          _FireInsideWidgetEvent(currentWidget, touchid);
      }
      else if (currentWidget->GetInputOver(touchid))
      {
        _FireExitWidgetEvent(currentWidget, touchid);
      }
      else
      {
        // Manage exit events
        if (currentWidget->GetInputOver(touchid))
          _FireExitWidgetEvent(currentWidget, touchid);
      }
    }
    iWidgetGlobalList++;
  }
 
  if (widget && widget->GetMouseEnable() && !widget->isOverlayed && !widget->is2DRect)
  {
    SPointInt injectPosition = ConvertTextureUvToWidgetCoordinates(widget, raycast.uvResult.x, raycast.uvResult.y);
    widget->InjectTouchUpdate(injectPosition.x, injectPosition.y, 0, 0, touchid);
 
    _FireTouchUpdateWidgetEvent(widget, injectPosition.x, injectPosition.y, 0, 0, touchid);
  }
}
 
void SWidgetManager::InjectKeyEvent(const UINT& msg, const ScolWindowHandle& hwnd, const WPARAM& wParam, const LPARAM& lParam)
{
  if(focusedWidget != 0)
    if(focusedWidget->GetKeyboardEnable())
    {
      focusedWidget->InjectKeyEvent(msg, hwnd, wParam, lParam);
      _FireKeyWidgetEvent(focusedWidget, msg, hwnd, wParam, lParam);
    }
}
 
void SWidgetManager::InjectTextEvent(const std::string& text)
{
  if(focusedWidget != 0)
    focusedWidget->InjectTextEvent(text);
}
 
void SWidgetManager::UpdateWidgetsZOrder()
{
  // The map orders the elements by their keys using a stored function key_compare, which simply does a less-than comparison.
  std::multimap<unsigned short, SWidget*> widgetListForeground;
  std::multimap<unsigned short, SWidget*> widgetListNotForeground;
  widgetListByZOrder.clear();
 
  // First, we need to separate widgets that have foreground flag from those who don't.
  WidgetList::iterator iWidgetList = overlayedWidgetList.begin();
  while(iWidgetList != overlayedWidgetList.end())
  {
    if(iWidgetList->second->GetForeground())
      widgetListForeground.insert(std::multimap<unsigned short, SWidget*>::value_type(iWidgetList->second->GetZOrder(), iWidgetList->second));
    else
      widgetListNotForeground.insert(std::multimap<unsigned short, SWidget*>::value_type(iWidgetList->second->GetZOrder(), iWidgetList->second));
 
    iWidgetList++;
  }
 
  // Continuing to set zOrder with foreground widgets.
  unsigned short zOrder = 650;
  unsigned short topOnFocusZOrder = zOrder;
  // Reserve the next zOrder for set eventually the focused "top on focus" widget".
  zOrder--;
 
  std::multimap<unsigned short, SWidget*>::reverse_iterator iOrderedWidgetIterator = widgetListForeground.rbegin();
  while(iOrderedWidgetIterator != widgetListForeground.rend())
  {
    SWidget* currentWidget = iOrderedWidgetIterator->second;
    bool forceZOrder = false;
 
    // If a focused "get on top on focus" overlay is detected, set the higher overlay to him.
    if (currentWidget == focusedWidget)
      if (currentWidget->GetTopOnFocus())
      {
        currentWidget->_SetOgreOverlayZOrder(topOnFocusZOrder);
        widgetListByZOrder.insert(WidgetListByZOrder::value_type(topOnFocusZOrder, currentWidget));
        forceZOrder = true;
      }
 
    // Normal zOrder
    if (!forceZOrder)
    {
      currentWidget->_SetOgreOverlayZOrder(zOrder);
      widgetListByZOrder.insert(WidgetListByZOrder::value_type(zOrder, currentWidget));
 
      // up to 650 ordered overlays, other are all at the same zOrder
      if (zOrder > 0)
        zOrder--;
    }
    iOrderedWidgetIterator++;
    zOrder--;
  }
 
  // Reserve the next zOrder for set eventually the focused "top on focus" widget".
  topOnFocusZOrder = zOrder;
  if(zOrder > 0)
    zOrder--;
 
  // Then set zOrder with no foreground widgets.
  iOrderedWidgetIterator = widgetListNotForeground.rbegin();
  while(iOrderedWidgetIterator != widgetListNotForeground.rend())
  {
    SWidget* currentWidget = iOrderedWidgetIterator->second;
    bool forceZOrder = false;
 
    // If a focused "get on top on focus" overlay is detected, set the higher overlay to him.
    if(currentWidget == focusedWidget)
      if(currentWidget->GetTopOnFocus())
      {
        currentWidget->_SetOgreOverlayZOrder(topOnFocusZOrder);
        widgetListByZOrder.insert(WidgetListByZOrder::value_type(topOnFocusZOrder, currentWidget));
        forceZOrder = true;
      }
 
    // Normal zOrder
    if(!forceZOrder)
    {
      currentWidget->_SetOgreOverlayZOrder(zOrder);
      widgetListByZOrder.insert(WidgetListByZOrder::value_type(zOrder, currentWidget));
 
      // up to 650 ordered overlays, other are all at the same zOrder
      if(zOrder > 0)
        zOrder--;
    }
 
    iOrderedWidgetIterator++;
  }
}
 
void SWidgetManager::UpdateFocusedWidget(SWidget* focusTargetedWidget)
{
  if (focusTargetedWidget == focusedWidget)
    return;
 
  //previous focused widget
  if (focusedWidget)
  {
    focusedWidget->SetFocusImpl(false);
    _FireFocusWidgetEvent(focusedWidget, false);
  }
 
  //focus the new widget
  focusedWidget = focusTargetedWidget;
  if (focusedWidget)
  {
    focusedWidget->SetFocusImpl(true);
    _FireFocusWidgetEvent(focusedWidget, true);
  }
 
  UpdateWidgetsZOrder();
}
 
SWidget* SWidgetManager::GetFocusedWidget()
{
  return focusedWidget;
}
 
SWidget* SWidgetManager::GetWidgetUnder(SWindow* originWindow, const int& posX, const int& posY, const int& id)
{
  SWidget* returnWidget = 0;
 
  // Overlayed widget are over all other one, so start mouse detection with overlayed widget.
  WidgetListByZOrder::reverse_iterator iWidgetList = widgetListByZOrder.rbegin();
  while(iWidgetList != widgetListByZOrder.rend())
  {
    // Easy check for overlayed components
    SWidget* currentWidget = iWidgetList->second;
    SPoint<int> position = currentWidget->GetPosition();
    unsigned short widgetWidth = currentWidget->GetWidth();
    unsigned short widgetHeight = currentWidget->GetHeight();
 
    if((posX >= position.x)
    && (posY >= position.y)
    && (posX <= (position.x + widgetWidth))
    && (posY <= (position.y + widgetHeight))
    && (currentWidget->GetVisible())
    && (currentWidget->GetMouseEnable()))
    {
      if (currentWidget->isTransparent && currentWidget->transparentIgnorePixels)
      {
        if (currentWidget->CheckPixelAlpha(posX - position.x, posY - position.y) && !returnWidget)
        {
          // Manage enter/in events
          if(!currentWidget->GetInputOver(id))
            _FireEnterWidgetEvent(currentWidget, id);
          else
            _FireInsideWidgetEvent(currentWidget, id);
 
          // Set this widget as the first found under mouse coordonates
          returnWidget = currentWidget;
        }
        else
        {
          // Manage exit events
          if(currentWidget->GetInputOver(id))
            _FireExitWidgetEvent(currentWidget, id);
        }
      }
      else if (!returnWidget)
      {
        // Manage enter/in events
        if(!currentWidget->GetInputOver(id))
          _FireEnterWidgetEvent(currentWidget, id);
        else
          _FireInsideWidgetEvent(currentWidget, id);
 
        // Set this widget as the first found under mouse coordonates
        returnWidget = currentWidget;
      }
      else
      {
        // Manage exit events
        if (currentWidget->GetInputOver(id))
          _FireExitWidgetEvent(currentWidget, id);
      }
    }
    else
    {
      // Manage exit events
      if(currentWidget->GetInputOver(id))
        _FireExitWidgetEvent(currentWidget, id);
    }
 
    iWidgetList++;
  }
 
  // If no overlayed widget was found under mouse, continue the checking with material widgets
  WidgetList::iterator iWidgetGlobalList = widgetList.begin();
  while(iWidgetGlobalList != widgetList.end())
  {
    SWidget* currentWidget = iWidgetGlobalList->second;
    if(!currentWidget->isOverlayed)
    {
      // Not very efficient, but we can have more than one scene.
      SMaterial* materialUnderMouse = originWindow->GetLastRayCast().material;
      if(materialUnderMouse != 0)
      {
        if ((materialUnderMouse->GetAssociatedWidget() == currentWidget) && !returnWidget)
        {
          // Manage enter/in events
          if(!currentWidget->GetInputOver(id))
            _FireEnterWidgetEvent(currentWidget);
          else
            _FireInsideWidgetEvent(currentWidget);
 
          // Set this widget as the first found under mouse coordonates
          returnWidget = currentWidget;
        }
        else if(currentWidget->GetInputOver(id))
        {
          _FireExitWidgetEvent(currentWidget, id);
        }
      }
      else
      {
        // Manage exit events
        if(currentWidget->GetInputOver(id))
          _FireExitWidgetEvent(currentWidget, id);
      }
    }
    iWidgetGlobalList++;
  }
 
  return returnWidget;
}
 
void SWidgetManager::AddWidgetListener(SWidgetListener* newWidgetListener)
{
  if(widgetListenerList.count(newWidgetListener))
    OGRE_EXCEPT(Ogre::Exception::ERR_DUPLICATE_ITEM, "Cannot add this listener, it already exists in the listener list!", "SWidgetManager::AddWidgetListener");
 
  widgetListenerList.insert(newWidgetListener);
}
 
void SWidgetManager::RemoveWidgetListener(SWidgetListener* existingWidgetListener)
{
  if(!widgetListenerList.count(existingWidgetListener))
    OGRE_EXCEPT(Ogre::Exception::ERR_DUPLICATE_ITEM, "Cannot remove listener, this listener does not exists in the listener list!", "SWidgetManager::RemoveWidgetListener");
 
  widgetListenerList.erase(existingWidgetListener);
}
 
void SWidgetManager::_FireEnterWidgetEvent(SWidget* targetedWidget, const int& id)
{
  bool prev = targetedWidget->GetMouseOver();
  targetedWidget->SetInputOver(id, true);
  if (targetedWidget->GetMouseOver() != prev)
  {
    WidgetListenerList::iterator iWidgetListenerList = widgetListenerList.begin();
    while (iWidgetListenerList != widgetListenerList.end())
    {
      //MMechostr(MSKDEBUG, ">> OnEnter\n");
      (*iWidgetListenerList)->OnEnter(targetedWidget);
      iWidgetListenerList++;
    }
  }
}
 
void SWidgetManager::_FireInsideWidgetEvent(SWidget* targetedWidget, const int& id)
{
  if (targetedWidget->GetInputOver(id))
  {
    WidgetListenerList::iterator iWidgetListenerList = widgetListenerList.begin();
    while (iWidgetListenerList != widgetListenerList.end())
    {
      //MMechostr(MSKDEBUG, ">> OnInside\n");
      (*iWidgetListenerList)->OnInside(targetedWidget);
      iWidgetListenerList++;
    }
  }
}
 
void SWidgetManager::_FireExitWidgetEvent(SWidget* targetedWidget, const int& id)
{
  bool prev = targetedWidget->GetMouseOver();
  targetedWidget->SetInputOver(id, false);
 
  if (targetedWidget->GetMouseOver() != prev)
  {
    WidgetListenerList::iterator iWidgetListenerList = widgetListenerList.begin();
    while (iWidgetListenerList != widgetListenerList.end())
    {
      //MMechostr(MSKDEBUG, ">> OnExit\n");
      (*iWidgetListenerList)->OnExit(targetedWidget);
      iWidgetListenerList++;
    }
  }
}
 
void SWidgetManager::_FireMouseMoveWidgetEvent(SWidget* targetedWidget, const int& mousePosX, const int& mousePosY, const MouseButtonId& mouseButton, const int& id)
{
  WidgetListenerList::iterator iWidgetListenerList = widgetListenerList.begin();
  while(iWidgetListenerList != widgetListenerList.end())
  {
    (*iWidgetListenerList)->OnMouseMove(targetedWidget, mousePosX, mousePosY, mouseButton, id);
    iWidgetListenerList++;
  }
}
 
void SWidgetManager::_FireMouseDownWidgetEvent(SWidget* targetedWidget, const int& mousePosX, const int& mousePosY, const MouseButtonId& mouseButton, const int& id)
{
  WidgetListenerList::iterator iWidgetListenerList = widgetListenerList.begin();
  while(iWidgetListenerList != widgetListenerList.end())
  {
    (*iWidgetListenerList)->OnMouseDown(targetedWidget, mousePosX, mousePosY, mouseButton, id);
    iWidgetListenerList++;
  }
}
 
void SWidgetManager::_FireMouseUpWidgetEvent(SWidget* targetedWidget, const int& mousePosX, const int& mousePosY, const MouseButtonId& mouseButton, const int& id)
{
  WidgetListenerList::iterator iWidgetListenerList = widgetListenerList.begin();
  while(iWidgetListenerList != widgetListenerList.end())
  {
    (*iWidgetListenerList)->OnMouseUp(targetedWidget, mousePosX, mousePosY, mouseButton, id);
    iWidgetListenerList++;
  }
}
 
void SWidgetManager::_FireMouseWheelWidgetEvent(SWidget* targetedWidget, const int& mousePosX, const int& mousePosY, const int& relativeScroll, const int& id)
{
  WidgetListenerList::iterator iWidgetListenerList = widgetListenerList.begin();
  while(iWidgetListenerList != widgetListenerList.end())
  {
    (*iWidgetListenerList)->OnMouseWheel(targetedWidget, mousePosX, mousePosY, relativeScroll, id);
    iWidgetListenerList++;
  }
}
 
void SWidgetManager::_FireTouchAddWidgetEvent(SWidget* targetedWidget, const int& mousePosX, const int& mousePosY, const int& touchid)
{
  WidgetListenerList::iterator iWidgetListenerList = widgetListenerList.begin();
  while (iWidgetListenerList != widgetListenerList.end())
  {
    (*iWidgetListenerList)->OnTouchAdd(targetedWidget, mousePosX, mousePosY, touchid);
    iWidgetListenerList++;
  }
}
 
void SWidgetManager::_FireTouchRemoveWidgetEvent(SWidget* targetedWidget, const int& mousePosX, const int& mousePosY, const int& touchid)
{
  WidgetListenerList::iterator iWidgetListenerList = widgetListenerList.begin();
  while (iWidgetListenerList != widgetListenerList.end())
  {
    (*iWidgetListenerList)->OnTouchRemove(targetedWidget, mousePosX, mousePosY, touchid);
    iWidgetListenerList++;
  }
}
 
void SWidgetManager::_FireTouchUpdateWidgetEvent(SWidget* targetedWidget, const int& mousePosX, const int& mousePosY, const int& vx, const int& vy, const int& touchid)
{
  WidgetListenerList::iterator iWidgetListenerList = widgetListenerList.begin();
  while (iWidgetListenerList != widgetListenerList.end())
  {
    (*iWidgetListenerList)->OnTouchUpdate(targetedWidget, mousePosX, mousePosY, vx, vy, touchid);
    iWidgetListenerList++;
  }
}
 
void SWidgetManager::_FireKeyWidgetEvent(SWidget* targetedWidget, const UINT& msg, const ScolWindowHandle& hwnd, const UINT& wParam, const LONG& lParam)
{
  WidgetListenerList::iterator iWidgetListenerList = widgetListenerList.begin();
  while(iWidgetListenerList != widgetListenerList.end())
  {
    (*iWidgetListenerList)->OnKey(targetedWidget, msg, hwnd, wParam, lParam);
    iWidgetListenerList++;
  }
}
 
void SWidgetManager::_FireFocusWidgetEvent(SWidget* targetedWidget, const bool& focused)
{
  WidgetListenerList::iterator iWidgetListenerList = widgetListenerList.begin();
  while(iWidgetListenerList != widgetListenerList.end())
  {
    (*iWidgetListenerList)->OnFocus(targetedWidget, focused);
    iWidgetListenerList++;
  }
}
 
void SWidgetManager::_FireScriptWidgetEvent(SWidget* targetedWidget, const SScriptFunction& functionCalled)
{
  WidgetListenerList::iterator iWidgetListenerList = widgetListenerList.begin();
  while(iWidgetListenerList != widgetListenerList.end())
  {
    (*iWidgetListenerList)->OnScriptCall(targetedWidget, functionCalled);
    iWidgetListenerList++;
  }
}
 
void SWidgetManager::_FireOnLoadStart(SWidget* targetedWidget)
{
  WidgetListenerList::iterator iWidgetListenerList = widgetListenerList.begin();
  while(iWidgetListenerList != widgetListenerList.end())
  {
    (*iWidgetListenerList)->OnLoadStart(targetedWidget);
    iWidgetListenerList++;
  }
}
 
void SWidgetManager::_FireOnLoadEnd(SWidget* targetedWidget)
{
  WidgetListenerList::iterator iWidgetListenerList = widgetListenerList.begin();
  while(iWidgetListenerList != widgetListenerList.end())
  {
    (*iWidgetListenerList)->OnLoadEnd(targetedWidget);
    iWidgetListenerList++;
  }
}
 
void SWidgetManager::_FireOnLoadError(SWidget* targetedWidget, const int& errorCode, const std::string& failedUrl)
{
  WidgetListenerList::iterator iWidgetListenerList = widgetListenerList.begin();
  while(iWidgetListenerList != widgetListenerList.end())
  {
    (*iWidgetListenerList)->OnLoadError(targetedWidget, errorCode, failedUrl);
    iWidgetListenerList++;
  }
}
 
SPointInt SWidgetManager::ConvertTextureUvToWidgetCoordinates(SWidget* targetedWidget, const float& uCoor, const float& vCoor)
{
  // Keep only the floating point value, discard integer value (modf keep the sign)
  double discardedIntValue = 0.0f;
  float uCoordinates = uCoor;
  float vCoordinates = vCoor;
  uCoordinates = (float)(modf((double)uCoordinates, &discardedIntValue));
  vCoordinates = (float)(modf((double)vCoordinates, &discardedIntValue));
 
  // Handle negative uv.
  if(uCoordinates < 0)
    uCoordinates += 1.0f;
  if(vCoordinates < 0)
    vCoordinates += 1.0f;
 
  // Compute widget relative position
  SPointInt widgetSpacePosition;
  widgetSpacePosition.x = static_cast <int> (uCoordinates * targetedWidget->GetWidth());
  widgetSpacePosition.y = static_cast <int> (vCoordinates * targetedWidget->GetHeight());
  return widgetSpacePosition;
}
 
}