as_object.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_AS_OBJECT_H
#define GNASH_AS_OBJECT_H

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

#include <map>
#include <vector>
#include <cmath>
#include <utility> 
#include <boost/scoped_ptr.hpp>
#include <boost/noncopyable.hpp>

#include "GC.h" // for inheritance from GcResource (to complete)
#include "PropertyList.h"
#include "PropFlags.h"
#include "Relay.h"
#include "ObjectURI.h"

// Forward declarations
namespace gnash {
    class as_function;
    class MovieClip;
    class DisplayObject;
    class as_environment;
    class VM;
    class IOChannel;
    class movie_root;
    class RunResources;
    class Global_as;
    class as_value;
    class string_table;
}

namespace gnash {


class Trigger
{
public:

    Trigger(const std::string& propname, as_function& trig,
            const as_value& customArg)
        :
        _propname(propname),
        _func(&trig),
        _customArg(customArg),
        _executing(false),
        _dead(false)
    {}

    //
    as_value call(const as_value& oldval, const as_value& newval, 
            as_object& this_obj);

    bool dead() const { return _dead; }

    void kill() {
        _dead = true;
    }

    void setReachable() const;

private:

    //
    std::string _propname;

    as_function* _func;

    as_value _customArg;

    bool _executing;

    //
    bool _dead;

};

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

public:
    
    //
    explicit as_object(const Global_as& global);

    virtual ~as_object() {}

    //
    virtual as_value call(const fn_call& fn);

    //
    virtual std::string stringValue() const;

    //
    static const int DefaultFlags = PropFlags::dontDelete |
                                    PropFlags::dontEnum;

    //
    Property* findProperty(const ObjectURI& uri, as_object** owner = 0);

    VM& vm() const {
        return _vm;
    }

    //
    //
    void dump_members();

    //
    virtual bool set_member(const ObjectURI& uri, const as_value& val,
        bool ifFound = false);

    //
    //
    void init_member(const std::string& name, const as_value& val, 
        int flags = DefaultFlags);

    //
    //
    void init_member(const ObjectURI& uri, const as_value& val, 
        int flags = DefaultFlags);

    //
    void init_property(const std::string& key, as_function& getter,
        as_function& setter, int flags = DefaultFlags);
        

    //
    void init_property(const std::string& key, as_c_function_ptr getter,
        as_c_function_ptr setter, int flags = DefaultFlags);

    //
    //
    void init_property(const ObjectURI& uri, as_function& getter,
        as_function& setter, int flags = DefaultFlags);

    //
    void init_property(const ObjectURI& uri, as_c_function_ptr getter,
        as_c_function_ptr setter, int flags = DefaultFlags);

    //
    //
    bool init_destructive_property(const ObjectURI& uri, as_function& getter,
            int flags = PropFlags::dontEnum);

    //
    //
    bool init_destructive_property(const ObjectURI& uri, 
            as_c_function_ptr getter, int flags = PropFlags::dontEnum);

    //
    // 
    //
    void init_readonly_property(const std::string& key, as_function& getter,
            int flags = DefaultFlags);

    //
    void init_readonly_property(const std::string& key,
            as_c_function_ptr getter, int flags = DefaultFlags);

    //
    bool watch(const ObjectURI& uri, as_function& trig, const as_value& cust);

    //
    bool unwatch(const ObjectURI& uri);

    //
    //
    //
    virtual bool get_member(const ObjectURI& uri, as_value* val);

    virtual as_object* get_super(const ObjectURI& fname);
    as_object* get_super();

    //
    //
    std::pair<bool, bool> delProperty(const ObjectURI& uri);

    //
    //
    Property* getOwnProperty(const ObjectURI& uri);

    //
    void set_member_flags(const ObjectURI& uri, int setTrue, int setFalse = 0);

    virtual as_function* to_function() { return 0; }

    virtual bool isSuper() const { return false; }

    //
    //
    void addInterface(as_object* ctor);

    //
    //
    //
    bool instanceOf(as_object* ctor);

    //
    //
    bool prototypeOf(as_object& instance);

    //
    //
    void setPropFlags(const as_value& props, int set_false, int set_true);

    //
    //
    void copyProperties(const as_object& o);

    void clearProperties() {
        _members.clear();
    }

    //
    //
    template<typename T>
    void visitProperties(PropertyVisitor& visitor) const {
        _members.visitValues<T>(visitor);
    }

    //
    //
    //
    void visitKeys(KeyVisitor& visitor) const;

    //
    void add_property(const std::string& key, as_function& getter,
        as_function* setter);

    //
    as_object* get_prototype() const;

    //
    void set_prototype(const as_value& proto);

    //
    //
    //
    void setRelay(Relay* p) {
        if (p) _array = false;
        if (_relay) _relay->clean();
        _relay.reset(p);
    }

    //
    //
    Relay* relay() const {
        return _relay.get();
    }

    bool array() const {
        return _array;
    }

    void setArray(bool array = true) {
        _array = array;
    }

    //
    DisplayObject* displayObject() const {
        return _displayObject;
    }

    void setDisplayObject(DisplayObject* d) {
        _displayObject = d;
    }

protected:

    //
    explicit as_object(VM& vm);

    //
    virtual void markReachableResources() const;

private:

    //
    //
    Property* findUpdatableProperty(const ObjectURI& uri);

    void executeTriggers(Property* prop, const ObjectURI& uri,
            const as_value& val);

    template<typename T> class PrototypeRecursor;

    //
    DisplayObject* _displayObject;

    //
    bool _array;

    //
    boost::scoped_ptr<Relay> _relay;

    VM& _vm;

    PropertyList _members;

    //
    std::vector<as_object*> _interfaces;

    typedef std::map<ObjectURI, Trigger, ObjectURI::LessThan> TriggerContainer;
    boost::scoped_ptr<TriggerContainer> _trigs;
};

//
//
//
void sendEvent(as_object& o, const as_environment& env, const ObjectURI& name);

//
//
//
//
inline as_value
getMember(as_object& o, const ObjectURI& uri)
{
    as_value ret;
    o.get_member(uri, &ret);
    return ret;
}

//
//
//
inline as_value
getOwnProperty(as_object& o, const ObjectURI& uri)
{
    Property* p = o.getOwnProperty(uri);
    return p ? p->getValue(o) : as_value();
}

class IsVisible
{
public:
    IsVisible(int version) : _version(version) {}
    bool operator()(const Property& prop) const {
        return visible(prop, _version);
    }
private:
    const int _version;
};

class Exists
{
public:
    Exists() {}
    bool operator()(const Property&) const {
        return true;
    }
};

class IsEnumerable
{
public:
    IsEnumerable() {}
    bool operator()(const Property& p) const {
        return !p.getFlags().test<PropFlags::dontEnum>();
    }
};

//
//
std::string getURLEncodedVars(as_object& o);

//
as_object* getPathElement(as_object& o, const ObjectURI& uri);


//
template<typename T>
T*
get(as_object* o)
{
    if (!o) return 0;
    return dynamic_cast<T*>(o->displayObject());
}

//
inline bool
hasOwnProperty(as_object& o, const ObjectURI& uri)
{
    return (o.getOwnProperty(uri));
}

as_object* getObjectWithPrototype(Global_as& gl, const ObjectURI& c);

//
//
template<typename T>
bool
isNativeType(const as_object* obj, T*& relay)
{
    if (!obj) return false;
    relay = dynamic_cast<T*>(obj->relay());
    return relay;
}

//
typedef std::vector<std::pair<ObjectURI, as_value> > SortedPropertyList;
    
//
//
//
//
SortedPropertyList enumerateProperties(as_object& o);

VM& getVM(const as_object& o);

movie_root& getRoot(const as_object& o);

string_table& getStringTable(const as_object& o);

const RunResources& getRunResources(const as_object& o);

int getSWFVersion(const as_object& o);

Global_as& getGlobal(const as_object& o);

inline bool caseless(const as_object& o) {
    return getSWFVersion(o) < 7;
}

} // namespace gnash

#endif // GNASH_AS_OBJECT_H