faithcore/faith/object.h

Go to the documentation of this file.

#ifndef KDE__OBJECT_H
#define KDE__OBJECT_H

#define K_OBJECT Q_OBJECT
#define Q_OBJECT \
protected: \
        virtual void *faith_get_list_for_signal_magna(const char *) const; \
        virtual bool faith_add_slot_to_list_magna(const char *, void *) const; \
        virtual bool faith_inherits_magna(const char *) const; \
        virtual const char *className() const; \
        int faith_vector_size() const; \
private:

#define emit

#define SIGNAL(sig) (#sig)
#define SLOT(slot) (#slot)

#define slots
#define signals protected

#include <faith/event.h>
#include <faith/core.h>

#include <list>
#include <set>

// timeval
#ifdef WIN32
        
#else
#include <sys/time.h>
#endif


namespace Faith
{

typedef const char *Slot;
typedef const char *Signal;

class Widget;

struct TimerInfo;

class FAITH_CORE_EXPORT Object
{
        K_OBJECT
        Object *mParent;
        const char *mName;
        struct Private;
        Private *d;
        friend class Application;
        friend class Widget;

        std::list<TimerInfo*> mTimers;
        std::list<Object*> mFilters;

        enum MagicFlags
        {
                MagicIsWidget=1
        };

        int mMagicFlags;


        void *faith_connector_map;

public:
        struct Faith_CalledSlot
        {
                Faith::Object *source;
                void *signalListItem;
                void *signalList;
        };

protected:
        mutable void **faith_callbacks_magna;

        void faith_magna_slot_begin(Faith_CalledSlot *slot);
        void faith_magna_slot_end(Faith_CalledSlot *slot);

private:
        Object(int magicflags, Object *parent, const char *name);

public:
        Object(Object *parent=0, const char *name=0);
        virtual ~Object();

        inline bool isA(const char *type) const { return faith_inherits_magna(type); }

        bool isWidgetType() const { return mMagicFlags & MagicIsWidget; }

        const char *name() const { return mName; }
        Object *parent() { return mParent; }
        
        const Object *parent() const { return mParent; }

        static bool connect(const Faith::Object *from, Signal signal, Faith::Object *to, Slot slot)
        {
                return to->connect(from, signal, slot);
        }

        bool connect(const Faith::Object *from, Signal signal, Slot slot);
        
        void blockSignals(bool on);
        
        bool signalsBlocked() const;

        int startTimer(int msecs);
        void killTimer(int id);

        void killTimers();

        virtual bool event(Event *event);

        void installEventFilter(Faith::Object *filter);

        void removeEventFilter(Faith::Object *filter);

public slots:
        void deleteLater();

protected:

        virtual void timerEvent(Faith::TimerEvent *) { }
        
        virtual void userEvent(Faith::Event *) { }
        
        virtual bool eventFilter(Faith::Object *filtered, Faith::Event *e);
        


protected:
        std::set<Faith::Object*>::iterator beginChildren();
        std::set<Faith::Object*>::iterator endChildren();

private:
        bool kde_event(Faith::Event *event);
};

template<class T> struct faith_callback_magna
{
    Faith::Object *obj;
    T method;
};

}




#endif

---