DisplayObject.h

Go to the documentation of this file.

// 
//   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 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_DISPLAY_OBJECT_H
#define GNASH_DISPLAY_OBJECT_H

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

#include <vector>
#include <map>
#include <string>
#include <cassert>
#include <boost/cstdint.hpp> // For C99 int types
#include <boost/noncopyable.hpp>

#include "Transform.h"
#include "event_id.h" 
#include "SWFRect.h"
#include "SWFMatrix.h"
#include "SWFCxForm.h"
#include "dsodefs.h" 
#include "snappingrange.h"
#include "VM.h"
#ifdef USE_SWFTREE
# include "tree.hh"
#endif


//#define DEBUG_SET_INVALIDATED 1

// Forward declarations
namespace gnash {
    class MovieClip;
    class Movie;
    class ExecutableCode;
    class action_buffer;
    class movie_definition;
    class StaticText;
    class InteractiveObject;
    class Renderer;
    class as_object;
    class as_value;
    class as_environment;
    namespace SWF {
        class TextRecord;
    }
}

namespace gnash {

//
bool isReferenceable(const DisplayObject& d);

//
//
bool setDisplayObjectProperty(DisplayObject& obj, string_table::key key,
        const as_value& val);

//
//
bool getDisplayObjectProperty(DisplayObject& obj, string_table::key key,
        as_value& val);

//
//
void getIndexedProperty(size_t index, DisplayObject& o, as_value& val);

//
//
void setIndexedProperty(size_t index, DisplayObject& o, const as_value& val);

//
void copyMatrix(const DisplayObject& from, DisplayObject& to);

//
//
SWFMatrix getWorldMatrix(const DisplayObject& d, bool includeRoot = true);

//
SWFCxForm getWorldCxForm(const DisplayObject& d);

//
//
//
//
//
//
class DisplayObject : public GcResource, boost::noncopyable
{
public:

    //
    DisplayObject(movie_root& mr, as_object* object, DisplayObject* parent);

    virtual ~DisplayObject() {}

    //
    //
    static const int lowerAccessibleBound = -16384;
    
    static const int upperAccessibleBound = 2130690044;

    static const int staticDepthOffset = lowerAccessibleBound;

    static const int removedDepthOffset = -32769; 

    //
    static const int noClipDepthValue = -1000000;

    //
    virtual as_environment& get_environment() {
        // MovieClip must override this
        // and any other DisplayObject will have
        // a parent!
        assert(_parent != NULL);
        return _parent->get_environment();
    }

    //
    virtual void enumerateNonProperties(as_environment&) const {}

    DisplayObject* parent() const
    {
        return _parent;
    }

    //
    void set_parent(DisplayObject* parent)
    {
        _parent = parent;
    }

    virtual MovieClip* to_movie() { return 0; }

    int get_depth() const { return _depth; }

    void set_depth(int d) { _depth = d; }

    int getVolume() const { return _volume; }

    void setVolume(int vol) { _volume = vol; }

    //
    int getWorldVolume() const;

    virtual int getDefinitionVersion() const {
        return -1;
    }
    
    const Transform& transform() const {
        return _transform;
    }


    //
    void setMatrix(const SWFMatrix& m, bool updateCache = false);

    //
    void set_x_scale(double factor);

    //
    void set_y_scale(double factor);

    //
    void set_rotation(double rot);

    //
    //
    virtual void setWidth(double width);

    //
    virtual void setHeight(double height);

    void setCxForm(const SWFCxForm& cx) 
    {       
        if (_transform.colorTransform != cx) {
            set_invalidated();
            _transform.colorTransform = cx;
        }
    }

    int get_ratio() const { return _ratio; }

    void set_ratio(int r) {
        if (r != _ratio) set_invalidated(); 
        _ratio = r;       
    }

    int get_clip_depth() const { return m_clip_depth; }

    void set_clip_depth(int d)
    {
        m_clip_depth = d;
    }
        
    bool isMaskLayer() const
    {
        return (m_clip_depth != noClipDepthValue && !_maskee);
    }

    bool isDynamicMask() const
    {
        return (_maskee);
    }

    DisplayObject* getMask() const
    {
#if GNASH_PARANOIA_LEVEL > 1
        if (_mask) assert(_mask->_maskee == this);
#endif
        return _mask;
    }

    void setMask(DisplayObject* mask);

    void set_name(string_table::key name) {
        _name = name;
    }

    string_table::key get_name() const { return _name; }

    //
    std::auto_ptr<ExecutableCode> get_event_handler(const event_id& id) const;

    //
    void add_event_handler(const event_id& id, const action_buffer& code);

    //
        virtual void display(Renderer& renderer, const Transform& xform) = 0;

    //
    virtual StaticText* getStaticText(std::vector<const SWF::TextRecord*>&,
            size_t&) {
        return 0;
    }

        virtual SWFRect getBounds() const = 0;

    //
    bool pointInBounds(boost::int32_t x, boost::int32_t y) const
    {
        SWFRect bounds = getBounds();
        const SWFMatrix wm = getWorldMatrix(*this, false);
        wm.transform(bounds);
        return bounds.point_test(x, y);
    }

    //
        virtual bool pointInShape(boost::int32_t  x, boost::int32_t  y) const = 0;

    //
    virtual bool pointInVisibleShape(boost::int32_t x, boost::int32_t y) const
    {
        if (!visible()) return false;
        if (isDynamicMask() || isMaskLayer()) return false;
        return pointInShape(x, y);
    }

    //
    virtual Movie* get_root() const {
        return parent()->get_root();
    }

    //
    virtual MovieClip* getAsRoot();

    virtual as_object* pathElement(string_table::key key);

    //
    bool get_accept_anim_moves() const
    {
        return ! _scriptTransformed && ! _dynamicallyCreated;
    }

    //
    bool isDynamic() const {
        return _dynamicallyCreated;
    }

    void setDynamic() {
        _dynamicallyCreated = true;
    }

    //
    void transformedByScript() 
    {
        _scriptTransformed = true;
    }

    //
    void set_visible(bool visible);

    // Return true if this DisplayObject should be rendered
    bool visible() const { return _visible; }

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

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

    //
    bool hasEventHandler(const event_id& id) const;

    //
        virtual InteractiveObject* topmostMouseEntity(boost::int32_t, 
            boost::int32_t) {
        return 0;
    }
        
    //
    virtual const DisplayObject* findDropTarget(boost::int32_t x, 
            boost::int32_t y, DisplayObject* dragging) const
    {
        if (this != dragging && visible() && pointInVisibleShape(x, y)) {
            return this;
        }
        
        return 0;
    }

    bool invalidated() const {
        return _invalidated;
    }

    bool childInvalidated() const {
        return _child_invalidated;
    }

    virtual void update() {
        set_invalidated();
    }

    //
    void set_invalidated();
    void set_invalidated(const char* debug_file, int debug_line);
    
    
    void extend_invalidated_bounds(const InvalidatedRanges& ranges);
    
    
    void set_child_invalidated();

    void clear_invalidated() {
        _invalidated = false;
        _child_invalidated = false;        
        m_old_invalidated_ranges.setNull();
    }
    
    //
    virtual void add_invalidated_bounds(InvalidatedRanges& ranges, bool force);

    virtual void omit_display() { clear_invalidated(); }; 
    
    //
    virtual void construct(as_object* /*init*/ = 0)
    {
        saveOriginalTarget();
    }

    //
    bool unload();

    virtual void getLoadedMovie(Movie* newMovie);

    bool unloaded() const;

    //
    virtual void destroy();

    //
    bool isDestroyed() const { return _destroyed; }
    
    bool boundsInClippingArea(Renderer& renderer) const; 

    //
    std::string getTargetPath() const;

    //
    const std::string& getOrigTarget() const
    {
        return _origTarget;
    }

    //
    std::string DSOEXPORT getTarget() const;

    //
    virtual bool isSelectableTextField() const { return false; }

    bool DSOEXPORT allowHandCursor() const;

#ifdef USE_SWFTREE
    typedef std::pair<std::string, std::string> StringPair; 
    typedef tree<StringPair> InfoTree; 
    //
    // TODO: use a typedef for tree<StringPair> ?
    virtual InfoTree::iterator getMovieInfo(InfoTree& tr,
            InfoTree::iterator it);
#endif
    
    string_table::key getNextUnnamedInstanceName();

    enum BlendMode
    {
        BLENDMODE_UNDEFINED = 0,
        BLENDMODE_NORMAL = 1,
        BLENDMODE_LAYER,
        BLENDMODE_MULTIPLY,
        BLENDMODE_SCREEN,
        BLENDMODE_LIGHTEN,
        BLENDMODE_DARKEN,
        BLENDMODE_DIFFERENCE,
        BLENDMODE_ADD,
        BLENDMODE_SUBTRACT,
        BLENDMODE_INVERT,
        BLENDMODE_ALPHA,
        BLENDMODE_ERASE,
        BLENDMODE_OVERLAY,
        BLENDMODE_HARDLIGHT = 14
    };

    BlendMode getBlendMode() const {
        return _blendMode;
    }
 
    void setBlendMode(BlendMode bm) {
        _blendMode = bm;
    }

    // action_buffer is externally owned
    typedef std::vector<const action_buffer*> BufferList;
    typedef std::map<event_id, BufferList> Events;

    //
    //
    virtual bool handleFocus() { 
        return false;
    }

    //
    virtual void killFocus() {}
  
    double rotation() const {
        return _rotation;
    }

    double scaleX() const {
        return _xscale;
    }

    double scaleY() const {
        return _yscale;
    }

    as_object* object() const;

    static as_value blendMode(const fn_call& fn);
  
    //
    virtual void markReachableResources() const;

    //
    virtual void markOwnResources() const {}

protected:
    
    //
    //
    class MaskRenderer
    {
    public:
        MaskRenderer(Renderer& r, const DisplayObject& o);
        ~MaskRenderer();
    private:
        Renderer& _renderer;
        DisplayObject* _mask;
    };

    virtual bool unloadChildren() { return false; }

    movie_root& stage() const {
        return _stage;
    }

    void saveOriginalTarget()
    {
        _origTarget=getTarget();
    }

    const Events& get_event_handlers() const
    {
        return _event_handlers;
    }

    void set_event_handlers(const Events& copyfrom);

    string_table::key _name;

    DisplayObject* _parent;

    //
    as_object* getPathElementSeparator(string_table::key key);

    InvalidatedRanges m_old_invalidated_ranges;

private:

    void setMaskee(DisplayObject* maskee);

    as_object* _object;

    movie_root& _stage;

    Transform _transform;
    
    Events _event_handlers;

    double _xscale, _yscale, _rotation;

    boost::int32_t _depth;

    //
    int _volume;

    int _ratio;
    int m_clip_depth;

    DisplayObject* _mask;

    DisplayObject* _maskee;

    std::string _origTarget;

    BlendMode _blendMode;

    bool _visible;

    //
    bool _scriptTransformed;

    bool _dynamicallyCreated;

    bool _unloaded;

    bool _destroyed;

    //
    bool _invalidated;

    bool _child_invalidated;


};

inline const SWFMatrix&
getMatrix(const DisplayObject& o)
{ 
    return o.transform().matrix;
}

inline const SWFCxForm&
getCxForm(const DisplayObject& o) 
{
    return o.transform().colorTransform;
}

inline SWFMatrix
getWorldMatrix(const DisplayObject& d, bool includeRoot)
{
    SWFMatrix m = d.parent() ?
        getWorldMatrix(*d.parent(), includeRoot) : SWFMatrix();

    if (d.parent() || includeRoot) m.concatenate(getMatrix(d));
    return m;
}

inline SWFCxForm
getWorldCxForm(const DisplayObject& d)
{
    SWFCxForm cx = d.parent() ? getWorldCxForm(*d.parent()) : SWFCxForm();
    cx.concatenate(getCxForm(d));
    return cx;
}

inline bool
isReferenceable(const DisplayObject& d)
{
    return d.object();
}

//
inline as_object*
getObject(const DisplayObject* d)
{
    return d ? d->object() : 0;
}

std::ostream&
operator<<(std::ostream& o, DisplayObject::BlendMode bm);

} // end namespace gnash


#ifdef DEBUG_SET_INVALIDATED
#define set_invalidated() set_invalidated(__FILE__, __LINE__)
#endif


#endif // GNASH_CHARACTER_H


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