abstractrunner.h

Go to the documentation of this file.

/*
 *   Copyright 2006-2007 Aaron Seigo <aseigo@kde.org>
 *
 *   This program 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, 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 Library 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.
 */

#ifndef PLASMA_ABSTRACTRUNNER_H
#define PLASMA_ABSTRACTRUNNER_H

#include <QtCore/QObject>
#include <QtCore/QMutex>
#include <QtCore/QStringList>

#include <kconfiggroup.h>
#include <kservice.h>

#include <plasma/plasma_export.h>
#include <plasma/querymatch.h>
#include <plasma/runnercontext.h>
#include <plasma/runnersyntax.h>
#include <plasma/version.h>

class QAction;
class QMimeData;

class KCompletion;

namespace Plasma
{

class DataEngine;
class Package;
class RunnerScript;
class QueryMatch;
class AbstractRunnerPrivate;

class PLASMA_EXPORT AbstractRunner : public QObject
{
    Q_OBJECT
    Q_PROPERTY(bool matchingSuspended READ isMatchingSuspended WRITE suspendMatching NOTIFY matchingSuspended)

    public:
        enum Speed {
            SlowSpeed,
            NormalSpeed
        };

        enum Priority {
            LowestPriority = 0,
            LowPriority,
            NormalPriority,
            HighPriority,
            HighestPriority
        };

        typedef QList<AbstractRunner*> List;

        virtual ~AbstractRunner();

        virtual void match(Plasma::RunnerContext &context);

        void performMatch(Plasma::RunnerContext &context);

        bool hasRunOptions();

        virtual void createRunOptions(QWidget *widget);

        virtual void run(const Plasma::RunnerContext &context, const Plasma::QueryMatch &match);

        Speed speed() const;

        Priority priority() const;

        RunnerContext::Types ignoredTypes() const;

        void setIgnoredTypes(RunnerContext::Types types);

        QString name() const;

        QString id() const;

        QString description() const;

        QIcon icon() const;

        const Package *package() const;

        virtual void reloadConfiguration();

        QList<RunnerSyntax> syntaxes() const;

        static QMutex *bigLock();

        RunnerSyntax *defaultSyntax() const;

        bool isMatchingSuspended() const;

    Q_SIGNALS:
        void prepare();

        void teardown();

        void matchingSuspended(bool suspended);

    protected:
        friend class RunnerManager;
        friend class RunnerManagerPrivate;

        explicit AbstractRunner(QObject *parent = 0, const QString &path = QString());
        explicit AbstractRunner(const KService::Ptr service, QObject *parent = 0);

        AbstractRunner(QObject *parent, const QVariantList &args);

        void suspendMatching(bool suspend);

        KConfigGroup config() const;

        void setHasRunOptions(bool hasRunOptions);

        void setSpeed(Speed newSpeed);

        void setPriority(Priority newPriority);

        KService::List serviceQuery(const QString &serviceType,
                                    const QString &constraint = QString()) const;

        virtual QList<QAction*> actionsForMatch(const Plasma::QueryMatch &match);

        QAction* addAction(const QString &id, const QIcon &icon, const QString &text);

        void addAction(const QString &id, QAction *action);

        void removeAction(const QString &id);

        QAction* action(const QString &id) const;

        QHash<QString, QAction*> actions() const;

        void clearActions();

        void addSyntax(const RunnerSyntax &syntax);

        void setDefaultSyntax(const RunnerSyntax &syntax);

        void setSyntaxes(const QList<RunnerSyntax> &syns);

        Q_INVOKABLE DataEngine *dataEngine(const QString &name) const;

    protected Q_SLOTS:
        void init();

        QMimeData * mimeDataForMatch(const Plasma::QueryMatch *match);

    private:
        friend class RunnerScript;

        AbstractRunnerPrivate *const d;
};

} // Plasma namespace

#define K_EXPORT_PLASMA_RUNNER( libname, classname )     \
K_PLUGIN_FACTORY(factory, registerPlugin<classname>();) \
K_EXPORT_PLUGIN(factory("plasma_runner_" #libname)) \
K_EXPORT_PLUGIN_VERSION(PLASMA_VERSION)

#define K_EXPORT_RUNNER_CONFIG( name, classname )     \
K_PLUGIN_FACTORY(ConfigFactory, registerPlugin<classname>();) \
K_EXPORT_PLUGIN(ConfigFactory("kcm_krunner_" #name)) \
K_EXPORT_PLUGIN_VERSION(PLASMA_VERSION)

#endif