Hikari.cpp

Go to the documentation of this file.

/*
  This file is part of Hikari, a library that allows developers
  to use Flash in their Ogre3D applications.
 
  Copyright (C) 2008 Adam J. Simmons
 
  This library 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.1 of the License, or (at your option) any later version.
 
  This library 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 library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
/****************************************************************************************************
  ___ ___ .__ __                 .__
  /   |   \|__|  | _______ _______|__|
  /    ~    \  |  |/ /\__  \\_  __ \  |
  \    Y    /  |    <  / __ \|  | \/  |
  \___|_  /|__|__|_ \‍(____  /__|  |__|  v0.4
  \/         \/     \/
 
 
  * Zed Games PC Development Team - Jaime Crespillo Vilchez (jcrespillo@zed.com)
  * Build: 0.1 - Date: 13/10/2008
  * Undocked version of Hikari Lib
  * Brief: Removed createFlashOverlay methods, added setFlashControl, new interface class IFlashControl
  ******************************************************************************************************/
 
#include "External/hikari/Hikari.h"
#include "External/hikari/impl/KeyboardHook.h"
#include <objbase.h>
#include <direct.h>
#include <stdlib.h>
#include <string>
#include <vector>
#include <windows.h>
 
using namespace Hikari;
//Singleton instance
HikariManager* HikariManager::mInstance = NULL;
 
// freak function to know our system path
std::string HikariManager::getCurrentWorkingDirectory()
{
  std::string workingDirectory = "";
  char currentPath[_MAX_PATH];
  _getcwd(currentPath, _MAX_PATH);
  workingDirectory = currentPath;
 
  return workingDirectory + "\\";
}
 
HikariManager::HikariManager() : focusedControl(0), mouseXPos(0), mouseYPos(0),
mouseButtonRDown(false), flashLib(0), keyboardHook(0)
{
  if (mInstance)
    return;
 
  HRESULT r = CoInitializeEx(NULL, COINIT_MULTITHREADED);
  //HRESULT r = CoInitialize(0);
 
  OleInitialize(0);
 
  // Attempt to load 'Flash.ocx', it's alrite if this fails, we have a fallback strategy
  std::string workingDirectory = getCurrentWorkingDirectory();
 
  flashLib = LoadLibrary((workingDirectory + "Flash.ocx").c_str());
 
  keyboardHook = new Hikari::Impl::KeyboardHook();
 
  mInjectingKeyboardToFlash = false;
 
  mInstance = this;
}
 
HikariManager::~HikariManager()
{
  /*************************************************************************************
  * we could not delete IFlashControl objects in this layer of app to avoid destructor errors
  * client app must do this job for each FlashControl. Just clear the objects Map.
  ***************************************************************************************
 
  for(ControlMap::iterator i = controls.begin(); i != controls.end();)
  {
  IFlashControl* toDelete = i->second;
  i = controls.erase(i);
  delete toDelete;
  }
  ***************************************************************************************/
  deleteControls();
 
  if (keyboardHook)
    delete keyboardHook;
 
  /**************************************************************************************
  * we can not get free flashLib cause Vision crash when unload shared dlls */
  //if(flashLib) FreeLibrary(flashLib);
  /***************************************************************************************/
 
  CoUninitialize();
 
  mInstance = 0;
}
 
bool HikariManager::isKeyboardOnGUI()
{
  return mInjectingKeyboardToFlash;
}
 
HikariManager& HikariManager::getSingleton()
{
  if (!mInstance)
    mInstance = new HikariManager();
 
  return *mInstance;
}
 
HikariManager* HikariManager::getSingletonPtr()
{
  if (!mInstance)
    mInstance = new HikariManager();
 
  return mInstance;
}
 
void HikariManager::setPath(const std::string& assetsDirectory){
 
  std::string workingDirectory = getCurrentWorkingDirectory();
  this->basePath = workingDirectory + assetsDirectory;
 
  if (this->basePath.at(this->basePath.length() - 1) != '\\')
    this->basePath.push_back('\\');
}
 
 
void HikariManager::destroyFlashControl(IFlashControl* controlToDestroy)
{
  if (controlToDestroy){
    ControlMap::iterator iter = controls.find(controlToDestroy->name);
    if (iter != controls.end())
      iter = controls.erase(iter);
 
    if (focusedControl == controlToDestroy)
      focusedControl = 0;
  }
}
 
void HikariManager::destroyFlashControl(const std::string& controlName)
{
  IFlashControl* control = getFlashControl(controlName);
  if (control)
    control->okayToDelete = true;
}
 
void HikariManager::destroyAllControls()
{
  for (ControlMap::iterator iter = controls.begin(); iter != controls.end(); iter++)
    iter->second->okayToDelete = true;
 
  focusedControl = 0;
}
 
void HikariManager::deleteControls()
{
  if (controls.size() > 0){
    for (ControlMap::iterator iter = controls.begin(); iter != controls.end(); iter++){
      if (iter->second)
        iter->second = 0;
    }
    controls.clear();
    focusedControl = 0;
  }
}
 
IFlashControl* HikariManager::getFlashControl(const std::string& controlName) const
{
  ControlMap::const_iterator i = controls.find(controlName);
  if (i != controls.end())
    return i->second;
 
  return 0;
}
 
void HikariManager::update()
{
  for (ControlMap::iterator iter = controls.begin(); iter != controls.end();)
  {
    int dirtyWidth = iter->second->dirtyBounds.right - iter->second->dirtyBounds.left;
    int dirtyHeight = iter->second->dirtyBounds.bottom - iter->second->dirtyBounds.top;
 
    int dirtyBufSize = dirtyWidth * dirtyHeight * 4;
    int actualBufferSize = 4 * (iter->second->dirtyBounds.right - iter->second->dirtyBounds.left);
 
    if (iter->second->okayToDelete)
    {
      IFlashControl* controlToDelete = iter->second;
      iter = controls.erase(iter);
      if (focusedControl == controlToDelete)
        focusedControl = 0;
      //delete controlToDelete;
    }
    else
    {
 
      IFlashControl* i = iter->second;
 
      if (i){
 
        i->update();
        iter++;
      }
    }
  }
}
 
IFlashControl* HikariManager::getFocusedControl()
{
  /*if( focusedControl )
    return focusedControl;*/
 
  return NULL;
}
 
 
bool HikariManager::isAnyFocused()
{
  //return !!focusedControl;
  return false;
}
 
void HikariManager::defocusAll()
{
  //focusedControl = 0;
}
 
bool HikariManager::injectMouseMove(short x, short y, int btn, bool ontex)
{
  bool eventHandled = false;
 
  /*if(mouseButtonRDown && focusedControl)
  {
  if(focusedControl->mouseEnable && focusedControl->isDraggable)
  {
  focusedControl->move(x-mouseXPos, y-mouseYPos);
  eventHandled = true;
  }
  }
  for(ControlMap::iterator iter = controls.begin(); iter != controls.end(); iter++)
  {
  //$BB add test ontex to control ouside mouse events only on billboard
  if(iter->second->isInputListener && iter->second->isVisible && iter->second->mouseEnable && ((!iter->second->isOverlay && ontex) || (iter->second->isOverlay && !ontex)))
  {
  iter->second->injectMouseMove(iter->second->getRelativeX(x), iter->second->getRelativeY(y),btn);
 
  if(!eventHandled)
  if(iter->second->isPointOverMe(x, y))
  eventHandled = true;
  }
  }
  mouseXPos = x;
  mouseYPos = y;*/
  return eventHandled;
}
 
bool HikariManager::isPointOverHikari(short x, short y)
{
  bool eventHandled = false;
  /*for(ControlMap::iterator iter = controls.begin(); iter != controls.end(); iter++)
  {
  if(iter->second->isInputListener && iter->second->isVisible)
  {
  if(iter->second->isPointOverMe(x, y))
  {
  eventHandled = true;
  }
 
  }
  }*/
  return eventHandled;
}
 
bool HikariManager::injectMouseDown(int buttonID)
{
  /*if(buttonID == LeftMouseButton)
  {
  if(focusControl(mouseXPos, mouseYPos))
  {
  if(!focusedControl->mouseEnable)
  return false;
  int relX = focusedControl->getRelativeX(mouseXPos);
  int relY = focusedControl->getRelativeY(mouseYPos);
 
  focusedControl->injectMouseDown(relX, relY,buttonID);
  }
  }
  else if(buttonID == RightMouseButton)
  {
  if(!focusedControl->mouseEnable)
  return false;
  if(focusControl(mouseXPos, mouseYPos))
  {
  int relX = focusedControl->getRelativeX(mouseXPos);
  int relY = focusedControl->getRelativeY(mouseYPos);
 
  focusedControl->injectMouseDown(relX, relY,buttonID);
  }
  mouseButtonRDown = true;
  focusControl(mouseXPos, mouseYPos);
  }
  else if(buttonID == MiddleMouseButton)
  {
  if(!focusedControl->mouseEnable)
  return false;
  if(focusControl(mouseXPos, mouseYPos))
  {
  int relX = focusedControl->getRelativeX(mouseXPos);
  int relY = focusedControl->getRelativeY(mouseYPos);
 
  focusedControl->injectMouseDown(relX, relY,buttonID);
  }
  }
 
  if(focusedControl)
  return true;*/
 
  return false;
}
 
bool HikariManager::injectMouseUp(int buttonID)
{
  /*if(buttonID == LeftMouseButton && focusedControl)
  {
  if(focusedControl)
  {
  if(!focusedControl->mouseEnable)
  return false;
  focusedControl->injectMouseUp(focusedControl->getRelativeX(mouseXPos), focusedControl->getRelativeY(mouseYPos),buttonID);
  }
  }
  else if(buttonID == RightMouseButton)
  {
  if(focusedControl)
  {
  if(!focusedControl->mouseEnable)
  return false;
  focusedControl->injectMouseUp(focusedControl->getRelativeX(mouseXPos), focusedControl->getRelativeY(mouseYPos),buttonID);
  }
  mouseButtonRDown = false;
  }
  else if(buttonID == MiddleMouseButton)
  {
  if(focusedControl)
  {
  if(!focusedControl->mouseEnable)
  return false;
  focusedControl->injectMouseUp(focusedControl->getRelativeX(mouseXPos), focusedControl->getRelativeY(mouseYPos),buttonID);
  }
  }
 
  if(focusedControl)
  return true;*/
 
  return false;
}
 
bool HikariManager::injectMouseWheel(int relScroll)
{
  /*if(focusedControl)
  {
  if(focusedControl->isPointOverMe(mouseXPos, mouseYPos)&& focusedControl->mouseEnable)
  {
  focusedControl->injectMouseWheel(relScroll, focusedControl->getRelativeX(mouseXPos), focusedControl->getRelativeY(mouseYPos));
  return true;
  }
  }*/
 
  return false;
}
 
void HikariManager::injectKeyEvent(UINT msg, WPARAM wParam, LPARAM lParam)
{
  /*if(focusedControl && !focusedControl->isBlocked && focusedControl->keyBoardEnable)
  {
  mInjectingKeyboardToFlash = true;
  focusedControl->handleKeyEvent(msg, wParam, lParam);
  }
  else
  {
  mInjectingKeyboardToFlash = false;
  }*/
}
 
void HikariManager::setKeyboardHookEnabled(bool isEnabled)
{
  if (isEnabled)
  {
    if (!keyboardHook)
      keyboardHook = new Impl::KeyboardHook();
  }
  else
  {
    if (keyboardHook)
    {
      delete keyboardHook;
      keyboardHook = 0;
    }
  }
}
 
bool HikariManager::focusControl(int x, int y, IFlashControl* selection)
{
  /*defocusAll();
  if(selection)
  {
  if(!selection)
  {
  focusedControl = selection;
  return true;
  }
  }
 
  IFlashControl* controlToFocus = selection? selection : getTopControl(x, y);
 
  if(!controlToFocus)
  return false;
  if(!controlToFocus->mouseEnable)
  return false;
  if(!controlToFocus->isOverlay)
  {
  focusedControl = controlToFocus;
  return true;
  }
  if(!controlToFocus->topOnFocus)
  {
  focusedControl = controlToFocus;
  return true;
  }
 
  // Recalculate the Z Order
  std::vector<IFlashControl*> sortedControls;
  std::map<std::string, IFlashControl*>::iterator iter;
  for(iter = controls.begin(); iter != controls.end(); iter++)
  if(iter->second)
  sortedControls.push_back(iter->second);
  struct compare { bool operator()(IFlashControl* a, IFlashControl* b){ return(a->getZOrder() > b->getZOrder()); }};
  std::sort(sortedControls.begin(), sortedControls.end(), compare());
  if(sortedControls.size())
  {
  if(sortedControls.at(0) != controlToFocus)
  {
  unsigned int popIdx = 0;
  for(; popIdx < sortedControls.size(); popIdx++)
  if(sortedControls.at(popIdx) == controlToFocus)
  break;
 
  unsigned short highestZ = sortedControls.at(0)->getZOrder();
  int fgidx = 0;
  if(!sortedControls.at(popIdx)->Foreground)
  {
  for(unsigned int i = 0; i < sortedControls.size(); i++)
  {
  if(!sortedControls.at(i)->Foreground)
  {
  highestZ = sortedControls.at(i)->getZOrder();
  fgidx = i;
  break;
  }
  }
  }
  for(fgidx; fgidx < popIdx; fgidx++)
  {
  sortedControls.at(fgidx)->setZOrder(sortedControls.at(fgidx+1)->getZOrder());
  }
  sortedControls.at(popIdx)->setZOrder(highestZ);
  }
  }
  for(unsigned int i = 0; i < sortedControls.size(); i++) sortedControls.at(i)->currentZOrder = sortedControls.at(i)->getZOrder();
 
  focusedControl = controlToFocus;*/
 
  return true;
}
 
IFlashControl* HikariManager::getTopControl(int x, int y)
{
  IFlashControl* top = 0;
 
  /*std::map<std::string, IFlashControl*>::iterator iter;
  for(iter = controls.begin(); iter != controls.end(); iter++)
  {
  if(!iter->second->isPointOverMe(x, y))
  continue;
 
  if(!top)
  top = iter->second;
  else
  top = top->getZOrder() > iter->second->getZOrder() ? top : iter->second;
  }*/
 
  return top;
}
 
// this is the SETTER method to inject FlashControls to hikari
void HikariManager::setFlashControl(IFlashControl* flashControl)
{
  if (controls.find(flashControl->name) == controls.end())
    controls[flashControl->name] = flashControl;
}