SO3WebNavigatorWidget.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 <scolPlugin.h>
#include "SO3Renderer/SO3WebNavigatorWidget.h"
#include "SO3Renderer/SO3Window.h"
#include "SO3Renderer/SO3ViewPort.h"
#include "SO3Renderer/SO3WidgetManager.h"
#include "SO3Renderer/SO3Root.h"
#include "SO3SceneGraph/SO3Scene.h"
#include "SO3Utils/SO3ScriptFunction.h"
#if SO3_WEB_NAVIGATOR_BUILD == 1
 
namespace SO3
{
 
SO3WebNavigatorWidgetListener::SO3WebNavigatorWidgetListener(SWebNavigatorWidget* targetWidgetInstance)
{
  targetWidget = targetWidgetInstance;
}
 
void SO3WebNavigatorWidgetListener::OnExternalCall(SO3::EmbeddedWebNavigator::WebNavigator* sourceWebNavigator, const SScriptFunction& functionCalled)
{
  // Send event information
  SWidgetManager::getSingleton()._FireScriptWidgetEvent(targetWidget, functionCalled);
}
 
void SO3WebNavigatorWidgetListener::OnExternalCallStr(SO3::EmbeddedWebNavigator::WebNavigator* sourceWebNavigator, const SScriptFunction& functionCalled)
{
  // Send event information
  SWidgetManager::getSingleton()._FireScriptWidgetEvent(targetWidget, functionCalled);
}
 
void SO3WebNavigatorWidgetListener::OnLoadStart(SO3::EmbeddedWebNavigator::WebNavigator* sourceWebNavigator, const std::string& frameName)
{
  SWidgetManager::getSingleton()._FireOnLoadStart(targetWidget);
}
 
void SO3WebNavigatorWidgetListener::OnLoadEnd(SO3::EmbeddedWebNavigator::WebNavigator* sourceWebNavigator, const std::string& frameName, int httpStatusCode)
{
  SWidgetManager::getSingleton()._FireOnLoadEnd(targetWidget);
}
 
void SO3WebNavigatorWidgetListener::OnLoadError(SO3::EmbeddedWebNavigator::WebNavigator* sourceWebNavigator, const std::string& frameName, int errorCode, const std::string& failedUrl, std::string& errorText)
{
  SWidgetManager::getSingleton()._FireOnLoadError(targetWidget, errorCode, failedUrl);
}
 
void SO3WebNavigatorWidgetListener::OnCursorChange(SO3::EmbeddedWebNavigator::WebNavigator* sourceWebNavigator, HCURSOR newCursor)
{
  targetWidget->_SetCurrentMouseCursor(newCursor);
}
 
SWebNavigatorWidget::SWebNavigatorWidget(SScene* targetScene, const std::string& webNavigatorName, const int& xPos, const int& yPos, const unsigned short& widgetWidth, const unsigned short& widgetHeight, SViewPort* targetViewport, const unsigned int& widgetZOrder) : SWidget(targetScene, webNavigatorName, xPos, yPos, widgetWidth, widgetHeight, targetViewport, widgetZOrder, SO3_WEB_NAVIGATOR_WIDGET_TYPE)
{
  CommonConstructorSequence();
}
 
SWebNavigatorWidget::SWebNavigatorWidget(SScene* targetScene, const std::string& webNavigatorName, const int& xPos, const int& yPos, const unsigned short& widgetWidth, const unsigned short& widgetHeight, SViewPort* targetViewport) : SWidget(targetScene, webNavigatorName, xPos, yPos, widgetWidth, widgetHeight, targetViewport, SO3_WEB_NAVIGATOR_WIDGET_TYPE)
{
  CommonConstructorSequence();
}
 
SWebNavigatorWidget::SWebNavigatorWidget(SScene* targetScene, const std::string& webNavigatorName, const unsigned short& widgetWidth, const unsigned short& widgetHeight, SMaterial* targetMaterial, const unsigned short& targetTechnique, const unsigned short& targetPass, const unsigned short& targetTextureUnit) : SWidget(targetScene, webNavigatorName, widgetWidth, widgetHeight, targetMaterial, targetTechnique, targetPass, targetTextureUnit, SO3_WEB_NAVIGATOR_WIDGET_TYPE)
{
  CommonConstructorSequence();
}
 
void SWebNavigatorWidget::CommonConstructorSequence()
{
  // Create WebNavigator instance
  embeddedWebNavigator = 0;
  webNavigatorListener = 0;
  lastCursor = 0;
  parentWindow = 0;
 
  //TODO windowHandler
  CreateWebNavigator();
}
 
SWebNavigatorWidget::~SWebNavigatorWidget()
{
  DestroyWebNavigator();
}
 
void SWebNavigatorWidget::CreateWebNavigator()
{
  DestroyWebNavigator();
  const SWindow* pwin = (viewport != 0) ? viewport->GetParentWindow() : 0;
  ScolWindowHandle parent = (pwin != 0) ? pwin->GetWindowHandle() : 0;
  // Create a parent window in any case to avoid crash on popup events on plugins like flash
  parentWindow = CreateWindow("ScolClass", GetName().c_str(), WS_CHILD, CW_USEDEFAULT, CW_USEDEFAULT, 1, 1, parent, 0, (HINSTANCE)SCgetExtra("this_inst"), 0);
 
  embeddedWebNavigator = EmbeddedWebNavigator::WebNavigatorManager::GetSingleton().CreateNavigator(const_cast<ScolWindowHandle&>(parentWindow), width, height, "google.com", GetTransparency());
 
  // Javascript external call listener
  webNavigatorListener = new SO3WebNavigatorWidgetListener(this);
  embeddedWebNavigator->SetListener(webNavigatorListener);
}
 
void SWebNavigatorWidget::DestroyWebNavigator()
{
  if(embeddedWebNavigator != 0)
  {
    // Remove Javascript external call listener
    embeddedWebNavigator->SetListener(0);
    delete(webNavigatorListener);
          webNavigatorListener = 0;
 
    EmbeddedWebNavigator::WebNavigatorManager::GetSingleton().DestroyNavigator(embeddedWebNavigator);
    embeddedWebNavigator = 0;
 
    if(parentWindow)
    {
      DestroyWindow(parentWindow);
      parentWindow = 0;
    }
  }
}
 
void SWebNavigatorWidget::LoadURL(const std::string& url)
{
  if(embeddedWebNavigator != 0)
    embeddedWebNavigator->LoadURL(url);
}
 
void SWebNavigatorWidget::LoadFile(const std::string& file)
{
  if(embeddedWebNavigator != 0)
    embeddedWebNavigator->LoadFile(file);
}
 
void SWebNavigatorWidget::LoadHTML(const std::string& html)
{
  if(embeddedWebNavigator != 0)
    embeddedWebNavigator->LoadHTML(html);
}
 
void SWebNavigatorWidget::InjectMouseMove(const int& xPos, const int& yPos, const MouseButtonId& button)
{
  if(embeddedWebNavigator != 0)
    embeddedWebNavigator->InjectMouseMove(xPos, yPos, false);
}
 
void SWebNavigatorWidget::InjectMouseWheel(const int& scrollX, const int& scrollY, const int& relativeScroll)
{
  if(embeddedWebNavigator != 0)
    embeddedWebNavigator->InjectMouseWheel(scrollX, scrollY, relativeScroll);
}
 
void SWebNavigatorWidget::InjectMouseDown(const int& xPos, const int& yPos, const MouseButtonId& button)
{
  if(embeddedWebNavigator != 0)
    embeddedWebNavigator->InjectMouseClick(xPos, yPos, button, false, 1);
}
 
void SWebNavigatorWidget::InjectMouseUp(const int& xPos, const int& yPos, const MouseButtonId& button)
{
  if(embeddedWebNavigator != 0)
    embeddedWebNavigator->InjectMouseClick(xPos, yPos, button, true, 1);
}
 
void SWebNavigatorWidget::InjectTouchAdd(const int& xPos, const int& yPos, const int& touchid)
{
  // Nothing to do
}
 
void SWebNavigatorWidget::InjectTouchRemove(const int& touchid)
{
  // Nothing to do
}
 
void SWebNavigatorWidget::InjectTouchUpdate(const int& xPos, const int& yPos, const int& vx, const int& vy, const int& touchid)
{
  // Nothing to do
}
 
void SWebNavigatorWidget::InjectKeyEvent(const UINT& msg, const ScolWindowHandle& hwnd, const WPARAM& wParam, const LPARAM& lParam)
{
  if(embeddedWebNavigator != 0)
    embeddedWebNavigator->InjectKeyMsg(msg, lParam, wParam);
}
 
void SWebNavigatorWidget::InjectTextEvent(const std::string& utf8)
{
  /*std::wstring wstringUtf8(utf8.length(),L' ');
  std::copy(utf8.begin(), utf8.end(), wstringUtf8.begin());
  navigatorWindow->injectTextEvent(wstringUtf8);*/
}
 
void SWebNavigatorWidget::SetTransparencyImpl(const bool& enableTransparency)
{
  CreateWebNavigator();
}
 
void SWebNavigatorWidget::SetFocusImpl(const bool& focusOnWidget)
{
  if(embeddedWebNavigator != 0)
    embeddedWebNavigator->InjectFocus(focusOnWidget);
}
 
void SWebNavigatorWidget::SetKeyboardEnableImpl(const bool& enableKeyboardOnWidget)
{
  // TODO
}
 
void SWebNavigatorWidget::SetMouseEnableImpl(const bool& enableMouseOnWidget)
{
  // TODO
}
 
void SWebNavigatorWidget::SetSizeImpl(const unsigned short& newWidth, const unsigned short& newHeight)
{
  if(embeddedWebNavigator != 0)
    embeddedWebNavigator->SetSize(std::pair<int, int>(newWidth, newHeight));
}
 
void SWebNavigatorWidget::Update(const bool& forceUpdate)
{
  bool updateCurrentFrame = forceRenderingUpdate || forceUpdate;
  if(embeddedWebNavigator != 0)
  {
    if(GetVisible())
    {
      if(GetUpdateOnFocusOnly())
      {
        if(HasFocus())
          updateCurrentFrame = true;
      }
      else
      {
        updateCurrentFrame = true;
      }
    }
 
    if(updateCurrentFrame)
      embeddedWebNavigator->GetWebNavigatorClient()->BlitOffscreenTexture(renderingTexture, forceRenderingUpdate || forceUpdate);
  }
 
  forceRenderingUpdate = false;
}
 
void SWebNavigatorWidget::RunScriptFunction(const std::string& functionName, const std::vector<std::string>& argumentList)
{
  if(embeddedWebNavigator != 0)
  {
    bool firstArgument = true;
    std::string javaScriptCommand = functionName + "(";
    std::vector<std::string>::const_iterator iArguments = argumentList.begin();
    while(iArguments != argumentList.end())
    {
      if(!firstArgument)
        javaScriptCommand += ", ";
 
      javaScriptCommand += (*iArguments);
      firstArgument = false;
      iArguments++;
    }
    javaScriptCommand += ");";
    embeddedWebNavigator->ExecuteJavaScript(javaScriptCommand, "", 1);
  }
}
 
bool SWebNavigatorWidget::CheckPixelAlpha(const int& posX, const int& posY)
{
  if(embeddedWebNavigator != 0)
    return embeddedWebNavigator->GetWebNavigatorClient()->CheckPixelAlpha(posX, posY, transparentTresholdColor);
  else
    return false;
}
 
bool SWebNavigatorWidget::CanGoBack()
{
  if(embeddedWebNavigator != 0)
    return embeddedWebNavigator->CanGoBack();
  else
    return false;
}
 
void SWebNavigatorWidget::GoBack()
{
  if(embeddedWebNavigator != 0)
    embeddedWebNavigator->GoBack();
}
 
bool SWebNavigatorWidget::CanGoForward()
{
  if(embeddedWebNavigator != 0)
    return embeddedWebNavigator->CanGoForward();
  else
    return false;
}
 
void SWebNavigatorWidget::GoForward()
{
  if(embeddedWebNavigator != 0)
    embeddedWebNavigator->GoForward();
}
 
void SWebNavigatorWidget::Reload()
{
  if(embeddedWebNavigator != 0)
    embeddedWebNavigator->Reload();
}
 
void SWebNavigatorWidget::ReloadIgnoreCache()
{
  if(embeddedWebNavigator != 0)
    embeddedWebNavigator->ReloadIgnoreCache();
}
 
void SWebNavigatorWidget::StopLoad()
{
  if(embeddedWebNavigator != 0)
    embeddedWebNavigator->StopLoad();
}
 
void SWebNavigatorWidget::Find(const int& identifier, const std::string& searchText, const bool& forward, const bool& matchCase, const bool& findNext)
{
  if(embeddedWebNavigator != 0)
    embeddedWebNavigator->Find(identifier, searchText, forward, matchCase, findNext);
}
 
void SWebNavigatorWidget::StopFinding(const bool& clearSelection)
{
  if(embeddedWebNavigator != 0)
    embeddedWebNavigator->StopFinding(clearSelection);
}
 
float SWebNavigatorWidget::GetZoomLevel()
{
  if(embeddedWebNavigator != 0)
    return static_cast<float>(embeddedWebNavigator->GetZoomLevel());
  else
    return 0.0f;
}
 
void SWebNavigatorWidget::SetZoomLevel(const float& zoomLevel)
{
  if(embeddedWebNavigator != 0)
    embeddedWebNavigator->SetZoomLevel(static_cast<double>(zoomLevel));
}
 
void SWebNavigatorWidget::ClearHistory()
{
  if(embeddedWebNavigator != 0)
    embeddedWebNavigator->ClearHistory();
}
 
void SWebNavigatorWidget::ShowDevTools()
{
  if(embeddedWebNavigator != 0)
    embeddedWebNavigator->ShowDevTools();
}
 
void SWebNavigatorWidget::CloseDevTools()
{
  if(embeddedWebNavigator != 0)
    embeddedWebNavigator->CloseDevTools();
}
 
std::string SWebNavigatorWidget::GetURL(const std::string& frameName)
{
  if(embeddedWebNavigator != 0)
    return embeddedWebNavigator->GetURL(frameName);
  else
    return "";
}
 
void SWebNavigatorWidget::Undo(const std::string& frameName)
{
  if(embeddedWebNavigator != 0)
    embeddedWebNavigator->Undo(frameName);
}
 
void SWebNavigatorWidget::Redo(const std::string& frameName)
{
  if(embeddedWebNavigator != 0)
    embeddedWebNavigator->Redo(frameName);
}
 
void SWebNavigatorWidget::Cut(const std::string& frameName)
{
  if(embeddedWebNavigator != 0)
    embeddedWebNavigator->Cut(frameName);
}
 
void SWebNavigatorWidget::Copy(const std::string& frameName)
{
  if(embeddedWebNavigator != 0)
    embeddedWebNavigator->Copy(frameName);
}
 
void SWebNavigatorWidget::Paste(const std::string& frameName)
{
  if(embeddedWebNavigator != 0)
    embeddedWebNavigator->Paste(frameName);
}
 
void SWebNavigatorWidget::Delete(const std::string& frameName)
{
  if(embeddedWebNavigator != 0)
    embeddedWebNavigator->Delete(frameName);
}
 
void SWebNavigatorWidget::SelectAll(const std::string& frameName)
{
  if(embeddedWebNavigator != 0)
    embeddedWebNavigator->SelectAll(frameName);
}
 
void SWebNavigatorWidget::Print(const std::string& frameName)
{
  if(embeddedWebNavigator != 0)
    embeddedWebNavigator->Print(frameName);
}
 
void SWebNavigatorWidget::ViewSource(const std::string& frameName)
{
  if(embeddedWebNavigator != 0)
    embeddedWebNavigator->ViewSource(frameName);
}
 
std::string SWebNavigatorWidget::GetSource(const std::string& frameName)
{
  if(embeddedWebNavigator != 0)
    return embeddedWebNavigator->GetSource(frameName);
  else
    return "";
}
 
std::string SWebNavigatorWidget::GetText(const std::string& frameName)
{
  if(embeddedWebNavigator != 0)
    return embeddedWebNavigator->GetText(frameName);
  else
    return "";
}
 
HCURSOR SWebNavigatorWidget::GetCurrentMouseCursor()
{
  return lastCursor;
}
 
void SWebNavigatorWidget::_SetCurrentMouseCursor(const HCURSOR& newCursor)
{
  lastCursor = newCursor;
}
 
}
 
#endif