SO3FlashWidget.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/SO3FlashWidget.h"
#include "SO3Material/SO3Material.h"
#include "SO3Renderer/SO3ViewPort.h"
#include "SO3Renderer/SO3Window.h"
#include "SO3SceneGraph/SO3Scene.h"
#include "SO3Renderer/SO3Root.h"
#include "External/hikari/impl/FlashHandler.h"
#include "External/hikari/impl/FlashSite.h"
#include "External/hikari/impl/RenderBuffer.h"
#include "SO3Renderer/SO3WidgetManager.h"
#include <OgreBitwise.h>
 
namespace SO3
{
 
SFlashWidget::SFlashWidget(SScene* targetScene, const std::string& flashWidgetName, const int& xPos, const int& yPos, const unsigned short& widgetWidth, const unsigned short& widgetHeight, SViewPort* targetViewport, const unsigned int& widgetZOrder) : SWidget(targetScene, flashWidgetName, xPos, yPos, widgetWidth, widgetHeight, targetViewport, widgetZOrder, SO3_FLASH_WIDGET_TYPE)
{
  CommonConstructorSequence(true);
  SetRenderingQuality(SO3_FLASH_QUALITY_AUTOHIGH);
  SetScaleMode(SO3_FLASH_SCALE_SHOWALL);
}
 
SFlashWidget::SFlashWidget(SScene* targetScene, const std::string& flashWidgetName, const int& xPos, const int& yPos, const unsigned short& widgetWidth, const unsigned short& widgetHeight, SViewPort* targetViewport) : SWidget(targetScene, flashWidgetName, xPos, yPos, widgetWidth, widgetHeight, targetViewport, SO3_FLASH_WIDGET_TYPE)
{
  CommonConstructorSequence(true);
  SetRenderingQuality(SO3_FLASH_QUALITY_AUTOHIGH);
  SetScaleMode(SO3_FLASH_SCALE_SHOWALL);
}
 
SFlashWidget::SFlashWidget(SScene* targetScene, const std::string& flashWidgetName, const unsigned short& widgetWidth, const unsigned short& widgetHeight, SMaterial* targetMaterial, const unsigned short& targetTechnique, const unsigned short& targetPass, const unsigned short& targetTextureUnit) : SWidget(targetScene, flashWidgetName, widgetWidth, widgetHeight, targetMaterial, targetTechnique, targetPass, targetTextureUnit, SO3_FLASH_WIDGET_TYPE)
{
  CommonConstructorSequence(false);
  SetRenderingQuality(SO3_FLASH_QUALITY_AUTOHIGH);
  SetScaleMode(SO3_FLASH_SCALE_EXACTFIT);
}
 
void SFlashWidget::CommonConstructorSequence(const bool& overlayedFlashControl)
{
  okayToDelete = false;
  lastDirtyWidth = 0;
  lastDirtyHeight = 0;
  isTotallyDirty = false;
  isInputListener = true;
        isVisible = true;
  comCount = 0;
  mainContext = altContext = 0;
  mainBitmap = altBitmap = 0;
  mainBuffer = altBuffer = 0;
  hOldMainBmp = hOldAltBmp = 0;
 
  // Make sure that IFlashControl and SWidget internal variable are synchronized.
  IFlashControl::name = SWidget::name;
  IFlashControl::width  = SWidget::width;
  IFlashControl::height = SWidget::height;
  IFlashControl::isOverlay = overlayedFlashControl;
 
  // Create the render buffer.
  renderBuffer = new Hikari::Impl::RenderBuffer(SWidget::width, SWidget::height);
  site = new Hikari::Impl::FlashSite();
        site->AddRef(); 
        site->Init(this, NULL);
 
  // Get a reference to the Flash ocx
  HMODULE flashLib = Hikari::HikariManager::getSingleton().flashLib;
 
  // Try to load Flash ocx from our SO3 flash.ocx supplied file
        if(flashLib)
        {
                IClassFactory* factory = 0;
                GetClassObject getClassFunc = (GetClassObject)GetProcAddress(flashLib, "DllGetClassObject");
                HRESULT result = getClassFunc(ShockwaveFlashObjects::CLSID_ShockwaveFlash, IID_IClassFactory, (void**)&factory);
                if(SUCCEEDED(result))
                {
      // Create the flash instance
                        factory->CreateInstance(NULL, IID_IOleObject, (void**)&oleObject);
                        factory->Release();     
                }
  }
 
  // If we still don't have the object, try loading the "ocx" from registry
  if(!oleObject)
  {
          HRESULT result = CoCreateInstance(ShockwaveFlashObjects::CLSID_ShockwaveFlash, 0, CLSCTX_INPROC_SERVER, IID_IOleObject, (void**)&oleObject);
          if(FAILED(result))
                  OGRE_EXCEPT(Ogre::Exception::ERR_RT_ASSERTION_FAILED, "Unable to load the Flash ActiveX control.", "SFlashWidget::CommonConstructorSequence");
  }
 
  // Need comments here...
  IOleClientSite* clientSite = 0;
        site->QueryInterface(__uuidof(IOleClientSite), (void**)&clientSite);
        oleObject->SetClientSite(clientSite);
 
  // Need comments here...
  IOleInPlaceObject* inPlaceObject = 0; 
        HRESULT result = oleObject->QueryInterface(__uuidof(IOleInPlaceObject), (LPVOID*)&inPlaceObject);               
        if(FAILED(result))
                OGRE_EXCEPT(Ogre::Exception::ERR_RT_ASSERTION_FAILED, "Unable to load the Flash ActiveX control.", "SFlashWidget::CommonConstructorSequence");
 
  if(inPlaceObject)
        {
                invalidateTotally();
                inPlaceObject->SetObjectRects(&dirtyBounds, &dirtyBounds);
                inPlaceObject->Release();
        }
 
        result = oleObject->QueryInterface(__uuidof(ShockwaveFlashObjects::IShockwaveFlash), (LPVOID*)&flashInterface);
        if(FAILED(result))
                OGRE_EXCEPT(Ogre::Exception::ERR_RT_ASSERTION_FAILED, "Unable to load the Flash ActiveX control.", "SFlashWidget::CommonConstructorSequence");
 
        flashInterface->PutWMode("opaque");
 
  // show the object and switch it to its running state.
        oleObject->DoVerb(OLEIVERB_INPLACEACTIVATE, 0, clientSite, 0, 0, 0);
        clientSite->Release();
 
  // A windowless control is created, the container needs the IOleInPlaceObjectWindowless interface to dispatch messages to the object because the object does not have its own window.
        result = oleObject->QueryInterface(__uuidof(IOleInPlaceObjectWindowless), (LPVOID*)&windowlessObject);
        if(FAILED(result))
                OGRE_EXCEPT(Ogre::Exception::ERR_RT_ASSERTION_FAILED, "Unable to load the Flash ActiveX control.", "SFlashWidget::CommonConstructorSequence");
 
  // Flashhandler inherits from _IShockwaveFlashEvents, that permits to receive fscommand() events from the Flash movie.
        handler = new Hikari::Impl::FlashHandler();
        handler->AddRef();      
        handler->Init(this);
 
        IViewObject* curView = 0;
        result = flashInterface->QueryInterface(IID_IViewObject, (void**)&curView);
        if(FAILED(result))
                OGRE_EXCEPT(Ogre::Exception::ERR_RT_ASSERTION_FAILED, "Unable to load the Flash ActiveX control.", "SFlashWidget::CommonConstructorSequence");
  
  curView->Release();
 
  // Enable keyboard and mouse
  SetKeyboardEnable(true);
  SetMouseEnable(true);
 
  // To enable update, we have to had this instance to HikariManager list.
  Hikari::HikariManager::getSingletonPtr()->setFlashControl(this);
}
 
SFlashWidget::~SFlashWidget()
{
  // Delete this instance from HikariManager list.
  okayToDelete = true;
  Hikari::HikariManager::getSingletonPtr()->update();
 
  if(altContext)
        {
    SelectObject(altContext, hOldAltBmp);
                DeleteDC(altContext);
                altContext = 0;
        }
 
  if(altBitmap)
        {
                DeleteObject(altBitmap);
                altBitmap = 0;
        }
 
  if(mainContext)
        {
    SelectObject(mainContext, hOldMainBmp);
                DeleteDC(mainContext);
                mainContext = 0;
        }
 
        if(mainBitmap)
        {
                DeleteObject(mainBitmap);
                mainBitmap = 0;
        }
 
  // Delete Hikari's stuff instances. Cannot use "delete" due to the ugly implementation, so, meanwhile an ole expert comes here, there's memory leaks here...
        if(windowlessObject)
  {
    windowlessObject->Release();
    windowlessObject = 0;
  }
 
  if(flashInterface)
  {
    flashInterface->Release();
    flashInterface = 0;
  }
 
  if(handler)
        {
                handler->Shutdown();
                handler->Release();
    handler = 0;
        }
 
        if(oleObject)
        {
                oleObject->Close(OLECLOSE_NOSAVE);
                oleObject->Release();
    oleObject = 0;
        }
 
        if(site) 
  {
    site->Release();
    site = 0;
  }
 
  // Free render buffer memory
  SO3_SAFE_DELETE(renderBuffer);
}
 
void SFlashWidget::LoadURL(const std::string& url)
{
  std::string urlString = CheckUrl(url);
  SWidgetManager::getSingleton()._FireOnLoadStart(this);
  flashInterface->PutMovie(urlString.c_str());
  SWidgetManager::getSingleton()._FireOnLoadEnd(this);
}
 
void SFlashWidget::LoadFile(const std::string& file)
{
        FILE* fileIndex = fopen((char*)(file.c_str()), "r");
        if(fileIndex)
        {
    fclose(fileIndex);
    SWidgetManager::getSingleton()._FireOnLoadStart(this);
                flashInterface->PutMovie((char*)(file.c_str()));
    SWidgetManager::getSingleton()._FireOnLoadEnd(this);
        }
        else
        {
    SWidgetManager::getSingleton()._FireOnLoadError(this, 0, file);
                OGRE_EXCEPT(Ogre::Exception::ERR_FILE_NOT_FOUND, "Could not load '" + file + "', the file was not found.", "FlashControl::LoadFile");
        }
}
 
void SFlashWidget::InjectMouseMove(const int& xPos, const int& yPos, const MouseButtonId& button)
{
  injectMouseMove(xPos, yPos, static_cast<int> (button));
}
 
void SFlashWidget::InjectMouseWheel(const int& scrollX, const int& scrollY, const int& relativeScroll)
{
  injectMouseWheel(relativeScroll, scrollX, scrollY);
}
 
void SFlashWidget::InjectMouseDown(const int& xPos, const int& yPos, const MouseButtonId& button)
{
  injectMouseDown(xPos, yPos, static_cast<int> (button));
}
 
void SFlashWidget::InjectMouseUp(const int& xPos, const int& yPos, const MouseButtonId& button)
{
  injectMouseUp(xPos, yPos, static_cast<int> (button));
}
 
void SFlashWidget::InjectTouchAdd(const int& xPos, const int& yPos, const int& touchid)
{
  // Nothing to do
}
 
void SFlashWidget::InjectTouchRemove(const int& touchid)
{
  // Nothing to do
}
 
void SFlashWidget::InjectTouchUpdate(const int& xPos, const int& yPos, const int& vx, const int& vy, const int& touchid)
{
  // Nothing to do
}
 
void SFlashWidget::InjectKeyEvent(const UINT& msg, const ScolWindowHandle& hwnd, const WPARAM& wParam, const LPARAM& lParam)
{
  handleKeyEvent(msg, wParam, lParam);
}
 
void SFlashWidget::InjectTextEvent(const std::string& utf8)
{
}
 
void SFlashWidget::SetFocusImpl(const bool& focusOnWidget)
{
  if (focusOnWidget)
    focus();
}
 
void SFlashWidget::SetTransparencyImpl(const bool& enableTransparency)
{
  setTransparent(enableTransparency, enableTransparency);
}
 
FlashRenderQuality SFlashWidget::GetRenderingQuality()
{
  return renderingQuality;
}
 
void SFlashWidget::SetRenderingQuality(const FlashRenderQuality& newQuality)
{
  setQuality(newQuality);
}
 
void SFlashWidget::Play()
{
  play();
}
 
void SFlashWidget::Stop()
{
  stop();
}
 
void SFlashWidget::Rewind()
{
  rewind();
}
 
void SFlashWidget::Seek(const long& seekFrame)
{
  gotoFrame(seekFrame);
}
 
void SFlashWidget::SetScaleMode(const FlashScaleMode& widgetScaleMode)
{
  setScaleMode(static_cast<short>(widgetScaleMode));
}
 
FlashScaleMode SFlashWidget::GetScaleMode()
{
  return scaleMode;
}
 
ScolWindowHandle SFlashWidget::getTopWindow()
{
  ScolWindowHandle olewin;
  windowlessObject->GetWindow(&olewin);
  
  ScolWindowHandle oletop = GetWindow(olewin, GW_CHILD);
  if (oletop)
    return oletop;
  else
    return olewin;
}
 
void SFlashWidget::RunScriptFunction(const std::string& functionName, const std::vector<std::string>& argumentList)
{
  string argumentStr;
        
  // Convert function name to unicode.
  std::vector<wchar_t> functionNameUnicodeTab(functionName.length()+1); 
        int i = mbstowcs(&functionNameUnicodeTab[0], functionName.c_str(), functionName.length()+1);
        const std::wstring functionNameUnicode = std::wstring(&functionNameUnicodeTab[0]); 
        
  // Convert each argument to unicode, and add to Hikari argument list.
  Hikari::Arguments hikariArgumentList;
  std::vector<std::string>::const_iterator iArgumentList = argumentList.begin();
  while (iArgumentList != argumentList.end())
  {
    std::string currentArgument = *iArgumentList;
                std::vector<wchar_t> currentArgumentUnicodeTab(currentArgument.length()+1);
                int i = mbstowcs(&currentArgumentUnicodeTab[0], currentArgument.c_str(), currentArgument.length()+1);
                const std::wstring currentArgumentUnicode = std::wstring(&currentArgumentUnicodeTab[0]); 
                hikariArgumentList.push_back(Hikari::FlashValue(currentArgumentUnicode));
 
    iArgumentList++;
  }
 
  // Call action script function
  // TODO if (isLoaded)
  callFunction(functionNameUnicode, hikariArgumentList);
}
 
void SFlashWidget::SetKeyboardEnableImpl(const bool& enableKeyboardOnWidget)
{
  IFlashControl::keyBoardEnable = enableKeyboardOnWidget;
  isBlocked = !enableKeyboardOnWidget;
}
 
void SFlashWidget::SetMouseEnableImpl(const bool& enableMouseOnWidget)
{
  IFlashControl::mouseEnable = enableMouseOnWidget;
}
 
void SFlashWidget::SetSizeImpl(const unsigned short& newWidth, const unsigned short& newHeight)
{
  SO3_SAFE_DELETE(renderBuffer); 
  renderBuffer = new Hikari::Impl::RenderBuffer(newWidth, newHeight);
  invalidateTotally();
}
 
void SFlashWidget::setZOrder(unsigned short zorder)
{
  // Nothing to do
}
        
unsigned short SFlashWidget::getZOrder()
{
  // Nothing to do
  return 0;
}
 
int SFlashWidget::getRelativeX(int absX)
{
  // Nothing to do
    return -1;
}
 
int SFlashWidget::getRelativeY(int absY)
{
  // Nothing to do
    return -1;
}
 
bool SFlashWidget::isPointOverMe(int screenX, int screenY)
{
  // Nothing to do
  return false;
}
 
void SFlashWidget::invalidateTotally()
{
        isClean = false;
        isTotallyDirty = true;
        dirtyBounds.left = 0;
        dirtyBounds.top = 0;
  dirtyBounds.right = IFlashControl::width = SWidget::width;
        dirtyBounds.bottom = IFlashControl::height = SWidget::height;
 
  IOleInPlaceObject* inPlaceObject = 0; 
        oleObject->QueryInterface(__uuidof(IOleInPlaceObject), (LPVOID*)&inPlaceObject);                        
 
        if(inPlaceObject)
        {
                inPlaceObject->SetObjectRects(&dirtyBounds, &dirtyBounds);
                inPlaceObject->Release();
        }
 
  forceRenderingUpdate = true;
}
 
void SFlashWidget::handleFlashCall(const std::wstring& xmlString)
{
        std::wstring funcName;
        Hikari::Arguments args;
 
        if(!Hikari::Impl::deserializeInvocation(xmlString, funcName, args))
                return;
 
  // Convert function name.
  std::string invokeName;
  invokeName.resize(funcName.size());
        wcstombs(&invokeName[0], &funcName[0], funcName.size());
 
  // Convert each argument value to string
  std::vector<std::string> arguments;
  Hikari::Arguments::iterator iArguments = args.begin();
  while(iArguments != args.end())
  {  
    float val;
    std::string argumentValue;
    std::ostringstream oss;
    switch((*iArguments).getType())
    {
    case Hikari::FT_NUMBER:
      val = static_cast<float> ((*iArguments).getNumber());
                        oss << val;
      argumentValue = oss.str();
      break;
    case Hikari::FT_BOOLEAN:
      val = static_cast<float>((*iArguments).getBool());
      oss << val;
      argumentValue = oss.str();
      break;
    case Hikari::FT_STRING:
      argumentValue = (*iArguments).getString();
      break;
    case Hikari::FT_WSTRING:
      std::wstring argumentValueUnicode = (*iArguments).getWString();
      if (argumentValueUnicode.size() <= 0)
        break;
                  argumentValue.resize(argumentValueUnicode.size());
                        wcstombs(&argumentValue[0], &argumentValueUnicode[0], argumentValueUnicode.size());
      break;
    }
 
    // Add to list, and convert next argument
    arguments.push_back(argumentValue);
    iArguments++;
  }
 
  // Structure containing action script function information
  SScriptFunction functionCalled(invokeName.c_str(), arguments);
 
  // Send event information
  SWidgetManager::getSingleton()._FireScriptWidgetEvent(this, functionCalled);
}
 
void SFlashWidget::update()
{
  if((isClean)&&(!forceRenderingUpdate))
                return;
 
        int dirtyWidth = dirtyBounds.right - dirtyBounds.left;
        int dirtyHeight = dirtyBounds.bottom - dirtyBounds.top;
        int dirtyBufSize = dirtyWidth * dirtyHeight * 4;
 
        IViewObject* curView = 0;
        flashInterface->QueryInterface(IID_IViewObject, (void**)&curView);
 
        if(!oleObject || !curView)
                return;
 
        if(!mainContext || dirtyWidth != lastDirtyWidth || dirtyHeight != lastDirtyHeight)
        {
    if(altContext)
                {
      SelectObject(altContext, hOldAltBmp);
                        DeleteDC(altContext);
                        altContext = 0;
                }
 
    if(altBitmap)
                {
                        DeleteObject(altBitmap);
                        altBitmap = 0;
                }
 
    if(mainContext)
                {
      SelectObject(mainContext, hOldMainBmp);
                        DeleteDC(mainContext);
                        mainContext = 0;
                }
 
                if(mainBitmap)
                {
                        DeleteObject(mainBitmap);
                        mainBitmap = 0;
                }
 
                lastDirtyWidth = dirtyWidth;
                lastDirtyHeight = dirtyHeight;
 
                HDC hdc = GetDC(NULL);
                BITMAPINFOHEADER bih = {0};
                bih.biSize = sizeof(BITMAPINFOHEADER);
                bih.biBitCount = 32;
                bih.biCompression = BI_RGB;
                bih.biPlanes = 1;
                bih.biWidth = dirtyWidth;
                bih.biHeight = -dirtyHeight;
                mainContext = CreateCompatibleDC(hdc);
                altContext = CreateCompatibleDC(hdc);
    mainBitmap = CreateDIBSection(hdc, (BITMAPINFO*)&bih, DIB_RGB_COLORS, (void**)&mainBuffer, 0, 0);
                altBitmap = CreateDIBSection(hdc, (BITMAPINFO*)&bih, DIB_RGB_COLORS, (void **)&altBuffer, 0, 0);
 
    hOldMainBmp = SelectObject(mainContext, mainBitmap);    
                hOldAltBmp = SelectObject(altContext, altBitmap);
 
                ReleaseDC(0, hdc);
        }
 
        RECT local;
        local.left = -dirtyBounds.left;
        local.top = -dirtyBounds.top;
        local.right = local.left + dirtyBounds.right;
        local.bottom = local.top + dirtyBounds.bottom;
 
  memset(mainBuffer, 0, dirtyBufSize);
  memset(altBuffer, 255, dirtyBufSize);
 
  OleDraw(curView, DVASPECT_TRANSPARENT, mainContext, &local);
  OleDraw(curView, DVASPECT_TRANSPARENT, altContext, &local);
 
  // We've rendered the dirty area twice: once on black and once
  // on white. Now we compare the red channels of each to determine
  // the alpha value of each pixel.
  BYTE *blackBuffer, *whiteBuffer;
  blackBuffer = mainBuffer;
  whiteBuffer = altBuffer;
  BYTE blackRed, whiteRed;
  int size = dirtyWidth * dirtyHeight;
  for(int i = 0; i < size; i++)
  {
    blackRed = *blackBuffer;
    whiteRed = *whiteBuffer;
    blackBuffer += 3;
    whiteBuffer += 4;
    *blackBuffer++ = (255 - (whiteRed - blackRed)) & 0xFF;
  }
 
        renderBuffer->copyArea(dirtyBounds, mainBuffer, dirtyWidth * 4);
 
  bool updateCurrentFrame = forceRenderingUpdate;
  if(GetVisible())
  {
    if(GetUpdateOnFocusOnly())
    {
      if(HasFocus())
        updateCurrentFrame = true;
    }
    else
    {
      updateCurrentFrame = true;
    }
  }
 
  if(updateCurrentFrame)
  {
    // Lock the pixel buffer and get a pixel box
    Ogre::HardwarePixelBufferSharedPtr pixelBuffer = renderingTexture->getBuffer();
    pixelBuffer->lock(Ogre::HardwareBuffer::HBL_DISCARD);
    const Ogre::PixelBox& pixelBox = pixelBuffer->getCurrentLock();
 
    // Create an Ogre pixel box with flash data for easy streching.
    const Ogre::PixelBox scolPixelBox(renderBuffer->width, renderBuffer->height, 1, Ogre::PF_BYTE_BGRA, renderBuffer->getBuffer());
    
    // Streching flash bitmap data to Ogre texture size. Nb that the scale function takes an optional filter parameter if we wants other filtering than bilinear
    Ogre::Image::scale(scolPixelBox, pixelBox);
    
    // No mipmap generation with widget.
    pixelBuffer->unlock();
  }
 
  curView->Release();
        isClean = true;
        isTotallyDirty = false;
  forceRenderingUpdate = false;
}
 
void SFlashWidget::load(const std::string& movieFilename, Hikari::HikariManager* hikariMgr, int type)
{
  // Nothing to do
}
 
void SFlashWidget::play()
{
        flashInterface->Play();
}
 
void SFlashWidget::stop()
{
        flashInterface->Stop();
}
 
void SFlashWidget::rewind()
{
        flashInterface->Rewind();
}
 
void SFlashWidget::gotoFrame(long frameNum)
{
        flashInterface->raw_GotoFrame(frameNum);
}
 
void SFlashWidget::setLoop(bool shouldLoop)
{
        flashInterface->PutLoop(shouldLoop);
}
 
void SFlashWidget::setTransparent(bool isWidgetTransparent, bool useAlphaHack)
{
  IFlashControl::isTransparent = isWidgetTransparent;
        if(isWidgetTransparent)
                flashInterface->PutWMode("transparent");
        else
                flashInterface->PutWMode("opaque");
}
 
void SFlashWidget::setQuality(short renderQuality)
{
  switch(renderQuality)
        {
        case SO3_FLASH_QUALITY_LOW:
                flashInterface->PutQuality2("low");
                break;
        case SO3_FLASH_QUALITY_MEDIUM:
                flashInterface->PutQuality2("medium");
                break;
        case SO3_FLASH_QUALITY_HIGH:
                flashInterface->PutQuality2("high");
                break;
        case SO3_FLASH_QUALITY_BEST:
                flashInterface->PutQuality2("best");
                break;
        case SO3_FLASH_QUALITY_AUTOLOW:
                flashInterface->PutQuality2("autolow");
                break;
        case SO3_FLASH_QUALITY_AUTOHIGH:
                flashInterface->PutQuality2("autohigh");
                break;
        }
  renderingQuality = static_cast <FlashRenderQuality> (renderQuality);
}
 
void SFlashWidget::setScaleMode(short widgetScaleMode)
{
  flashInterface->PutScaleMode(widgetScaleMode);
  scaleMode = static_cast <FlashScaleMode> (widgetScaleMode);
 
  //TODO updateTexture();
}
 
void SFlashWidget::setDraggable(bool widgetDraggable)
{
  // Nothing to do
}
 
void SFlashWidget::setIgnoreTransparentPixels(bool shouldIgnore, float threshold)
{
  // Nothing to do
}
 
const std::string& SFlashWidget::getName() const
{
  return SData::name;
}
 
const std::string& SFlashWidget::getMaterialName() const
{
  // TODO
  return SData::name;
}
 
void SFlashWidget::bind(const std::wstring& funcName, const Hikari::FlashDelegate& callback)
{
  // Nothing to do
}
 
void SFlashWidget::unbind(const std::wstring& funcName)
{
  // Nothing to do
}
 
Hikari::FlashValue SFlashWidget::callFunction(const std::wstring& funcName, const Hikari::Arguments& args)
{
        BSTR returnVal = 0;
        HRESULT result = flashInterface->raw_CallFunction(_bstr_t(Hikari::Impl::serializeInvocation(funcName, args).c_str()), &returnVal);
        if(FAILED(result))
  {
    // Convert function name.
    std::string stringFunctionName;
    stringFunctionName.resize(funcName.size());
          int ref = wcstombs(&stringFunctionName[0], &funcName[0], funcName.size());
    OGRE_EXCEPT(Ogre::Exception::ERR_RT_ASSERTION_FAILED,  "Failed to call ActionScript function '" + stringFunctionName + "' from FlashControl '" + SWidget::name + "'", "SFlashWidget::callFunction");
  }
 
  if (returnVal == 0)
    return FLASH_VOID;
  else
          return Hikari::Impl::deserializeValue((wchar_t*)returnVal);
}
        
void SFlashWidget::hide()
{
  // Nothing to do
}
        
void SFlashWidget::show()
{
  // Nothing to do
}
        
bool SFlashWidget::getVisibility() const
{
  return const_cast<SFlashWidget*> (this)->GetVisible();
}
        
void SFlashWidget::setOpacity(float opacity)
{
}
 
void SFlashWidget::focus()
{
  ScolWindowHandle olewin = getTopWindow();
  SetFocus(olewin);
}
 
void SFlashWidget::move(int deltaX, int deltaY)
{
  // Nothing to do
}
 
void SFlashWidget::getExtents(unsigned short& width, unsigned short& height) const
{
  // Nothing to do
}
        
void SFlashWidget::getUVScale(float& uScale, float& vScale) const
{
  uScale = vScale = 1.0f;
        if(IsCompensateNPOT())
        {
    uScale = (float)SWidget::width/(float)mTextureWidth;
                vScale = (float)SWidget::height/(float)mTextureHeight;
        }
}
 
void SFlashWidget::injectMouseMove(int xPos, int yPos, int btn)
{
  LRESULT result;
  windowlessObject->OnWindowMessage(WM_MOUSEMOVE, btn, MAKELPARAM(xPos, yPos), &result);
}
 
void SFlashWidget::injectMouseDown(int xPos, int yPos, int index)
{
  LRESULT result;
  windowlessObject->OnWindowMessage(MouseButtonMessageConverter(index, true), index, MAKELPARAM(xPos, yPos), &result);
}
 
void SFlashWidget::injectMouseUp(int xPos, int yPos, int index)
{
  LRESULT result;
  windowlessObject->OnWindowMessage(MouseButtonMessageConverter(index, false), index, MAKELPARAM(xPos, yPos), &result);
}
 
void SFlashWidget::injectMouseWheel(int relScroll, int xPos, int yPos)
{
  LRESULT result;
  windowlessObject->OnWindowMessage(WM_MOUSEWHEEL, MAKEWPARAM(0, relScroll), MAKELPARAM(xPos, yPos), &result);
}
 
void SFlashWidget::handleKeyEvent(UINT msg, WPARAM wParam, LPARAM lParam)
{
        LRESULT aResult;
        windowlessObject->OnWindowMessage(msg, wParam, lParam, &aResult);
}
 
UINT SFlashWidget::MouseButtonMessageConverter(const int& button, const bool& pressed)
{
  UINT value = WM_NULL;
  if(pressed)
  {
    switch(button)
    {
    case MK_LBUTTON:
      value = WM_LBUTTONDOWN;
      break;
    case MK_RBUTTON:
      value = WM_RBUTTONDOWN;
      break;
    case MK_MBUTTON:
      value = WM_MBUTTONDOWN;
      break;
    }
  }
  else
  {
    switch(button)
    {
    case MK_LBUTTON:
      value = WM_LBUTTONUP;
      break;
    case MK_RBUTTON:
      value = WM_RBUTTONUP;
      break;
    case MK_MBUTTON:
      value = WM_MBUTTONUP;
      break;
    }
  }
  return value;
};
 
bool SFlashWidget::CheckPixelAlpha(const int& posX, const int& posY)
{
  if((posX <= SWidget::width) && (posY <= SWidget::height))
  {
    int color = renderBuffer->getBuffer()[posY*renderBuffer->rowSpan + posX*4 + 3];
    if (color > transparentTresholdColor * 255)
      return true;
  }
  return false;
}
 
}