MovieClip.h

Go to the documentation of this file.

// MovieClip.h:  Stateful live Sprite instance, for Gnash.
// 
//   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

// Stateful live Sprite instance

#ifndef GNASH_MOVIECLIP_H
#define GNASH_MOVIECLIP_H

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

#include <vector>
#include <map>
#include <string>
#include <boost/ptr_container/ptr_list.hpp>
#include <boost/intrusive_ptr.hpp>

#include "ControlTag.h"
#include "movie_definition.h" // for inlines
#include "DisplayObjectContainer.h"
#include "as_environment.h" // for composition
#include "DynamicShape.h" // for composition
#include "dsodefs.h" // for DSOEXPORT

// Forward declarations
namespace gnash {
    class Movie;
    class swf_event;
    class drag_state;
    class LoadVariablesThread;
    class GradientRecord;
    class TextField;
    class BitmapData_as;
    class CachedBitmap;
    class DisplayList;
    namespace SWF {
        class PlaceObject2Tag;
    }
}

namespace gnash {

//
//
//
//
//
class DSOTEXPORT MovieClip : public DisplayObjectContainer 
{
public:

    typedef std::vector<TextField*> TextFields;

    typedef std::map<ObjectURI, TextFields, ObjectURI::LessThan>
        TextFieldIndex;

    typedef std::map<std::string, std::string> MovieVariables;

    typedef movie_definition::PlayList PlayList;

    enum PlayState
    {
        PLAYSTATE_PLAY,
        PLAYSTATE_STOP
    };

    //
    MovieClip(as_object* object, const movie_definition* def,
            Movie* root, DisplayObject* parent);

    virtual ~MovieClip();

    // Return the originating SWF
    virtual Movie* get_root() const;

    virtual bool trackAsMenu();

    //
    void queueEvent(const event_id& id, int lvl);

    void queueLoad();

    //
    virtual MovieClip* getAsRoot();

    virtual SWFRect getBounds() const;

    // See dox in DisplayObject.h
    virtual bool pointInShape(std::int32_t x, std::int32_t y) const;

    // See dox in DisplayObject.h
    virtual bool pointInVisibleShape(std::int32_t x, std::int32_t y) const;

    virtual bool pointInHitableShape(std::int32_t x, std::int32_t y) const;

    size_t get_current_frame() const
    {
        return _currentFrame;
    }

    size_t get_frame_count() const
    {
        return _def ? _def->get_frame_count() : 1;
    }

    //
    size_t get_loaded_frames() const
    {
        return _def ? _def->get_loading_frame() : 1;
    }

    size_t get_bytes_total() const
    {
        return isDynamic() ? 0 : _def->get_bytes_total();
    }

    size_t get_bytes_loaded() const
    {
        return isDynamic() ? 0 : _def->get_bytes_loaded();
    }

    const SWFRect& get_frame_size() const
    {
        static const SWFRect r;
        return _def ? _def->get_frame_size() : r;
    }

    //
    DSOEXPORT void setPlayState(PlayState s);

    PlayState getPlayState() const { return _playState; }

    // delegates to movie_root (possibly wrong)
    void set_background_color(const rgba& color);

    //
    virtual bool mouseEnabled() const;

    virtual InteractiveObject* topmostMouseEntity(std::int32_t x,
            std::int32_t y);

    // see dox in DisplayObject.h
    const DisplayObject* findDropTarget(std::int32_t x, std::int32_t y,
            DisplayObject* dragging) const;

    void setDropTarget(const std::string& tgt) {
        _droptarget = tgt;
    }

    const std::string& getDropTarget() const {
        return _droptarget;
    }
    
    //
    virtual void advance();

    //
    DSOEXPORT void goto_frame(size_t target_frame_number);

    //
    bool get_frame_number(const as_value& frame_spec, size_t& frameno) const;

    bool goto_labeled_frame(const std::string& label);
        
    virtual void display(Renderer& renderer, const Transform& xform);
    
    //
    void draw(Renderer& renderer, const Transform& xform);

    void omit_display();

    //
    void swapDepths(DisplayObject* ch1, int newdepth)
    {
        _displayList.swapDepths(ch1, newdepth);
    }

    //
    DisplayObject* getDisplayObjectAtDepth(int depth);

    DisplayObject* addDisplayListObject(DisplayObject* obj, int depth);

    //
    DisplayObject* add_display_object(const SWF::PlaceObject2Tag* tag,
            DisplayList& dlist);

    void move_display_object(const SWF::PlaceObject2Tag* tag,
            DisplayList& dlist);

    void replace_display_object(const SWF::PlaceObject2Tag* tag,
            DisplayList& dlist);

    void remove_display_object(const SWF::PlaceObject2Tag* tag,
            DisplayList& dlist);

    //
    void remove_display_object(int depth, int /*id*/);

    void unloadMovie();

    //
    void attachCharacter(DisplayObject& newch, int depth, as_object* initObject);

    //
    //
    virtual void construct(as_object* initObj = nullptr);

    //
    void destroy();
        
    void add_action_buffer(const action_buffer* a)
    {
        if (!_callingFrameActions) queueAction(*a);
        else execute_action(*a);
    }

    
    //
    void execute_init_action_buffer(const action_buffer& a, int cid);

    void execute_action(const action_buffer& ab);

    MovieClip* to_movie () { return this; }

    //
    enum VariablesMethod
    {
        METHOD_NONE = 0,
        METHOD_GET,
        METHOD_POST
    };

    // See dox in DisplayObject.h
    virtual void getLoadedMovie(Movie* newMovie);

    //
    void loadVariables(const std::string& urlstr,
            VariablesMethod sendVarsMethod);

    //
    bool getTextFieldVariables(const ObjectURI& uri, as_value& val);

    // Set TextField variables
    //
    bool setTextFieldVariables(const ObjectURI& uri, const as_value& val);

    //
    //
    DisplayObject* getDisplayListObject(const ObjectURI& uri);

    as_object* pathElement(const ObjectURI& uri);

    //
    virtual void call_frame_actions(const as_value& frame_spec);

    //
    MovieClip* duplicateMovieClip(const std::string& newname,
        int newdepth, as_object* init_object = nullptr);

    virtual void mouseEvent(const event_id& id) {
        notifyEvent(id);
    }
        
    //
    void notifyEvent(const event_id& id);

    // inherited from DisplayObject class, see dox in DisplayObject.h
    virtual as_environment& get_environment() {
        return _environment;
    }

    //
    void set_textfield_variable(const ObjectURI& name, TextField* ch);

    void add_invalidated_bounds(InvalidatedRanges& ranges, bool force);
    
    const DisplayList& getDisplayList() const {
            return _displayList;
    }

    //
    int getNextHighestDepth() const {
        return _displayList.getNextHighestDepth();
    }

    // 
    // TODO: rename to setStreamingSoundId
    void setStreamSoundId(int id);

    //
    void removeMovieClip();

    DynamicShape& graphics() {
        set_invalidated();
        return _drawable;
    }

    //
    virtual bool handleFocus();


    DSOEXPORT void setVariables(const MovieVariables& vars);

    //
    virtual void visitNonProperties(KeyVisitor& v) const;

    void cleanupDisplayList();

    //
    void queueAction(const action_buffer& buf);

    //
    void constructAsScriptObject();

    bool getLockRoot() const { return _lockroot; }

    void setLockRoot(bool lr) { _lockroot=lr; }

    virtual int getDefinitionVersion() const;

protected:

    //
    virtual bool unloadChildren();

    //
    virtual void markOwnResources() const;
    
    // Used by BitmapMovie.
    void placeDisplayObject(DisplayObject* ch, int depth) {       
        _displayList.placeDisplayObject(ch, depth);  
    }

private:

    void processCompletedLoadVariableRequests();

    void processCompletedLoadVariableRequest(LoadVariablesThread& request);

    
    //
    void executeFrameTags(size_t frame, DisplayList& dlist,
            int typeflags = SWF::ControlTag::TAG_DLIST |
                            SWF::ControlTag::TAG_ACTION);

    void stopStreamSound();

    //
    //
    bool isEnabled() const;

    //
    bool hitTestDrawable(std::int32_t x, std::int32_t y) const;

    //
    //  http://www.gnashdev.org/wiki/index.php/TimelineControl
    //
    void restoreDisplayList(size_t targetFrame);

    void increment_frame_and_check_for_loop();

    void cleanup_textfield_variables();

    const boost::intrusive_ptr<const movie_definition> _def;

    typedef boost::ptr_list<LoadVariablesThread> LoadVariablesThreads;
    
    //
    LoadVariablesThreads _loadVariableRequests;

    Movie* _swf;

    DynamicShape _drawable;

    PlayState _playState;

    as_environment _environment;

    std::unique_ptr<TextFieldIndex> _text_variables;

    std::string _droptarget;

    // 0-based index to current frame
    size_t _currentFrame;
    
    int m_sound_stream_id;

    // true if this sprite reached the last frame and restarted
    bool _hasLooped;

    // true if orphaned tags (tags found after last advertised showframe)
    // have been executed at least once.
    bool _flushedOrphanedTags;

    // true is we're calling frame actions
    bool _callingFrameActions;

    bool _lockroot;

    bool _onLoadCalled;
};

} // end of namespace gnash

#endif // GNASH_SPRITE_INSTANCE_H