SO3Engine/SO3Renderer/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) 2010 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

You may alternatively use this source under the terms of a specific version of
the OpenSpace3D Unrestricted License provided you have obtained such a license from
I-maginer.
-----------------------------------------------------------------------------
*/

#include "SO3WidgetManager.h"
#include "../SO3SceneGraph/SO3Scene.h"
#include "../SO3Renderer/SO3Window.h"
#include <Ogre.h>

namespace Ogre
{
  //Singleton instance
  template<> SO3::SWidgetManager* Ogre::Singleton<SO3::SWidgetManager>::ms_Singleton = 0;
}

namespace SO3
{

SWidgetManager* SWidgetManager::getSingletonPtr()
{
        return ms_Singleton;
}

SWidgetManager& SWidgetManager::getSingleton()
{
        assert(ms_Singleton);
  return (*ms_Singleton);
}

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();
}

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(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, std::string widgetName, int xPos, int yPos, unsigned short width, unsigned short height, SViewPort* targetViewport, unsigned int widgetZOrder, 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, std::string widgetName, int xPos, int yPos, unsigned short width, unsigned short height, SViewPort* targetViewport, 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, std::string widgetName, unsigned short width, unsigned short height, SMaterial* targetMaterial, unsigned short targetTechnique, unsigned short targetPass, unsigned short targetTextureUnit, 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);

      // 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, int xPos, int yPos, MouseButtonId button)
{
  // Focus 3D widget (not overlayed) when mouse is over automaticaly.
  SWidget* widgetUnder = GetWidgetUnder(originWindow, xPos, yPos);

  if(widgetUnder != 0)
    if(widgetUnder->GetMouseEnable())
      if(widgetUnder->isOverlayed)
      {
        widgetUnder->InjectMouseMove(xPos, yPos, button);
      }
      else
      {
        SRaycastResult raycast = originWindow->GetLastRayCast();
        unsigned int leftPos = static_cast <int> (raycast.uvResult.x * widgetUnder->GetWidth());
        unsigned int topPos  = static_cast <int> (raycast.uvResult.y * widgetUnder->GetHeight());
        widgetUnder->InjectMouseMove(leftPos, topPos, 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()))
      iWidgetList->second->InjectMouseMove(xPos, yPos, button);
    
    iWidgetList++;
  }
}

void SWidgetManager::InjectMouseWheel(SWindow* originWindow, int scrollX, int scrollY, int relativeScroll)
{
  if(focusedWidget != 0)
    if(focusedWidget->GetMouseEnable())
    {
      focusedWidget->InjectMouseWheel(scrollX, scrollY, relativeScroll);
      _FireMouseWheelWidgetEvent(focusedWidget, relativeScroll);
    }
}

void SWidgetManager::InjectMouseDown(SWindow* originWindow, int xPos, int yPos, MouseButtonId button)
{
  // Verify focused widget
  UpdateFocusedWidget(GetWidgetUnder(originWindow, xPos, yPos));

  if(focusedWidget != 0)
    if(focusedWidget->GetMouseEnable())
    {
      if(focusedWidget->isOverlayed)
      {
        focusedWidget->InjectMouseDown(xPos, yPos, button);
      }
      else
      {
        SRaycastResult raycast = originWindow->GetLastRayCast();
        unsigned int leftPos = static_cast <int> (raycast.uvResult.x * focusedWidget->GetWidth());
        unsigned int topPos  = static_cast <int> (raycast.uvResult.y * focusedWidget->GetHeight());
        focusedWidget->InjectMouseDown(leftPos, topPos, button);
      }

      _FireMouseDownWidgetEvent(focusedWidget, xPos, yPos, button);
    }
}

void SWidgetManager::InjectMouseUp(SWindow* originWindow, int xPos, int yPos, MouseButtonId button)
{
  if(focusedWidget != 0)
    if(focusedWidget->GetMouseEnable())
    {
      if(focusedWidget->isOverlayed)
      {
        focusedWidget->InjectMouseUp(xPos, yPos, button);
      }
      else
      {
        SRaycastResult raycast = originWindow->GetLastRayCast();
        unsigned int leftPos = static_cast <int> (raycast.uvResult.x * focusedWidget->GetWidth());
        unsigned int topPos  = static_cast <int> (raycast.uvResult.y * focusedWidget->GetHeight());
        focusedWidget->InjectMouseUp(leftPos, topPos, button);
      }

      _FireMouseUpWidgetEvent(focusedWidget, xPos, yPos, button);
    }
}

void SWidgetManager::InjectKeyEvent(UINT msg, WindowHandle hwnd, WPARAM wParam, LPARAM lParam)
{
  if(focusedWidget != 0)
    if(focusedWidget->GetKeyboardEnable())
      focusedWidget->InjectKeyEvent(msg, hwnd, wParam, lParam);
}

void SWidgetManager::InjectTextEvent(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;
  std::multimap<unsigned short, SWidget*>::reverse_iterator iOrderedWidgetIterator = widgetListForeground.rbegin();
  while(iOrderedWidgetIterator != widgetListForeground.rend())
  {
    SWidget* currentWidget = iOrderedWidgetIterator->second;
    currentWidget->_SetOgreOverlayZOrder(zOrder);
    widgetListByZOrder.insert(WidgetListByZOrder::value_type(zOrder, currentWidget));
    iOrderedWidgetIterator++;
    zOrder--;
  }

  // Reserve the next zOrder for set eventually the focused "top on focus" widget".
  unsigned short 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)
{
  focusedWidget = 0;
  WidgetList::iterator iWidgetList = widgetList.begin();
  while (iWidgetList != widgetList.end())
  {
    SWidget* currentWidget = iWidgetList->second;
    if(currentWidget == focusTargetedWidget)
    {
      currentWidget->SetFocusImpl(true);
      focusedWidget = focusTargetedWidget;
    }
    else
      currentWidget->SetFocusImpl(false);

    iWidgetList++;
  }

  UpdateWidgetsZOrder();
}

SWidget* SWidgetManager::GetFocusedWidget()
{
  return focusedWidget;
}

SWidget* SWidgetManager::GetWidgetUnder(SWindow* originWindow, int posX, int posY)
{
  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->GetPixelUnder(posX - position.x, posY - position.y) != -1)
        {
          // Manage enter/in events
          if(!currentWidget->mouseIsOver)
            _FireEnterWidgetEvent(currentWidget);
          else
            _FireInsideWidgetEvent(currentWidget);

          // Set this widget as the first found under mouse coordonates
          if(returnWidget == 0)
            returnWidget = currentWidget;
        }
        else
        {
          // Manage exit events
          if(currentWidget->mouseIsOver)
            _FireExitWidgetEvent(currentWidget);
        }
      }
      else
      {
        // Manage enter/in events
        if(!currentWidget->mouseIsOver)
          _FireEnterWidgetEvent(currentWidget);
        else
          _FireInsideWidgetEvent(currentWidget);

        // Set this widget as the first found under mouse coordonates
        if(returnWidget == 0)
          returnWidget = currentWidget;
      }
    }
    else
    {
      // Manage exit events
      if(currentWidget->mouseIsOver)
        _FireExitWidgetEvent(currentWidget);
    }

    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)
        {
          // Manage enter/in events
          if(!currentWidget->mouseIsOver)
            _FireEnterWidgetEvent(currentWidget);
          else
            _FireInsideWidgetEvent(currentWidget);

          // Set this widget as the first found under mouse coordonates
          if(returnWidget == 0)
            returnWidget = currentWidget;
        }
      }
      else
      {
        // Manage exit events
        if(currentWidget->mouseIsOver)
          _FireExitWidgetEvent(currentWidget);
      }
    }
    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)
{
  targetedWidget->mouseIsOver = true;
  WidgetListenerList::iterator iWidgetListenerList = widgetListenerList.begin();
  while(iWidgetListenerList != widgetListenerList.end())
  {
    (*iWidgetListenerList)->OnEnter(targetedWidget);
    iWidgetListenerList++;
  }
}

void SWidgetManager::_FireInsideWidgetEvent(SWidget* targetedWidget)
{
  WidgetListenerList::iterator iWidgetListenerList = widgetListenerList.begin();
  while(iWidgetListenerList != widgetListenerList.end())
  {
    (*iWidgetListenerList)->OnInside(targetedWidget);
    iWidgetListenerList++;
  }
}

void SWidgetManager::_FireExitWidgetEvent(SWidget* targetedWidget)
{
  targetedWidget->mouseIsOver = false;
  WidgetListenerList::iterator iWidgetListenerList = widgetListenerList.begin();
  while(iWidgetListenerList != widgetListenerList.end())
  {
    (*iWidgetListenerList)->OnExit(targetedWidget);
    iWidgetListenerList++;
  }
}

void SWidgetManager::_FireMouseDownWidgetEvent(SWidget* targetedWidget, int mousePosX, int mousePosY, MouseButtonId mouseButton)
{
  WidgetListenerList::iterator iWidgetListenerList = widgetListenerList.begin();
  while(iWidgetListenerList != widgetListenerList.end())
  {
    (*iWidgetListenerList)->OnMouseDown(targetedWidget, mousePosX, mousePosY, mouseButton);
    iWidgetListenerList++;
  }
}

void SWidgetManager::_FireMouseUpWidgetEvent(SWidget* targetedWidget, int mousePosX, int mousePosY, MouseButtonId mouseButton)
{
  WidgetListenerList::iterator iWidgetListenerList = widgetListenerList.begin();
  while(iWidgetListenerList != widgetListenerList.end())
  {
    (*iWidgetListenerList)->OnMouseUp(targetedWidget, mousePosX, mousePosY, mouseButton);
    iWidgetListenerList++;
  }
}

void SWidgetManager::_FireMouseWheelWidgetEvent(SWidget* targetedWidget, int relativeScroll)
{
  WidgetListenerList::iterator iWidgetListenerList = widgetListenerList.begin();
  while(iWidgetListenerList != widgetListenerList.end())
  {
    (*iWidgetListenerList)->OnMouseWheel(targetedWidget, relativeScroll);
    iWidgetListenerList++;
  }
}

void SWidgetManager::_FireScriptWidgetEvent(SWidget* targetedWidget, SWidget::WidgetScriptFunction functionCalled)
{
  WidgetListenerList::iterator iWidgetListenerList = widgetListenerList.begin();
  while(iWidgetListenerList != widgetListenerList.end())
  {
    (*iWidgetListenerList)->OnScriptCall(targetedWidget, functionCalled);
    iWidgetListenerList++;
  }
}

}

---