scriptableextension.h

Go to the documentation of this file.

/* This file is part of the KDE project
   Copyright (C) 2010 Maksim Orlovich <maksim@kde.org>
   Copyright (C) 2002 Koos Vriezen <koos.vriezen@gmail.com>

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.

   This library 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
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
*/

#ifndef kparts_scriptableextension_h
#define kparts_scriptableextension_h

#include <QtGlobal>
#include <QObject>
#include <QVariant>
#include <kparts/part.h>

namespace KParts {

class  ScriptableExtension;
struct ScriptableExtensionPrivate;
class  LiveConnectExtension;

class KPARTS_EXPORT ScriptableExtension: public QObject
{
    Q_OBJECT
public:
    struct Null {};

    struct Undefined {};

    struct Exception {
        QString message;

        Exception() {}
        Exception(const QString& msg): message(msg) {}
    };

    struct Object {
        ScriptableExtension* owner;
        quint64              objId;

        Object(): owner(0), objId(0) {}
        Object(ScriptableExtension* o, quint64 id): owner(o), objId(id) {}
        bool operator==(const Object& other) const { return owner == other.owner && objId == other.objId; }
    };

    struct FunctionRef {
        Object   base;
        QString  field;

        FunctionRef() {}
        FunctionRef(const Object& b, const QString&f): base(b), field(f) {}
        bool operator==(const FunctionRef& other) const { return base == other.base && field == other.field; }
    };




protected:
    ScriptableExtension(QObject* parent);
public:
    virtual ~ScriptableExtension();

    static ScriptableExtension* childObject(QObject* obj);

    static ScriptableExtension* adapterFromLiveConnect(QObject* parentObj,
                                                       LiveConnectExtension* oldApi);





    void setHost(ScriptableExtension* host);

    ScriptableExtension* host() const;

    virtual QVariant rootObject();

    QVariant enclosingObject();



    typedef QList<QVariant> ArgList;

    virtual QVariant callAsFunction(ScriptableExtension* callerPrincipal, quint64 objId, const ArgList& args);

    virtual QVariant callFunctionReference(ScriptableExtension* callerPrincipal, quint64 objId,
                                           const QString& f, const ArgList& args);

    virtual QVariant callAsConstructor(ScriptableExtension* callerPrincipal, quint64 objId, const ArgList& args);

    virtual bool hasProperty(ScriptableExtension* callerPrincipal, quint64 objId, const QString& propName);

    virtual QVariant get(ScriptableExtension* callerPrincipal, quint64 objId, const QString& propName);

    virtual bool put(ScriptableExtension* callerPrincipal, quint64 objId, const QString& propName, const QVariant& value);

    virtual bool removeProperty(ScriptableExtension* callerPrincipal, quint64 objId, const QString& propName);

    virtual bool enumerateProperties(ScriptableExtension* callerPrincipal, quint64 objId, QStringList* result);

    virtual bool setException(ScriptableExtension* callerPrincipal, const QString& message);


    enum ScriptLanguage {
        ECMAScript, 
        EnumLimit = 0xFFFF
    };
    
    virtual QVariant evaluateScript(ScriptableExtension* callerPrincipal,
                                    quint64 contextObjectId,
                                    const QString& code,
                                    ScriptLanguage language = ECMAScript);

    virtual bool isScriptLanguageSupported(ScriptLanguage lang) const;

    virtual void acquire(quint64 objid);

    static QVariant acquireValue(const QVariant& v);

    virtual void release(quint64 objid);

    static QVariant releaseValue(const QVariant& v);

private:
    virtual QVariant encloserForKid(KParts::ScriptableExtension* kid);

    ScriptableExtensionPrivate* const d;
};

KPARTS_EXPORT unsigned int qHash(const KParts::ScriptableExtension::Object& o);

KPARTS_EXPORT unsigned int qHash(const KParts::ScriptableExtension::FunctionRef& f);

} // namespace KParts

Q_DECLARE_METATYPE(KParts::ScriptableExtension::Null)
Q_DECLARE_METATYPE(KParts::ScriptableExtension::Undefined)
Q_DECLARE_METATYPE(KParts::ScriptableExtension::Exception)
Q_DECLARE_METATYPE(KParts::ScriptableExtension::Object)
Q_DECLARE_METATYPE(KParts::ScriptableExtension::FunctionRef)

#endif

// kate: indent-width 4; replace-tabs on; tab-width 4; space-indent on;