SO3ObjWindowWidget.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/SO3ObjWindowWidget.h"
#include "SO3Material/SO3Material.h"
#include "SO3Renderer/SO3ViewPort.h"
#include "SO3Renderer/SO3Window.h"
#include "SO3SceneGraph/SO3Scene.h"
#include "SO3Utils/SO3ConversionTools.h"
#include "SO3Renderer/SO3Root.h"
#include "SO3Renderer/SO3WidgetManager.h"
 
namespace SO3
{
 
SObjWindowWidget::SObjWindowWidget(SScene* targetScene, const std::string& bitmapWidgetName, const int& xPos, const int& yPos, const unsigned short& widgetWidth, const unsigned short& widgetHeight, SViewPort* targetViewport, const unsigned int& widgetZOrder) : SWidget(targetScene, bitmapWidgetName, xPos, yPos, widgetWidth, widgetHeight, targetViewport, widgetZOrder, SO3_OBJ_WINDOW_WIDGET_TYPE)
{
  CommonConstructorSequence();
}
 
SObjWindowWidget::SObjWindowWidget(SScene* targetScene, const std::string& bitmapWidgetName, const int& xPos, const int& yPos, const unsigned short& widgetWidth, const unsigned short& widgetHeight, SViewPort* targetViewport) : SWidget(targetScene, bitmapWidgetName, xPos, yPos, widgetWidth, widgetHeight, targetViewport, SO3_OBJ_WINDOW_WIDGET_TYPE)
{
  CommonConstructorSequence();
}
 
SObjWindowWidget::SObjWindowWidget(SScene* targetScene, const std::string& bitmapWidgetName, const unsigned short& widgetWidth, const unsigned short& widgetHeight, SMaterial* targetMaterial, const unsigned short& targetTechnique, const unsigned short& targetPass, const unsigned short& targetTextureUnit) : SWidget(targetScene, bitmapWidgetName, widgetWidth, widgetHeight, targetMaterial, targetTechnique, targetPass, targetTextureUnit, SO3_OBJ_WINDOW_WIDGET_TYPE)
{
  CommonConstructorSequence();
}
 
void SObjWindowWidget::CommonConstructorSequence()
{
  targetWindowHandle = 0;
  lastWindowWithBordersWidth = -1;
  lastWindowWithBordersHeight = -1;
  targetWindowDC = 0;
  memoryBitmapDC = 0;
  memoryBitmap = 0;
  pixelsData = 0;
  drawBorders = false;
}
 
SObjWindowWidget::~SObjWindowWidget()
{
  // Clean
  DestroyDevicesContexts();
  DestroyMemoryBitmap();
}
 
void SObjWindowWidget::SetTargetWindow(const ScolWindowHandle& targetWindowHandlePtr)
{
  // Associate with the window
  assert(targetWindowHandle == 0);
  targetWindowHandle = targetWindowHandlePtr;
}
 
void SObjWindowWidget::LoadURL(const std::string& url)
{
  // Throw exception, catch in scol bind, and return nil.
  SWidgetManager::getSingleton()._FireOnLoadError(this, 0, url);
  OGRE_EXCEPT(Ogre::Exception::ERR_NOT_IMPLEMENTED, "Cannot directly load an URL in a ObjWindow widget, use \"UpdateRawData\" function!", "SObjWindowWidget::LoadURL");
}
 
void SObjWindowWidget::LoadFile(const std::string& file)
{
  // Throw exception, catch in scol bind, and return nil.
  SWidgetManager::getSingleton()._FireOnLoadError(this, 0, file);
  OGRE_EXCEPT(Ogre::Exception::ERR_NOT_IMPLEMENTED, "Cannot directly load a file directly in a ObjWindow widget, use \"UpdateRawData\" function!", "SObjWindowWidget::LoadFile");
}
 
void SObjWindowWidget::InjectMouseMove(const int& xPos, const int& yPos, const MouseButtonId& button)
{
  if(CheckWindowIsStillValid())
  {
    // Push event to target window
    //WPARAM wparam = static_cast <WPARAM> (button);
    InjectMouseMessage(xPos, yPos, WM_MOUSEMOVE/*, wparam*/);
  }
}
 
void SObjWindowWidget::InjectMouseWheel(const int& scrollX, const int& scrollY, const int& relativeScroll)
{
  if(CheckWindowIsStillValid())
  {
    // Push event to target window
    InjectMouseMessage(scrollX, scrollY, WM_MOUSEHWHEEL, MAKEWPARAM(0, relativeScroll));
  }
}
 
void SObjWindowWidget::InjectMouseDown(const int& xPos, const int& yPos, const MouseButtonId& button)
{
  if(CheckWindowIsStillValid())
  {
    // Push event to target window
    switch(button)
    {
    case MOUSE_LEFT_BUTTON:
      InjectMouseMessage(xPos, yPos, WM_LBUTTONDOWN);
      break;
    case MOUSE_MIDDLE_BUTTON:
      InjectMouseMessage(xPos, yPos, WM_MBUTTONDOWN);
      break;
    case MOUSE_RIGHT_BUTTON:
      InjectMouseMessage(xPos, yPos, WM_RBUTTONDOWN);
      break;
    }
  }
}
 
void SObjWindowWidget::InjectMouseUp(const int& xPos, const int& yPos, const MouseButtonId& button)
{
  if(CheckWindowIsStillValid())
  {
    // Push event to target window
    switch(button)
    {
    case MOUSE_LEFT_BUTTON:
      InjectMouseMessage(xPos, yPos, WM_LBUTTONUP);
      break;
    case MOUSE_MIDDLE_BUTTON:
      InjectMouseMessage(xPos, yPos, WM_MBUTTONUP);
      break;
    case MOUSE_RIGHT_BUTTON:
      InjectMouseMessage(xPos, yPos, WM_RBUTTONUP);
      break;
    }
  }
}
 
void SObjWindowWidget::InjectTouchAdd(const int& xPos, const int& yPos, const int& touchid)
{
  // Nothing to do
}
 
void SObjWindowWidget::InjectTouchRemove(const int& touchid)
{
  // Nothing to do
}
 
void SObjWindowWidget::InjectTouchUpdate(const int& xPos, const int& yPos, const int& vx, const int& vy, const int& touchid)
{
  // Nothing to do
}
 
void SObjWindowWidget::InjectKeyEvent(const UINT& msg, const ScolWindowHandle& hwnd, const WPARAM& wParam, const LPARAM& lParam)
{
  if(CheckWindowIsStillValid())
  {
    // Push event to target window
    PostMessage(targetWindowHandle, msg, wParam, lParam);
  }
}
 
void SObjWindowWidget::InjectTextEvent(const std::string& utf8)
{
  // Nothing to do
}
 
void SObjWindowWidget::SetFocusImpl(const bool& focusOnWidget)
{
  if(CheckWindowIsStillValid())
  {
    /*if(focusOnWidget)
      SetFocus(targetWindowHandle);
    else
      SetFocus(SRoot::getSingleton().GetRootWindowHandle());*/
  }
}
 
void SObjWindowWidget::SetTransparencyImpl(const bool& enableTransparency)
{
  // Nothing to do
}
 
void SObjWindowWidget::RunScriptFunction(const std::string& functionName, const std::vector<std::string>& argumentList)
{
  // Nothing to do, no script for objWindow!
}
 
void SObjWindowWidget::SetKeyboardEnableImpl(const bool& enableKeyboardOnWidget)
{
  // Nothing to do
}
 
void SObjWindowWidget::SetMouseEnableImpl(const bool& enableMouseOnWidget)
{
  // Nothing to do
}
 
void SObjWindowWidget::SetSizeImpl(const unsigned short& newWidth, const unsigned short& newHeight)
{
  // Nothing to do
}
 
bool SObjWindowWidget::CheckPixelAlpha(const int& posX, const int& posY)
{
  return false;
}
 
bool SObjWindowWidget::GetBorderVisible()
{
  return drawBorders;
}
 
void SObjWindowWidget::SetBorderVisible(const bool& drawBordersEnable)
{
  drawBorders = drawBordersEnable;
}
 
void SObjWindowWidget::InjectMouseMessage(const int& xPos, const int& yPos, const unsigned int& message, const WPARAM& wParam)
{
  if(CheckWindowIsStillValid())
  {
    // Get target window rectangle 
    WINDOWINFO parentWindowInfos;
    GetWindowInfo(targetWindowHandle, &parentWindowInfos);
 
    // Recompute real window coordonates
    POINT localPosition;
    if(drawBorders)
    {
      localPosition.x = static_cast<int>((static_cast<long>(xPos) * (parentWindowInfos.rcWindow.right - parentWindowInfos.rcWindow.left) / static_cast<long>(width)) - (parentWindowInfos.rcClient.left - parentWindowInfos.rcWindow.left));
      localPosition.y = static_cast<int>((static_cast<long>(yPos) * (parentWindowInfos.rcWindow.bottom - parentWindowInfos.rcWindow.top) / static_cast<long>(height)) - (parentWindowInfos.rcClient.top - parentWindowInfos.rcWindow.top));
    }
    else
    {
      localPosition.x = static_cast<int>(static_cast<long>(xPos) * (parentWindowInfos.rcClient.right - parentWindowInfos.rcClient.left) / static_cast<long>(width));
      localPosition.y = static_cast<int>(static_cast<long>(yPos) * (parentWindowInfos.rcClient.bottom - parentWindowInfos.rcClient.top) / static_cast<long>(height));
    }
 
    // Find the child window that is under the mouse coordinates
    WINDOWINFO chilWindowInfos;
    ScolWindowHandle childWindowHandle = 0;
    ScolWindowHandle lastChildWindowHandle = 0;
    do
                {
      // Store infos about parent for later use. No need to do it for first pass, as we already have information of targetWindowHandle in parentWindowInfos.
      if(lastChildWindowHandle == 0)
        lastChildWindowHandle = targetWindowHandle;
      else
        GetWindowInfo(lastChildWindowHandle, &parentWindowInfos);
      
      // Get child
      childWindowHandle = ChildWindowFromPoint(lastChildWindowHandle, localPosition);
      if(childWindowHandle == 0)
        lastChildWindowHandle = 0;
      
      // If different than the last
                        if(childWindowHandle != lastChildWindowHandle)
                        {
        // Get infos about the child
                                GetWindowInfo(childWindowHandle, &chilWindowInfos);
 
        // Re-compute local position
        localPosition.x = localPosition.x - (chilWindowInfos.rcWindow.left - parentWindowInfos.rcClient.left);
        localPosition.y = localPosition.y - (chilWindowInfos.rcWindow.top - parentWindowInfos.rcClient.top);
        lastChildWindowHandle = childWindowHandle;
        childWindowHandle = 0;
                        }
                }while (childWindowHandle != lastChildWindowHandle);
    
    // If the position is not over the target window (mouse move message for example)
    if(lastChildWindowHandle == 0)
      lastChildWindowHandle = targetWindowHandle;
 
    // Post message
    SetCapture(targetWindowHandle);
    SendMessage(lastChildWindowHandle, WM_SETCURSOR, (WPARAM)(0), (LPARAM)(MAKELONG(HTCLIENT, message)));
    SendMessage(lastChildWindowHandle, message, wParam, MAKELPARAM(localPosition.x, localPosition.y));
    ReleaseCapture();
  }
}
 
void SObjWindowWidget::Update()
{
  if(CheckWindowIsStillValid())
  {
    // Get target window informations
    WINDOWINFO targetWindowInfos;
    GetWindowInfo(targetWindowHandle, &targetWindowInfos);
 
    // Compute render size
    long targetWindowWithBordersWidth  = targetWindowInfos.rcWindow.right - targetWindowInfos.rcWindow.left;
    long targetWindowWithBordersHeight = targetWindowInfos.rcWindow.bottom - targetWindowInfos.rcWindow.top;
 
    // Size has changed, need to update the device context and the bitmap too
    if((lastWindowWithBordersWidth != targetWindowWithBordersWidth) || (lastWindowWithBordersHeight != targetWindowWithBordersHeight))
    {
      CreateDevicesContexts();
      CreateMemoryBitmap(targetWindowWithBordersWidth, targetWindowWithBordersHeight);
 
      // Update windows bound
      lastWindowWithBordersWidth = targetWindowWithBordersWidth;
      lastWindowWithBordersHeight = targetWindowWithBordersHeight;
    }
 
    // Paint the window to the bitmap
    if((targetWindowDC != 0) && (memoryBitmapDC != 0) && (memoryBitmap != 0) && (pixelsData!=0))
    {
      // Prepare render flags
      LPARAM printFlags = 0|PRF_CHILDREN|PRF_CLIENT|PRF_ERASEBKGND|PRF_OWNED|PRF_NONCLIENT;
 
      // Paint
      SelectObject(memoryBitmapDC, memoryBitmap);
      //PrintWindow(targetWindowHandle, memoryBitmapDC, 0);
      SendMessage(targetWindowHandle, WM_PRINT, (WPARAM)memoryBitmapDC, printFlags);
      
      // Create an Ogre pixel box with window data for easy streching.
      Ogre::PixelBox scolPixelBox(targetWindowWithBordersWidth, targetWindowWithBordersHeight, 1, Ogre::PF_BYTE_BGR, pixelsData);
 
      // Remove window borders
      if(!drawBorders)
      {
        long targetWindowWithoutBordersWidth  = targetWindowInfos.rcClient.right - targetWindowInfos.rcClient.left;
        long targetWindowWithoutBordersHeight = targetWindowInfos.rcClient.bottom - targetWindowInfos.rcClient.top;
        long xOffset = targetWindowInfos.rcClient.left - targetWindowInfos.rcWindow.left;
        long yOffsetTop = targetWindowInfos.rcClient.top - targetWindowInfos.rcWindow.top;
        Ogre::Box windowRectWithoutBorders(xOffset, yOffsetTop, targetWindowWithoutBordersWidth + xOffset, targetWindowWithoutBordersHeight + yOffsetTop);
        scolPixelBox = scolPixelBox.getSubVolume(windowRectWithoutBorders);
      }
 
      // Lock Ogre's pixel buffer and get a pixel box
      Ogre::HardwarePixelBufferSharedPtr pixelBuffer = renderingTexture->getBuffer();
      pixelBuffer->lock(Ogre::HardwareBuffer::HBL_DISCARD);
      const Ogre::PixelBox& pixelBox = pixelBuffer->getCurrentLock();
 
      // Streching obj window 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();
    }
  }
}
 
void SObjWindowWidget::CreateDevicesContexts()
{
  if(CheckWindowIsStillValid())
  {
    // Clean if necessary
    DestroyDevicesContexts();
 
    // Get target window DC
    targetWindowDC = GetWindowDC(targetWindowHandle); 
    memoryBitmapDC = CreateCompatibleDC(targetWindowDC); 
  }
}
 
void SObjWindowWidget::DestroyDevicesContexts()
{
  // Release Devices contexts
  if(memoryBitmapDC)
  {
    DeleteDC(memoryBitmapDC);
    memoryBitmapDC = 0;
  }
 
  if(CheckWindowIsStillValid())
  {
    if(targetWindowDC)
    {
      ReleaseDC(targetWindowHandle, targetWindowDC);
      targetWindowDC = 0;
    }
  }
}
 
void SObjWindowWidget::CreateMemoryBitmap(const long& targetWindowWidth, const long& targetWindowHeight)
{
  if(CheckWindowIsStillValid())
  {
    // Clean if necessary
    DestroyMemoryBitmap();
 
    if(targetWindowDC)
    {
      // Configure bitmap
      BITMAPINFOHEADER infoHeader;
      infoHeader.biSize = sizeof(BITMAPINFOHEADER);
      infoHeader.biWidth = targetWindowWidth;
      infoHeader.biHeight = -targetWindowHeight; // Negate here to avoid the "upside down" rendering.
      infoHeader.biPlanes = 1;
      infoHeader.biBitCount = 32;
      infoHeader.biCompression = BI_RGB;
 
      // dibsection information
      BITMAPINFO info;
      info.bmiHeader = infoHeader;
 
      // Create bitmap
      memoryBitmap = CreateDIBSection(targetWindowDC, &info, DIB_RGB_COLORS, (void**)&pixelsData, 0, 0);
    }
  }
}
 
void SObjWindowWidget::DestroyMemoryBitmap()
{
  if(memoryBitmap)
  {
    // Release bitmap
    DeleteObject(memoryBitmap);
    memoryBitmap = 0;
    pixelsData = 0;
  }
}
 
bool SObjWindowWidget::CheckWindowIsStillValid()
{
  bool stillValid = false;
  if(targetWindowHandle)
  {
    if(IsWindow(targetWindowHandle))
      stillValid = true;
    else
      targetWindowHandle = 0;
  }
  return stillValid;
}
 
bool SObjWindowWidget::GetMinimizeMaximizeAnimation()
{
  ANIMATIONINFO animationInfo;
  animationInfo.cbSize = sizeof(ANIMATIONINFO);
  SystemParametersInfo(SPI_GETANIMATION, animationInfo.cbSize, &animationInfo, 0);
    
  // Zero value indicates no animation and a non-zero value indicates that animation is enabled
  if (animationInfo.iMinAnimate == 0)
    return false;
  else
    return true;
}
 
void SObjWindowWidget::SetMinimizeMaximizeAnimation(const bool& status)
{
  // Zero value indicates no animation and a non-zero value indicates that animation is enabled
  if (status != GetMinimizeMaximizeAnimation())
  {
    // Convert bool to int safely
    int intStatus = 0;
    if(status)
      intStatus = 1;
 
    // Set new value
    ANIMATIONINFO animationInfo;
    animationInfo.cbSize = sizeof(ANIMATIONINFO);
    animationInfo.iMinAnimate = intStatus;
    SystemParametersInfo(SPI_SETANIMATION, animationInfo.cbSize, &animationInfo, SPIF_SENDCHANGE);
  }
}
 
}