libogre/include/sirikata/ogre/WebView.hpp

Go to the documentation of this file.

/*  Sirikata
 *  WebView.hpp
 *
 *  Copyright (c) 2009, Adam Jean Simmons
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are
 *  met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *  * Neither the name of Sirikata nor the names of its contributors may
 *    be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef _SIRIKATA_GRAPHICS_WEBVIEW_HPP_
#define _SIRIKATA_GRAPHICS_WEBVIEW_HPP_

#include <sirikata/ogre/OgreHeaders.hpp>
#include "Ogre.h"
#include <sirikata/ogre/ViewportOverlay.hpp>
#include <sirikata/proxyobject/Invokable.hpp>
#include <vector>
#include <boost/any.hpp>

#include <sirikata/core/util/Liveness.hpp>
#include <sirikata/core/service/Context.hpp>

#ifdef HAVE_BERKELIUM
#include "berkelium/Berkelium.hpp"
#include "berkelium/Widget.hpp"
#include "berkelium/Window.hpp"
#include "berkelium/WindowDelegate.hpp"
#endif

#ifndef HAVE_BERKELIUM
namespace Berkelium {
  struct Rect {};
  struct Window;
  struct Widget;
  struct WindowDelegate {
    struct Data { char *message; int length; };
  };
}
#endif



namespace Sirikata {

typedef Sirikata::DataReference<const char*> JSArgument;
typedef std::vector<JSArgument> JSArguments;

namespace Graphics {

class WebView;
#ifdef HAVE_BERKELIUM
    using Berkelium::WideString;
    using Berkelium::URLString;
#endif

typedef std::tr1::function<boost::any (WebView*, const JSArguments&)> JSDelegate;

class SIRIKATA_OGRE_EXPORT WebView
        : public Ogre::ManualResourceLoader
#ifdef HAVE_BERKELIUM
        , public Berkelium::WindowDelegate
#endif
        , public Invokable
        , public Liveness
    {
    public:

            typedef std::tr1::function<void()> ReadyCallback;
            typedef std::tr1::function<void()> ResetReadyCallback;
            typedef std::tr1::function<void(const String&)> NavigatedCallback;
            typedef std::tr1::function<void(int32 left, int32 top, int32 right, int32 bottom)> UpdateViewportCallback;

        void loadURL(const std::string& url);

        void loadFile(const std::string& file);

        void loadHTML(const std::string& html);

        void evaluateJS(const std::string& javascript);

                void defaultEvent(const String& name);

                void setUpdateViewportCallback(UpdateViewportCallback cb);

                void setReadyCallback(ReadyCallback cb);
                void setResetReadyCallback(ResetReadyCallback cb);

                // Callback to invoke when the browser URL
                // changes. Does *not* indicate the page is fully loaded.
                void setNavigatedCallback(NavigatedCallback cb);

        void bind(const std::string& name, JSDelegate callback);


        void setViewport(Ogre::Viewport* newViewport);

        void setTransparent(bool isTransparent);

        void setIgnoreBounds(bool ignoreBounds = true);

        void setIgnoreTransparent(bool ignoreTrans, float threshold = 0.05);

        void setMaxUPS(unsigned int maxUPS = 0);

        void setOpacity(float opacity);

        void setPosition(const OverlayPosition &viewPosition);

        void resetPosition();

        void hide();

        void hide(bool fade, unsigned short fadeDurationMS = 300);

        void show();

        void show(bool fade, unsigned short fadeDurationMS = 300);

        void focus();
        void unfocus();

        void raise();

        void move(int deltaX, int deltaY);

        void getExtents(unsigned short &width, unsigned short &height);

        int getRelativeX(int absX);

        int getRelativeY(int absY);

        bool inDraggableRegion(int relX, int relY);


        bool isMaterialOnly();

        ViewportOverlay* getOverlay();

        std::string getName();

        std::string getType();

        std::string getURL();

        std::string getViewTextureName();

        std::string getMaterialName();

        bool getVisibility();

        bool getNonStrictVisibility();

        void getDerivedUV(Ogre::Real& u1, Ogre::Real& v1, Ogre::Real& u2, Ogre::Real& v2);

        void injectMouseMove(int xPos, int yPos);

        void injectMouseWheel(int scrollX, int scrollY);

        void injectMouseDown(int xPos, int yPos);

        void injectMouseUp(int xPos, int yPos);

            void injectCut();
            void injectCopy();
            void injectPaste();

            void injectKeyEvent(bool press, int modifiers, int vk_code, int raw_scancode);

        void injectTextEvent(std::string utf8);

        void resize(int width, int height);

        class WebViewBorderSize {
        public:
            unsigned short mBorderLeft;
            unsigned short mBorderRight;
            unsigned short mBorderTop;
            unsigned short mBorderBottom;
            WebViewBorderSize(unsigned short left, unsigned short right,
                    unsigned short top, unsigned short bottom)
            : mBorderLeft(left), mBorderRight(right),
              mBorderTop(top), mBorderBottom(bottom) {}
        };

        static const WebViewBorderSize mDefaultBorder;

    protected:
                Context* mContext;
                Network::IOStrandPtr postingStrand;
                
                
#ifdef HAVE_BERKELIUM
            Berkelium::Window* webView;

            // Get Rect used for blitting that doesn't include borders.
            Berkelium::Rect getBorderlessRect(Ogre::HardwarePixelBufferSharedPtr pixelBuffer) const;
            // Get Rect offset by border
            Berkelium::Rect getBorderedRect(const Berkelium::Rect& orig) const;

            void blitNewImage(
                Ogre::HardwarePixelBufferSharedPtr pixelBuffer,
                const unsigned char* srcBuffer, const Berkelium::Rect& srcRect,
                const Berkelium::Rect& copyRect,
                bool updateAlphaCache
            );
            void blitScrollImage(
                Ogre::HardwarePixelBufferSharedPtr pixelBuffer,
                const Berkelium::Rect& scrollOrigRect,
                int scroll_dx, int scroll_dy,
                bool updateAlphaCache
            );

            void compositeWidgets(Berkelium::Window*);
#endif

        std::string viewName;
            std::string viewType;
            String viewURL;
        unsigned short viewWidth;
        unsigned short viewHeight;
        unsigned short mBorderLeft;
        unsigned short mBorderRight;
        unsigned short mBorderTop;
        unsigned short mBorderBottom;

        ViewportOverlay* overlay;
        unsigned int maxUpdatePS;
        Ogre::Timer timer;
        unsigned long lastUpdateTime;
        float opacity;
        bool usingMask;
        unsigned char* alphaCache;
        size_t alphaCachePitch;

        Ogre::Pass* matPass;
        Ogre::TextureUnitState* baseTexUnit;
        Ogre::TextureUnitState* maskTexUnit;

        bool ignoringTrans;
        float transparent;
        bool isWebViewTransparent;
        bool ignoringBounds;

        Ogre::TexturePtr viewTexture;
        Ogre::TexturePtr backingTexture;
        std::map<Berkelium::Widget*,Ogre::TexturePtr>widgetTextures;
        double fadeValue;
        bool isFading;
        double deltaFadePerMS;
        double lastFadeTimeMS;
        bool compensateNPOT;

        bool okayToDelete;
        unsigned short texWidth;
        unsigned short texHeight;
        std::map<std::string, JSDelegate> delegateMap;
                Invokable* mExceptionHandler;
        Ogre::FilterOptions texFiltering;
        std::pair<std::string, std::string> maskImageParameters;

                UpdateViewportCallback mUpdateViewportCallback;
                bool mReady;
                ReadyCallback mReadyCallback;
                ResetReadyCallback mResetReadyCallback;
                NavigatedCallback mNavigatedCallback;

                bool mUnresponsive;

        friend class WebViewManager;


        WebView(
                    Context* ctx, const std::string& name,const std::string& type,
                    unsigned short width, unsigned short height,
                    const OverlayPosition &viewPosition,Ogre::uchar zOrder,
                    Tier tier, Ogre::Viewport* viewport,
                    Network::IOStrandPtr postBackStrand,
                    const WebViewBorderSize& border = mDefaultBorder);


                WebView(
                    Context* ctx, const std::string& name, const std::string& type,
                    unsigned short width, unsigned short height,
                    Ogre::FilterOptions texFiltering,
                    Network::IOStrandPtr postBackStrand);

        ~WebView();

        void createWebView(bool resetting);

        void initializeWebView(
#ifdef HAVE_BERKELIUM
            Berkelium::Window *win,
#endif
            bool resetting
            );
        void cleanupWebView();

        void createMaterial();

        void loadResource(Ogre::Resource* resource);

        void update();

        void updateFade();

        bool isPointOverMe(int x, int y);

        // helper for onJavascriptCallback, defaultEvent
        boost::any dispatchToDelegate(const String& name, const JSArguments& args);
        void dispatchToDelegateNoReturn(const String& name, const JSArguments& args)
        {
            dispatchToDelegate(name,args);
        }


#ifdef HAVE_BERKELIUM
        void onAddressBarChanged(Berkelium::Window*, URLString url);
        void onStartLoading(Berkelium::Window*, URLString url);
        void onTitleChanged(Berkelium::Window*, WideString title);
        void onTooltipChanged(Berkelium::Window*, WideString text);
        void onLoad(Berkelium::Window*);
        void onConsoleMessage(Berkelium::Window *win, WideString message,
                              WideString sourceId, int line_no);
        void onScriptAlert(Berkelium::Window *win, WideString message,
                           WideString defaultValue, URLString url,
                           int flags, bool &success, WideString &value);
        void onPaint(Berkelium::Window *win,
                     const unsigned char *sourceBuffer,
                     const Berkelium::Rect &sourceBufferRect,
                     size_t numCopyRects, const Berkelium::Rect *copyRects,
                     int dx, int dy, const Berkelium::Rect &scrollRect);

        void onJavascriptCallback(Berkelium::Window *win, void* replyMsg, URLString origin, WideString funcName, Berkelium::Script::Variant *args, size_t numArgs);

        void onCrashed(Berkelium::Window*);
        void onResponsive(Berkelium::Window*);
        void onUnresponsive(Berkelium::Window*);

        void onCreatedWindow(Berkelium::Window*, Berkelium::Window*);

        void onWidgetCreated(Berkelium::Window *win, Berkelium::Widget *newWidget, int zIndex);
        void onWidgetDestroyed(Berkelium::Window *win, Berkelium::Widget *newWidget);
        void onWidgetResize(Berkelium::Window *win, Berkelium::Widget *widg, int w, int h);
        void onWidgetMove(Berkelium::Window *win, Berkelium::Widget *widg, int x, int y);
        void onWidgetPaint(
            Berkelium::Window *win,
            Berkelium::Widget *wid,
            const unsigned char *sourceBuffer,
            const Berkelium::Rect &rect,
            size_t numCopyRects,
            const Berkelium::Rect *copyRects,
            int dx, int dy,
            const Berkelium::Rect &scrollRect);
#endif // HAVE_BERKELIUM


     virtual boost::any invoke(std::vector<boost::any>& params);
     // Helpers for invokable calls that produce callbacks later
     boost::any translateParamsAndInvoke(Invokable*, WebView*, const JSArguments&);
     void forwardOnNavigateToInvokable(Invokable* _invokable, const String& url);


        boost::any handleReadyCallback(WebView* wv, const JSArguments& args);

        boost::any handleSetUIViewport(WebView* wv, const JSArguments& args);

        boost::any userLog(WebView* wv, const JSArguments& args);

        boost::any handleOpenBrowser(WebView* wv, const JSArguments& args);

        boost::any handleListenToBrowser(WebView* wv, const JSArguments& args);

        boost::any handleGetBrowserURL(WebView* wv, const JSArguments& args);

        // Helper handler for forwarding navigation events to listener
        void forwardBrowserNavigatedCallback(Liveness::Token alive, const String& cb_name, const String& url);

        boost::any handleCloseBrowser(WebView* wv, const JSArguments& args);

        // Helper handler for when a webview goes unresponsive.
        void handleUnresponsiveTimeout(Liveness::Token alive);

        // Does the real work for crashing/unresponsive pages, clearing out old
        // one and starting up a new copy
        void restartPage();

        };
}
}

#endif