KviKvsObject.h

Go to the documentation of this file.

#ifndef _KVI_KVS_OBJECT_H_
#define _KVI_KVS_OBJECT_H_
//=============================================================================
//
//   File : KviKvsObject.h
//   Creation date : Wed 08 Oct 2003 02:31:57 by Szymon Stefanek
//
//   This file is part of the KVIrc IRC client distribution
//   Copyright (C) 2003-2010 Szymon Stefanek <pragma at kvirc dot net>
//
//   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 2
//   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 Street, Fifth Floor, Boston, MA 02110-1301, USA.
//
//=============================================================================

#include "kvi_settings.h"
#include "KviQString.h"
#include "KviPointerList.h"
#include "KviKvsRunTimeCall.h"
#include "KviKvsParameterProcessor.h"
#include "KviKvsObjectFunctionHandler.h"
#include "KviKvsTypes.h"

#include <QObject>

class KviKvsObjectFunctionCall;

typedef struct _KviKvsObjectConnection
{
        KviKvsObject * pSourceObject; // source object (owner of the struct)
        KviKvsObject * pTargetObject; // target object
        QString szSignal;             // source signal name
        QString szSlot;               // target slot function
} KviKvsObjectConnection;

typedef KviPointerList<KviKvsObjectConnection> KviKvsObjectConnectionList;
typedef KviPointerListIterator<KviKvsObjectConnection> KviKvsObjectConnectionListIterator;

class KVIRC_API KviKvsObject : public QObject
{
        friend class KviKvsObjectController;
        friend class KviKvsObjectClass;
        Q_OBJECT
public:
        KviKvsObject(KviKvsObjectClass * pClass, KviKvsObject * pParent, const QString & szName);
        virtual ~KviKvsObject();

protected:
        // main data
        QString m_szName;             // object name
        kvs_hobject_t m_hObject;      // global object handle
        KviKvsObjectClass * m_pClass; // the class definition

        KviKvsHash * m_pDataContainer; // member variables

        KviPointerList<KviKvsObject> * m_pChildList;

        KviPointerHashTable<QString, KviKvsObjectFunctionHandler> * m_pFunctionHandlers; // our function handlers

        KviPointerHashTable<QString, KviKvsObjectConnectionList> * m_pSignalDict; // our signals connected to other object functions

        KviKvsObjectConnectionList * m_pConnectionList; // signals connected to this object functions

        // this is valid when processing one of our slots
        kvs_hobject_t m_hSignalSender;
        QString m_szSignalName;

        // if this object wraps a qt one, it is here
        QObject * m_pObject;
        bool m_bObjectOwner; // do we have to destroy it ?

        // We're going to die soon after the control is given back to the event loop
        bool m_bInDelayedDeath;
        // We're going to die BEFORE the control is given back to the event loop
        bool m_bAboutToDie;
        // Did we already call the destructor ?
        bool m_bDestructorCalled;

public:
        kvs_hobject_t handle() { return m_hObject; };

        // the wrapped Qt object (may be 0!)
        QObject * object() const { return m_pObject; };
        void setObject(QObject * o, bool bIsOwned = true);

        const QString & getName() { return m_szName; };

        KviKvsObject * parentObject() { return (KviKvsObject *)parent(); };
        QWidget * parentScriptWidget();

        bool connectSignal(const QString & sigName, KviKvsObject * target, const QString & slotName);
        bool disconnectSignal(const QString & sigName, KviKvsObjectConnection * con);
        bool disconnectSignal(const QString & sigName, KviKvsObject * target, const QString & slotName);

        // Emits a signal by calling all the attacched slots in an unspecified order.
        // Returns the number of slots called (may be 0, if no slot is connected)
        // The parameters are preserved.
        // this is intended to be called from other function calls (the parameters are copied from pOuterCall)
        // since we should NEVER emit totally spontaneous signals: all of them
        // should be generated inside object functions (either from scripting or by core calls)
        int emitSignal(const QString & sigName, KviKvsObjectFunctionCall * pOuterCall, KviKvsVariantList * pParams = 0);

        void setSignalSender(kvs_hobject_t hObject) { m_hSignalSender = hObject; };
        kvs_hobject_t signalSender() { return m_hSignalSender; };
        void setSignalName(const QString & szSigName) { m_szSignalName = szSigName; };

        KviPointerHashTable<QString, KviKvsObjectFunctionHandler> * functionHandlers() { return m_pFunctionHandlers; };

        KviKvsHash * dataContainer() { return m_pDataContainer; };

        bool die();
        bool dieNow();

        KviKvsObjectClass * getExactClass() { return m_pClass; };
        KviKvsObjectClass * getClass(const QString & classOverride = QString());
        bool inheritsClass(KviKvsObjectClass * pClass);
        bool inheritsClass(const QString & szClass);

        KviKvsObjectFunctionHandler * lookupFunctionHandler(const QString & funcName, const QString & classOverride = QString());

        // Registers a private implementation of a function
        // The function may or may not be already registered in the class
        // If szCode is empty the the private implementation is removed instead
        void registerPrivateImplementation(const QString & szFunctionName, const QString & szCode);

        // ONLY pCaller can be zero here!
        // please use one of the wrappers, if possible
        bool callFunction(
            KviKvsObject * pCaller,          // calling object, can be zero (used for the "internal" access list verification)
            const QString & fncName,         // name of the function to call
            const QString & classOverride,   // eventual class override for the functon call, may be QString()
            KviKvsRunTimeContext * pContext, // calling runtime context (you'll have problems with instantiating this... :P )
            KviKvsVariant * pRetVal,         // the return value
            KviKvsVariantList * pParams);    // the parameters for the call
        // a nice and simple wrapper: it accepts a parameter list only (eventually 0)
        bool callFunction(KviKvsObject * pCaller, const QString & fncName, KviKvsVariantList * pParams = 0);
        // this one gets a non null ret val too
        bool callFunction(KviKvsObject * pCaller, const QString & fncName, KviKvsVariant * pRetVal, KviKvsVariantList * pParams = 0);

        KviKvsObject * findChild(const QString & szClass, const QString & szName);
        void killAllChildrenWithClass(KviKvsObjectClass * cl);

protected:
        void registerConnection(KviKvsObjectConnection * con);
        bool unregisterConnection(KviKvsObjectConnection * con);

        virtual bool init(KviKvsRunTimeContext * pContext, KviKvsVariantList * pParams);

        void registerChild(KviKvsObject * c);
        void unregisterChild(KviKvsObject * c);

        virtual bool eventFilter(QObject * o, QEvent * e); //necessary ?
        virtual void timerEvent(QTimerEvent * e);

protected:
        bool function_name(KviKvsObjectFunctionCall * c);
        bool function_startTimer(KviKvsObjectFunctionCall * c);
        bool function_killTimer(KviKvsObjectFunctionCall * c);
        bool function_className(KviKvsObjectFunctionCall * c);
        bool function_findChild(KviKvsObjectFunctionCall * c);
        bool function_childCount(KviKvsObjectFunctionCall * c);
        bool function_emit(KviKvsObjectFunctionCall * c);
        bool function_children(KviKvsObjectFunctionCall * c);
        bool function_signalSender(KviKvsObjectFunctionCall * c);
        bool function_signalName(KviKvsObjectFunctionCall * c);
        bool function_destructor(KviKvsObjectFunctionCall * c);
        bool function_parent(KviKvsObjectFunctionCall * c);
        bool function_property(KviKvsObjectFunctionCall * c);
        bool function_setProperty(KviKvsObjectFunctionCall * c);
        bool function_listProperties(KviKvsObjectFunctionCall * c);
protected slots:
        void delayedDie();
        void objectDestroyed();

private:
        void callDestructor();
};

#define KVSO_PARAMETER(a, b, c, d) KVS_PARAMETER(a, b, c, d)

#define KVSO_PARAMETERS_BEGIN(pCall) \
        KVS_PARAMETERS_BEGIN(parameter_format_list)

#define KVSO_PARAMETERS_END(pCall)                                                                   \
        KVS_PARAMETERS_END                                                                               \
        if(!KviKvsParameterProcessor::process(pCall->params(), pCall->context(), parameter_format_list)) \
                return false;

#endif