SO3EmbeddedWebNavigatorClient.h

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
-----------------------------------------------------------------------------
*/
 
#ifndef _SCOL_EMBEDDED_WEB_NAVIGATOR_CLIENT_
#define _SCOL_EMBEDDED_WEB_NAVIGATOR_CLIENT_
 
#include "SO3EmbeddedWebNavigatorPrerequisites.h"
#include "SO3EmbeddedWebNavigatorListener.h"
#include "SO3EmbeddedWebNavigatorDisplayHandler.h"
#include "SO3EmbeddedWebNavigatorKeyboardHandler.h"
#include "SO3EmbeddedWebNavigatorLoadHandler.h"
#include "SO3EmbeddedWebNavigatorRenderHandler.h"
 
#if SO3_WEB_NAVIGATOR_BUILD == 1
#include "include/cef_client.h"
#include "include/cef_browser.h"
#include "include/cef_frame.h"
#include "include/cef_print_handler.h"
#include "include/cef_render_process_handler.h"
#include "include/cef_context_menu_handler.h"
#include "include/base/cef_lock.h"
 
#include "OgreTexture.h"
 
namespace SO3
{
  namespace EmbeddedWebNavigator
  {
    
    class WebNavigatorClient : public CefClient,
                               public CefContextMenuHandler,
                               public CefLifeSpanHandler,
                               public CefDragHandler,
                               public CefRequestHandler
    {
    public:
    protected:
      //Include the default reference counting implementation.
      IMPLEMENT_REFCOUNTING(WebNavigatorClient);
      // Include the default locking implementation.
      IMPLEMENT_LOCKING(WebNavigatorClient);
    private:
      const ScolWindowHandle scolMainWindowHandle;
      WebNavigator* parentWebNavigator;
      CefRefPtr<CefBrowser> cefBrowser;
 
      CefRefPtr<WebNavigatorDisplayHandler> displayHandler;
      CefRefPtr<WebNavigatorKeyboardHandler> keyboardHandler;
      CefRefPtr<WebNavigatorLoadHandler> loadHandler;
      CefRefPtr<WebNavigatorRenderHandler> renderHandler;
    public:
      WebNavigatorClient(WebNavigator* parentWebNavigatorInstance, const ScolWindowHandle& scolMainWindow, bool offscreen);
 
      virtual ~WebNavigatorClient();
 
      bool BlitOffscreenBitmap(unsigned char* dest, int destWidth, int destHeight, int destBytesPerPixel, int destBitsPerLine);
 
      bool BlitOffscreenAlphaBitmap(unsigned char* destColor, unsigned char* destAlpha, int destWidth, int destHeight, int destColorBytesPerPixel, int destColorBitsPerLine);
 
      bool BlitOffscreenTexture(Ogre::TexturePtr& ogreTexture, bool forceUpdate);
 
      bool CheckPixelAlpha(int posX, int posY, float transparentTresholdColor);
 
      virtual CefRefPtr<CefContextMenuHandler> GetContextMenuHandler() OVERRIDE
      {
        return this;
      }
      virtual CefRefPtr<CefLifeSpanHandler> GetLifeSpanHandler() OVERRIDE
      {
        return this;
      }
      virtual CefRefPtr<CefDragHandler> GetDragHandler() OVERRIDE
      {
        return this;
      }
      virtual CefRefPtr<CefRequestHandler> GetRequestHandler() OVERRIDE
      {
        return this;
      }
      virtual CefRefPtr<CefDisplayHandler> GetDisplayHandler() OVERRIDE
      {
        return displayHandler;
      }
      virtual CefRefPtr<CefKeyboardHandler> GetKeyboardHandler() OVERRIDE
      {
        return keyboardHandler;
      }
      virtual CefRefPtr<CefLoadHandler> GetLoadHandler() OVERRIDE
      {
        return loadHandler;
      }
      virtual CefRefPtr<CefRenderHandler> GetRenderHandler() OVERRIDE
      {
        return renderHandler;
      }
 
      virtual bool OnProcessMessageReceived(CefRefPtr<CefBrowser> browser, CefProcessId source_process, CefRefPtr<CefProcessMessage> message) OVERRIDE;
 
      virtual void OnAfterCreated(CefRefPtr<CefBrowser> browser) OVERRIDE;
      virtual void OnBeforeClose(CefRefPtr<CefBrowser> browser) OVERRIDE;
      virtual bool 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) OVERRIDE;
      virtual bool DoClose(CefRefPtr<CefBrowser> browser) OVERRIDE;
 
      virtual void OnBeforeContextMenu(CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame, CefRefPtr<CefContextMenuParams> params, CefRefPtr<CefMenuModel> model) OVERRIDE;
      virtual bool OnContextMenuCommand(CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame, CefRefPtr<CefContextMenuParams> params, int command_id, CefContextMenuHandler::EventFlags event_flags) OVERRIDE;
 
      CefRefPtr<CefBrowser> GetBrowser();
 
      WebNavigator* GetParentWebNavigator();
 
      void _Cleanup();
    protected:
    private:
      WebNavigatorClient();
    };
 
  }
}
 
#endif
#endif