SO3Engine/SO3Renderer/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) 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 "SO3FlashWidget.h"
#include "../SO3Material/SO3Material.h"
#include "../SO3Renderer/SO3ViewPort.h"
#include "../SO3Renderer/SO3Window.h"
#include "../SO3SceneGraph/SO3Scene.h"
#include "../SO3Renderer/SO3Root.h"
#include "impl/FlashHandler.h"
#include "impl/FlashSite.h"
#include "impl/RenderBuffer.h"
#include "SO3WidgetManager.h"
#include <OgreBitwise.h>

namespace SO3
{

SFlashWidget::SFlashWidget(SScene* targetScene, std::string flashWidgetName, int xPos, int yPos, unsigned short widgetWidth, unsigned short widgetHeight, SViewPort* targetViewport, 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, std::string flashWidgetName, int xPos, int yPos, unsigned short widgetWidth, 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, std::string flashWidgetName, unsigned short widgetWidth, unsigned short widgetHeight, SMaterial* targetMaterial, unsigned short targetTechnique, unsigned short targetPass, 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(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;

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

  // 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;
  }

        if(mainContext)
    ::DeleteDC(mainContext);

  if(altContext)
    ::DeleteDC(altContext);

  if(mainBitmap)
    ::DeleteObject(mainBitmap);

  if(altBitmap)
    ::DeleteObject(altBitmap);

  // Free render buffer memory
  SAFE_DELETE(renderBuffer);
}

void SFlashWidget::LoadURL(const std::string& url)
{
  std::string urlString = CheckUrl(url);
  flashInterface->PutMovie(urlString.c_str());
}

void SFlashWidget::LoadFile(const std::string& file)
{
        FILE* fileIndex = fopen((char*)(file.c_str()), "r");
        if(fileIndex)
        {
    fclose(fileIndex);
                flashInterface->PutMovie((char*)(file.c_str()));
        }
        else
        {
                OGRE_EXCEPT(Ogre::Exception::ERR_FILE_NOT_FOUND, "Could not load '" + file + "', the file was not found.", "FlashControl::LoadFile");
        }
}

void SFlashWidget::InjectMouseMove(int xPos, int yPos, MouseButtonId button)
{
  injectMouseMove(xPos - leftPos , yPos - topPos, static_cast<int> (button));
}

void SFlashWidget::InjectMouseWheel(int scrollX, int scrollY, int relativeScroll)
{
  injectMouseWheel(relativeScroll, scrollX, scrollY);
}

void SFlashWidget::InjectMouseDown(int xPos, int yPos, MouseButtonId button)
{
  injectMouseDown(xPos - leftPos , yPos - topPos, static_cast<int> (button));
}

void SFlashWidget::InjectMouseUp(int xPos, int yPos, MouseButtonId button)
{
  injectMouseUp(xPos - leftPos , yPos - topPos, static_cast<int> (button));
}

void SFlashWidget::InjectKeyEvent(UINT msg, WindowHandle hwnd, WPARAM wParam, LPARAM lParam)
{
  handleKeyEvent(msg, wParam, lParam);
}

void SFlashWidget::InjectTextEvent(std::string utf8)
{
}

void SFlashWidget::SetFocusImpl(bool focusOnWidget)
{
  if (focusOnWidget)
    focus();
}

void SFlashWidget::SetTransparencyImpl(bool enableTransparency)
{
  setTransparent(enableTransparency, enableTransparency);
}

SFlashWidget::FlashRenderQuality SFlashWidget::GetRenderingQuality()
{
  return renderingQuality;
}

void SFlashWidget::SetRenderingQuality(SFlashWidget::FlashRenderQuality newQuality)
{
  setQuality(newQuality);
}

void SFlashWidget::Play()
{
  play();
}

void SFlashWidget::Stop()
{
  stop();
}

void SFlashWidget::Rewind()
{
  rewind();
}

void SFlashWidget::Seek(long seekFrame)
{
  gotoFrame(seekFrame);
}

void SFlashWidget::SetScaleMode(SFlashWidget::FlashScaleMode widgetScaleMode)
{
  setScaleMode(static_cast<short>(widgetScaleMode));
}

SFlashWidget::FlashScaleMode SFlashWidget::GetScaleMode()
{
  return scaleMode;
}

WindowHandle SFlashWidget::getTopWindow()
{
  WindowHandle olewin;
  windowlessObject->GetWindow(&olewin);
  
  WindowHandle oletop = GetWindow(olewin, GW_CHILD);
  if (oletop)
    return oletop;
  else
    return olewin;
}

void SFlashWidget::RunScriptFunction(std::string functionName, 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>::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(bool enableKeyboardOnWidget)
{
  IFlashControl::keyBoardEnable = enableKeyboardOnWidget;
  isBlocked = !enableKeyboardOnWidget;
}

void SFlashWidget::SetMouseEnableImpl(bool enableMouseOnWidget)
{
  IFlashControl::mouseEnable = enableMouseOnWidget;
}

void SFlashWidget::SetSizeImpl(unsigned short newWidth, unsigned short newHeight)
{
  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;

  // Structure containing action script function information
  WidgetScriptFunction functionCalled;

  // Convert function name.
  std::string invokeName;
  invokeName.resize(funcName.size());
        wcstombs(&invokeName[0], &funcName[0], funcName.size());
  functionCalled.function = invokeName.c_str();

  // Convert each argument value to string
  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();
                  argumentValue.resize(argumentValueUnicode.size());
                        wcstombs(&argumentValue[0], &argumentValueUnicode[0], argumentValueUnicode.size());
      break;
    }

    // Add to list, and convert next argument
    functionCalled.arguments.push_back(argumentValue);
    iArguments++;
  }

  // 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(mainContext)
                {
                        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);
                mainBitmap = CreateDIBSection(hdc, (BITMAPINFO*)&bih, DIB_RGB_COLORS, (void**)&mainBuffer, 0, 0);
                SelectObject(mainContext, mainBitmap);

    if(altContext)
                {
                        DeleteDC(altContext);
                        altContext = 0;
                }
                if(altBitmap)
                {
                        DeleteObject(altBitmap);
                        altBitmap = 0;
                }

                altContext = CreateCompatibleDC(hdc);
                altBitmap = CreateDIBSection(hdc, (BITMAPINFO*)&bih, DIB_RGB_COLORS, (void **)&altBuffer, 0, 0);
                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);

  // 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, renderingTexture->getFormat(), 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();

        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 std::string("unused");
}

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

        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()
{
  WindowHandle 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)textureWidth;
                vScale = (float)SWidget::height/(float)textureHeight;
        }
}

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, 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;
};

int SFlashWidget::GetPixelUnder(int posX, int posY)
{
  if((posX <= SWidget::width) && (posY <= SWidget::height))
  {
    int color = renderBuffer->getBuffer()[posY*renderBuffer->rowSpan + posX*4 + 3];
    if (color > transparentTresholdColor * 255)
      return color;
  }
  return -1;
}

}

---