SO3EmbeddedWebNavigatorClient.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) 2011 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 "SO3Web/SO3EmbeddedWebNavigatorManager.h"
#include "SO3Web/SO3EmbeddedWebNavigatorClient.h"
#include "SO3Web/SO3EmbeddedWebNavigator.h"
 
#if SO3_WEB_NAVIGATOR_BUILD == 1
#include "include/wrapper/cef_helpers.h"
 
namespace SO3
{
  namespace EmbeddedWebNavigator
  {
 
    WebNavigatorClient::WebNavigatorClient(WebNavigator* parentWebNavigatorInstance, const ScolWindowHandle& scolMainWindow, bool offscreen) :
      parentWebNavigator(parentWebNavigatorInstance),
      scolMainWindowHandle(scolMainWindow)
    {
      displayHandler = new WebNavigatorDisplayHandler(CefRefPtr<WebNavigatorClient>(const_cast <WebNavigatorClient*> (this)), scolMainWindowHandle);
      keyboardHandler = new WebNavigatorKeyboardHandler(CefRefPtr<WebNavigatorClient>(const_cast <WebNavigatorClient*> (this)), scolMainWindowHandle);
      loadHandler = new WebNavigatorLoadHandler(CefRefPtr<WebNavigatorClient>(const_cast <WebNavigatorClient*> (this)), scolMainWindowHandle);
      renderHandler = new WebNavigatorRenderHandler(CefRefPtr<WebNavigatorClient>(const_cast <WebNavigatorClient*> (this)), scolMainWindowHandle, offscreen);
 
      cefBrowser = 0;
    }
 
    WebNavigatorClient::WebNavigatorClient() : parentWebNavigator(0),
      scolMainWindowHandle(0)
    {
      // Forbiden ctor.
    }
 
    WebNavigatorClient::~WebNavigatorClient()
    {
      _Cleanup();
    }
 
    bool WebNavigatorClient::BlitOffscreenBitmap(unsigned char* dest, int destWidth, int destHeight, int destBytesPerPixel, int destBitsPerLine)
    {
      return renderHandler->BlitOffscreenBitmap(dest, destWidth, destHeight, destBytesPerPixel, destBitsPerLine);
    }
 
    bool WebNavigatorClient::BlitOffscreenAlphaBitmap(unsigned char* destColor, unsigned char* destAlpha, int destWidth, int destHeight, int destColorBytesPerPixel, int destColorBitsPerLine)
    {
      return renderHandler->BlitOffscreenAlphaBitmap(destColor, destAlpha, destWidth, destHeight, destColorBytesPerPixel, destColorBitsPerLine);
    }
 
    bool WebNavigatorClient::BlitOffscreenTexture(Ogre::TexturePtr& ogreTexture, bool forceUpdate)
    {
      return renderHandler->BlitOffscreenTexture(ogreTexture, forceUpdate);
    }
 
    bool WebNavigatorClient::CheckPixelAlpha(int posX, int posY, float transparentTresholdColor)
    {
      return renderHandler->CheckPixelAlpha(posX, posY, transparentTresholdColor);
    }
 
    void WebNavigatorClient::_Cleanup()
    {
      parentWebNavigator = 0;
 
      if (displayHandler.get())
        displayHandler->_Cleanup();
 
      if (keyboardHandler.get())
        keyboardHandler->_Cleanup();
 
      if (loadHandler.get())
        loadHandler->_Cleanup();
 
      if (renderHandler.get())
        renderHandler->_Cleanup();
 
      if (cefBrowser)
      {
        cefBrowser->GetHost()->CloseBrowser(true);
        cefBrowser = 0;
      }
    }
 
    CefRefPtr<CefBrowser> WebNavigatorClient::GetBrowser()
    {
      return cefBrowser;
    }
 
    WebNavigator* WebNavigatorClient::GetParentWebNavigator()
    {
      return parentWebNavigator;
    }
 
    bool WebNavigatorClient::OnBeforePopup(CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame, const CefString& target_url, const CefString& target_frame_name, CefLifeSpanHandler::WindowOpenDisposition target_disposition, bool user_gesture, const CefPopupFeatures& popupFeatures, CefWindowInfo& windowInfo, CefRefPtr<CefClient>& client, CefBrowserSettings& settings, bool* no_javascript_access)
    {
      std::unique_lock< std::shared_mutex > lock(WebNavigatorManager::GetSingletonPtr()->webMessageQueueCriticalSection);
      WebNavigatorManager::GetSingletonPtr()->mainThreadWebMessageQueue.post(std::bind(&WebNavigatorManager::InvokeBeforePopup, WebNavigatorManager::GetSingletonPtr(), parentWebNavigator->GetUniqueId(), popupFeatures.x, popupFeatures.y, popupFeatures.width, popupFeatures.height, target_url));
 
      // Allways cancel popup creation, if we want it, then it's up to the scol developper to create a new web navigator with the given informations.
      return true;
    }
 
    void WebNavigatorClient::OnAfterCreated(CefRefPtr<CefBrowser> browser)
    {
      CEF_REQUIRE_UI_THREAD();
      AutoLock lock_scope(this);
 
      // Register the newly created browser in our WebNavigatorClient object.
      cefBrowser = browser;
 
      //force the navigator zoom to 0 or it will take the last zoom value
      cefBrowser->GetHost()->SetZoomLevel(0.0f);
 
      // Set initial position and size
      if (parentWebNavigator != 0)
      {
        parentWebNavigator->SetPosition(parentWebNavigator->GetPosition());
        parentWebNavigator->SetSize(parentWebNavigator->GetSize());
      }
    }
 
    bool WebNavigatorClient::DoClose(CefRefPtr<CefBrowser> browser)
    {
      // WARNING! DO NOT SEND MESSAGE TO SCOL HERE
      // Because when the scol main thread will handle the reflexive call, the WebNavigator and Cef::Browser object will already have been destroyed!
      return false;
    }
 
    void WebNavigatorClient::OnBeforeClose(CefRefPtr<CefBrowser> browser)
    {
      CEF_REQUIRE_UI_THREAD();
      AutoLock lock_scope(this);
 
      // Unregister the browser from our WebNavigatorClient object.
      displayHandler = 0;
      keyboardHandler = 0;
      loadHandler = 0;
      renderHandler = 0;
    }
 
    bool WebNavigatorClient::OnProcessMessageReceived(CefRefPtr<CefBrowser> browser, CefProcessId source_process, CefRefPtr<CefProcessMessage> message)
    {
      CEF_REQUIRE_UI_THREAD();
      
      if (!message->IsValid())
        return false;
 
      if (parentWebNavigator)
      {
        std::vector<std::string> scolParameters;
        CefRefPtr<CefListValue> arguments = message->GetArgumentList();
        std::string funname;
 
        //scol function name is first parameter
        if (arguments->GetSize() >= 1)
        {
          funname = arguments->GetValue(0)->GetString();
 
          if (arguments->GetSize() > 1)
          for (unsigned int currentArg = 1; currentArg < arguments->GetSize(); currentArg++)
          {
            CefRefPtr<CefValue> arg = arguments->GetValue(currentArg);
            scolParameters.push_back(arg->GetString());
          }
        }
 
        // Create function object
        SScriptFunction functionCalled(funname, scolParameters);
        if (message->GetName() == "scolExternalCall")
        {
          std::unique_lock< std::shared_mutex > lock(WebNavigatorManager::GetSingletonPtr()->webMessageQueueCriticalSection);
          WebNavigatorManager::GetSingletonPtr()->mainThreadWebMessageQueue.post(std::bind(&WebNavigatorManager::InvokeExternalCall, WebNavigatorManager::GetSingletonPtr(), parentWebNavigator->GetUniqueId(), functionCalled));
        }
        else if (message->GetName() == "scolExternalCallStr")
        {
          std::unique_lock< std::shared_mutex > lock(WebNavigatorManager::GetSingletonPtr()->webMessageQueueCriticalSection);
          WebNavigatorManager::GetSingletonPtr()->mainThreadWebMessageQueue.post(std::bind(&WebNavigatorManager::InvokeExternalCallStr, WebNavigatorManager::GetSingletonPtr(), parentWebNavigator->GetUniqueId(), functionCalled));
        }
      }
 
      return true;
    }
 
    void WebNavigatorClient::OnBeforeContextMenu(CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame, CefRefPtr<CefContextMenuParams> params, CefRefPtr<CefMenuModel> model)
    {
      CEF_REQUIRE_UI_THREAD();
      model->Clear();
    }
 
    bool WebNavigatorClient::OnContextMenuCommand(CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame, CefRefPtr<CefContextMenuParams> params, int command_id, CefContextMenuHandler::EventFlags event_flags)
    {
      CEF_REQUIRE_UI_THREAD();
      return false;
    }
  }
}
 
#endif