movie_root.h

Go to the documentation of this file.

// 
//   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
//   Free Software Foundation, Inc
// 
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 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 General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA




#ifndef GNASH_MOVIE_ROOT_H
#define GNASH_MOVIE_ROOT_H

#ifdef HAVE_CONFIG_H
#include "gnashconfig.h" //USE_SWFTREE
#endif

#include <map>
#include <string>
#include <vector>
#include <forward_list>
#include <set>
#include <bitset>
#include <array>
#include <boost/ptr_container/ptr_deque.hpp>
#include <boost/noncopyable.hpp>
#include <boost/any.hpp>
#include <boost/optional.hpp>

#include "dsodefs.h" // DSOEXPORT
#include "DragState.h"
#include "MouseButtonState.h" // for composition
#include "GnashKey.h" // key::code
#include "GnashEnums.h" 
#include "MovieClip.h"
#include "SimpleBuffer.h" // for LoadCallback
#include "MovieLoader.h"
#include "ExternalInterface.h"
#include "GC.h"
#include "VM.h"
#include "HostInterface.h"
#include "log.h"
#include "IOChannel.h"

#ifdef USE_SWFTREE
# include "tree.hh"
#endif

// GNASH_PARANOIA_LEVEL:
// 0 : (not unimplemented)
// 1 : quick assertions
// 2 : add testInvariant
//
#ifndef GNASH_PARANOIA_LEVEL
# define GNASH_PARANOIA_LEVEL 1
#endif

// Forward declarations
namespace gnash {
    class ExecutableCode; 
    class URL;
    class Timer;
    class MovieClip;
    class VirtualClock;
    class RunResources;
    class Button;
    class VM;
    class Movie;
}

namespace gnash {

struct DepthComparator
{
    typedef MovieClip* LevelMovie;
    bool operator()(const LevelMovie& d1, const LevelMovie& d2) const {
        return d1->get_depth() < d2->get_depth();
    }
};

//
//
//
//
class DSOEXPORT movie_root : public GcRoot, boost::noncopyable
{
public:
    
    class LoadCallback {
    public:
        LoadCallback(std::unique_ptr<IOChannel> s, as_object* o)
            :
            _stream(std::move(s)),
            _obj(o)
        {}
        bool processLoad();
        void setReachable() const;
    private:
        std::unique_ptr<IOChannel> _stream;
        SimpleBuffer _buf;
        as_object* _obj;
    };
    typedef std::list<LoadCallback> LoadCallbacks;

    typedef std::bitset<key::KEYCOUNT> Keys;

    //
    movie_root(VirtualClock& clock, const RunResources& runResources);

    ~movie_root();

    //
    // 
    Movie* init(movie_definition* def,
            const MovieClip::MovieVariables& variables);

    //
    MovieClip* getLevel(unsigned int num) const;

    //
    void setLevel(unsigned int num, Movie* movie);

    //
    void replaceLevel(unsigned int num, Movie* external_movie);

    //
    void swapLevels(MovieClip* sp, int depth);

    //
    void dropLevel(int depth);

    //
    //
    void setDimensions(size_t w, size_t h);

    size_t getStageWidth() const;

    size_t getStageHeight() const;

    //
    DSOEXPORT bool mouseMoved(std::int32_t x, std::int32_t y);

    //
    DSOEXPORT bool mouseClick(bool press);

    //
    DSOEXPORT bool mouseWheel(int delta);

    //
    DSOEXPORT bool keyEvent(key::code k, bool down);

    //
    std::pair<std::int32_t, std::int32_t> mousePosition() const;

    void setDragState(const DragState& st);

    //
    Movie& getRootMovie() {
        return *_rootMovie;
    }

    void stop_drag() {
        _dragState.reset();
    }

    //
    std::uint32_t addIntervalTimer(std::unique_ptr<Timer> timer);

    //
    //
    //
    //
    //
    void addLoadableObject(as_object* obj, std::unique_ptr<IOChannel> str);

    void addAdvanceCallback(ActiveRelay* obj);

    void removeAdvanceCallback(ActiveRelay* obj);

    //
    bool clearIntervalTimer(std::uint32_t x);

    void set_background_color(const rgba& color);

    void set_background_alpha(float alpha);

    VM& getVM() { return _vm; }
 
    //
    bool advance();

    //
    int timeToNextFrame() const;

    //
    void advanceMovie();

    void display();

    size_t nextUnnamedInstance() {
        return ++_unnamedInstance;
    }

    void registerButton(Button* listener);

    void removeButton(Button* listener);

    //
    DisplayObject* getFocus();

    //
    bool setFocus(DisplayObject* to);
    
    DSOEXPORT void add_invalidated_bounds(InvalidatedRanges& ranges,
            bool force);
    
    //
    DisplayObject* getActiveEntityUnderPointer() const;

    //
    const DisplayObject* getEntityUnderPointer() const;

    DisplayObject* getDraggingCharacter() const;

    bool testInvariant() const;

    enum DisplayState {
        DISPLAYSTATE_NORMAL,
        DISPLAYSTATE_FULLSCREEN
    };

    enum ScaleMode {
        SCALEMODE_SHOWALL,
        SCALEMODE_NOSCALE,
        SCALEMODE_EXACTFIT,
        SCALEMODE_NOBORDER
    };

    enum StageHorizontalAlign {
        STAGE_H_ALIGN_C,
        STAGE_H_ALIGN_L,
        STAGE_H_ALIGN_R
    };

    enum StageVerticalAlign {
        STAGE_V_ALIGN_C,
        STAGE_V_ALIGN_T,       
        STAGE_V_ALIGN_B
    };

    enum AlignMode {
        STAGE_ALIGN_L,
        STAGE_ALIGN_T,
        STAGE_ALIGN_R,
        STAGE_ALIGN_B
    };

    enum AllowScriptAccessMode {
        SCRIPT_ACCESS_NEVER,
        SCRIPT_ACCESS_SAME_DOMAIN,
        SCRIPT_ACCESS_ALWAYS
    };

    void setQuality(Quality q);

    Quality getQuality() const { return _quality; }

    void setStageAlignment(short s);

    void setAllowScriptAccess(AllowScriptAccessMode mode);
    
    AllowScriptAccessMode getAllowScriptAccess();

    typedef std::pair<StageHorizontalAlign, StageVerticalAlign> StageAlign;

    StageAlign getStageAlignment() const;

    bool getShowMenuState() const;
    
    void setShowMenuState(bool state);

    void setStageScaleMode(ScaleMode sm);
    
    ScaleMode getStageScaleMode() const { return _scaleMode; }

    // The string representation of the current align mode.
    std::string getStageAlignMode() const;

    DisplayState getStageDisplayState() const { return _displayState; }

    // The string representation of the current align mode.
    void setStageDisplayState(const DisplayState ds);

    enum ActionPriorityLevel {
        PRIORITY_INIT,
        PRIORITY_CONSTRUCT,
        PRIORITY_DOACTION,
        PRIORITY_SIZE
    };

    //
    typedef std::array<boost::ptr_deque<ExecutableCode>, PRIORITY_SIZE>
        ActionQueue;

    void pushAction(std::unique_ptr<ExecutableCode> code, size_t lvl);

    void pushAction(const action_buffer& buf, DisplayObject* target);

    //
    void markReachableResources() const;

    //
    void addLiveChar(MovieClip* ch)
    {
        // Don't register the object in the list twice 
#if GNASH_PARANOIA_LEVEL > 1
        assert(std::find(_liveChars.begin(), _liveChars.end(), ch) ==
            _liveChars.end());
#endif
        _liveChars.push_front(ch);
    }

    void reset();

    //
    void disableScripts();

    bool scriptsDisabled() const { return _disableScripts; };

    //
    void flushHigherPriorityActionQueues();

    DisplayObject* findCharacterByTarget(const std::string& tgtstr) const;

    //
    //
    void loadMovie(const std::string& url, const std::string& target,
            const std::string& data, MovieClip::VariablesMethod method,
            as_object* handler=nullptr)
    {
        _movieLoader.loadMovie(url, target, data, method, handler);
    }

    //
    //
    void getURL(const std::string& urlstr, const std::string& target,
            const std::string& data, MovieClip::VariablesMethod method);


    key::code lastKeyEvent() const {
        return _lastKeyEvent;
    }

    const Keys& unreleasedKeys() const {
        return _unreleasedKeys;
    }

    //
    void registerClass(const SWF::DefinitionTag* sprite, as_function* cls);

    //
    as_function* getRegisteredClass(const SWF::DefinitionTag* sprite) const;

    void setHostFD(int fd) {
        assert(fd >= 0);
        _hostfd = fd;
    }

    void setControlFD(int fd) {
        _controlfd = fd;
    }

    int getHostFD() const {
        return _hostfd;
    }

    int getControlFD() const {
        return _controlfd;
    }

    DSOEXPORT void registerFSCommandCallback(FsCallback* handler) {
        _fsCommandHandler = handler;
    }

    DSOEXPORT void handleFsCommand(const std::string& cmd,
            const std::string& arg) const;
    
    DSOEXPORT void registerEventCallback(HostInterface* handler) {
        _interfaceHandler = handler;
    }

    //
    void callInterface(const HostInterface::Message& e) const;

    //
    //
    template<typename T> T callInterface(const HostInterface::Message& e) const;

    //
    void setScriptLimits(std::uint16_t recursion, std::uint16_t timeout);
    
    std::uint16_t getRecursionLimit() const {
        return _recursionLimit;
    }

    std::uint16_t getTimeoutLimit() const
    {
        return _timeoutLimit;
    }

#ifdef USE_SWFTREE
    typedef tree<std::pair<std::string, std::string> > InfoTree;
    void getMovieInfo(InfoTree& tr, InfoTree::iterator it);
    void getCharacterTree(InfoTree& tr, InfoTree::iterator it);
#endif

    const RunResources& runResources() const { return _runResources; }

    typedef std::map<std::string, as_object*> ExternalCallbackMethods;
    typedef std::map<std::string, as_object*> ExternalCallbackInstances;
    ExternalCallbackMethods _externalCallbackMethods;
    ExternalCallbackInstances _externalCallbackInstances;

    //
    void addExternalCallback(const std::string& name, as_object* callback,
                             as_object* instance);

    bool processInvoke(ExternalInterface::invoke_t *);

    std::string callExternalCallback(const std::string &name, 
                                     const std::vector<as_value>& args);
    
    std::string callExternalJavascript(const std::string &name, 
                                       const std::vector<as_value>& args);

    //
    void removeQueuedConstructor(MovieClip* target);

    GC& gc() {
        return _gc;
    }

    //
    bool queryInterface(const std::string& what) const;

    //
    //
    void setStreamBlock(int id, int block);

    //
    //
    void stopStream(int id);

private:

    //
    void setRootMovie(Movie* movie);

    bool notify_mouse_listeners(const event_id& event);
    
    bool fire_mouse_event();

    void doMouseDrag();

    void executeAdvanceCallbacks();
    
    void executeTimers();

    void cleanupAndCollect();

    //
    InteractiveObject* getTopmostMouseEntity(std::int32_t x,
            std::int32_t y) const;

    void cleanupDisplayList();

    void advanceLiveChars();

    void setInvalidated() { _invalidated = true; }

    //
    void clearInvalidated() { _invalidated = false; }

    //
    bool isInvalidated() { return _invalidated; }

    //
    size_t minPopulatedPriorityQueue() const;

    size_t processActionQueue(size_t lvl);

    bool processingActions() const {
        return (_processingActionLevel < PRIORITY_SIZE);
    }

    const DisplayObject* findDropTarget(std::int32_t x, std::int32_t y,
            DisplayObject* dragging) const;

    void handleActionLimitHit(const std::string& ref);

    typedef std::forward_list<Button*> ButtonListeners;
    ButtonListeners _buttonListeners;

    GC _gc;

    const RunResources& _runResources; 

    VM _vm;

    HostInterface* _interfaceHandler;

    FsCallback* _fsCommandHandler;

    //
    typedef std::forward_list<MovieClip*> LiveChars;

    LiveChars _liveChars;

    ActionQueue _actionQueue;

    void processActionQueue();

    size_t _stageWidth;
    size_t _stageHeight;

    rgba m_background_color;
    bool m_background_color_set;

    std::int32_t _mouseX;
    std::int32_t _mouseY;

    MouseButtonState  _mouseButtonState;

    typedef std::set<ActiveRelay*> ObjectCallbacks;
    ObjectCallbacks _objectCallbacks;

    LoadCallbacks _loadCallbacks;
    
    typedef std::map<std::uint32_t, std::unique_ptr<Timer>> TimerMap;

    TimerMap _intervalTimers;

    size_t _lastTimerId;

    Keys _unreleasedKeys;   

    key::code _lastKeyEvent;

    DisplayObject* _currentFocus;

    boost::optional<DragState> _dragState;

    typedef std::map<int, MovieClip*> Levels;

    //
    Levels _movies;

    typedef std::map<const SWF::DefinitionTag*, as_function*> RegisteredClasses;
    RegisteredClasses _registeredClasses;

    Movie* _rootMovie;

    bool _invalidated;

    bool _disableScripts;
    int _processingActionLevel;
    
    //
    int _hostfd;
    int _controlfd;

    //
    Quality _quality;

    std::bitset<4u> _alignMode;

    AllowScriptAccessMode _allowScriptAccess;

    bool _showMenu;

    ScaleMode _scaleMode;

    DisplayState _displayState;
    
    // Maximum number of recursions set in the ScriptLimits tag.
    std::uint16_t _recursionLimit;

    // Timeout in seconds for script execution, set in the ScriptLimits tag.
    std::uint16_t _timeoutLimit;

    // delay between movie advancement, in milliseconds
    size_t _movieAdvancementDelay;

    // time of last movie advancement, in milliseconds
    size_t _lastMovieAdvancement;

    size_t _unnamedInstance;

    MovieLoader _movieLoader;

    struct SoundStream {
        SoundStream(int i, int b) : id(i), block(b) {}
        int id;
        int block;
    };

    boost::optional<SoundStream> _timelineSound;
};

//
bool isLevelTarget(int version, const std::string& name, unsigned int& levelno);

DSOEXPORT short stringToStageAlign(const std::string& s);

template<typename T>
T
movie_root::callInterface(const HostInterface::Message& e) const
{
    if (!_interfaceHandler) {
        log_error("Hosting application registered no callback for "
                "messages, can't call %s(%s)");
        return T();
    }

    try {
        return boost::any_cast<T>(_interfaceHandler->call(e));
    }
    catch (const boost::bad_any_cast&) {
        log_error(_("Unexpected type from host interface when requesting "
                "%1%"), e); 
        return T();
    }
}

} // namespace gnash

#endif // GNASH_MOVIE_ROOT_H

// Local Variables:
// mode: C++
// indent-tabs-mode: nil
// End: