basicobject.h

Go to the documentation of this file.

#ifndef BASICOBJECT_H
#define BASICOBJECT_H

#include "SDL/SDL.h" // just for DECLSPEC
#include <list>

#include "tinyxml.h"

#define DECLARE_SLOT(name,classname,func)\
 static BasicSlot classname ## __ ## name(#name,#classname,func);

class BasicObject;

class BasicSlot
{
public:
    typedef void (*Callback)(void *sender, BasicObject *reciever, void *data);
    DECLSPEC BasicSlot(const char *fname, const char *classname, Callback func);
    virtual DECLSPEC ~BasicSlot();
    Callback getFunction()  {return pFunc;}
    const char *getName()   {return strName;}
    bool matchName(const char *name)    {return strcmp(strName, name) == 0;}
    BasicSlot *beNext;
    static BasicSlot *getFirst()    {return beFirst;}
    static Callback getFunction(const char *name, const char *classname = NULL);
private:
    Callback pFunc;
    char *strName, *strClassName;
    // pointer to the first event in the global event list
    static BasicSlot *beFirst;
};

class BasicObject
{
public:
    typedef BasicSlot::Callback Callback;
    struct FunctionData
    {
        Callback func;
        BasicObject *obj;
        FunctionData(): func(NULL), obj(NULL)
        {
        }
        FunctionData(Callback f, BasicObject *p = NULL): func(f), obj(p)
        {
        }
    };
    DECLSPEC BasicObject(const char *name, BasicObject *parent);
    DECLSPEC BasicObject( TiXmlElement *el, BasicObject *p );
    virtual DECLSPEC ~BasicObject();
    TiXmlElement *getXmlData()  { return xmlData; }
    
    virtual const char *getClassName()  { return "BasicObject"; }
    DECLSPEC bool matchName(const char *name);
    DECLSPEC FunctionData getFunctionByName(const char *name);
    DECLSPEC Callback getFuncByName( const char *name );
    DECLSPEC BasicObject *getObjectByName( const char *name );
    DECLSPEC BasicObject *getChildWithName( const char *name );
    const char *getName() const { return strName; }
    BasicObject *getParent() const  { return parent; }
    unsigned int numChildren()  { return children.size(); }
    virtual bool isUiObject() const { return false; }
    virtual bool isNetSocket() const    { return false; }
    
    void init() { onInit(); }
    void destroy()  {onDestroy();}
    
    static BasicObject *getObject(const char *name) { return pBase? pBase->getObjectByName(name) : NULL; }
    static Callback getFunc(const char *name)   { return pBase? pBase->getFuncByName(name) : NULL; }
    DECLSPEC static FunctionData getFunction(const char *name);

protected:
    typedef std::list<BasicObject*> child_list;
    typedef child_list::iterator child_iter;
    typedef child_list::reverse_iterator child_reverse_iter;
    typedef std::list<BasicSlot *>::iterator EventIter;
    
    virtual DECLSPEC void onInit();
    virtual DECLSPEC void onDestroy();

    TiXmlElement *xmlData;
    // the object's children
    child_list children;
    // item of this object in the parent's children list
    child_iter parentitem;
private:
    // adds a child, name must not be NULL
    child_iter addChild( BasicObject *obj, const char *name, bool top = true );
    // removes a child and frees its name
    void removeChild( BasicObject *obj );
    
    // pointer to the parent object
    BasicObject *parent;
    // allocated/freed by parent
    char *strName;
    
    // pointer to the last object, created without parent
    static BasicObject *pBase;
    friend class UiManager;
    friend class UiObject;
};

class TiXmlElement;

class SignalMultiplier : public BasicObject
{
public:
    DECLSPEC SignalMultiplier(const char *name, BasicObject *parent);
    DECLSPEC SignalMultiplier(TiXmlElement *el, BasicObject *parent);
    DECLSPEC ~SignalMultiplier();
    DECLSPEC void addSlot(Callback func, BasicObject *aim);
    DECLSPEC void removeSlot(Callback func, BasicObject *aim);
    
    static void event(void *sender, BasicObject *aim, void *data)
    {
        ((SignalMultiplier*)aim)->onevent(sender, data);
    }
protected:
    DECLSPEC void onInit();
    
private:
    DECLSPEC void onevent(void *sender, void *data);
    typedef std::list<BasicObject::FunctionData> cblist;
    cblist aims;
};

#endif

---