File indexing completed on 2024-04-21 15:02:57

 /***************************************************************************
  * action.cpp
  * This file is part of the KDE project
  * copyright (C)2004-2006 by Sebastian Sauer (mail@dipe.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 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
  * Library General Public License for more details.
  * You should have received a copy of the GNU Library General Public License
  * along with this program; see the file COPYING.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  ***************************************************************************/
 
 #include "action.h"
 #include "actioncollection.h"
 #include "interpreter.h"
 #include "script.h"
 #include "manager.h"
 #include "wrapperinterface.h"
 #include "kross_debug.h"
 
 #include <QFile>
 #include <QFileInfo>
 
 #include <klocalizedstring.h>
 #include <qmimedatabase.h>
 
 using namespace Kross;
 
 namespace Kross
 {
 
 /// \internal d-pointer class.
 class Action::Private
 {
 public:
 
     /**
     * The \a Script instance the \a Action uses if initialized. It will
     * be NULL as long as we didn't initialized it what will be done on
     * demand.
     */
     Script *script;
 
     /**
     * The version number this \a Action has. Those version number got
     * used internally to deal with different releases of scripts.
     */
     int version;
 
     /**
     * The optional description to provide some more details about the
     * Action to the user.
     */
     QString description;
 
     /**
     * The name of the icon.
     */
     QString iconname;
 
     /**
     * The scripting code.
     */
     QByteArray code;
 
     /**
     * The name of the interpreter. This could be something
     * like for example "python" for the python binding.
     */
     QString interpretername;
 
     /**
     * The name of the scriptfile that should be executed. Those
     * scriptfile will be read and the content will be used to
     * set the scripting code and, if not defined, the used
     * interpreter.
     */
     QString scriptfile;
 
     /**
     * The path list where the \a Script may be located.
     * \todo after BIC break: don't keep it all the time,
     * as it is now passed to [to|from]DomElement
     */
     QStringList searchpath;
 
     /**
     * Map of options that overwritte the \a InterpreterInfo::Option::Map
     * standard options.
     */
     QMap< QString, QVariant > options;
 
     Private() : script(nullptr), version(0) {}
 };
 
 }
 
 enum InitOptions {Enable = 1};
 void static init(Action *th, const QString &name, int options = 0)
 {
     th->setEnabled(options & Enable);
     th->setObjectName(name);
 #ifdef KROSS_ACTION_DEBUG
     qCDebug(KROSS_LOG) << "Action::Action(QObject*,QString,QDir) Ctor name=" << th->objectName();
 #endif
     QObject::connect(th, SIGNAL(triggered(bool)), th, SLOT(slotTriggered()));
 }
 
 Action::Action(QObject *parent, const QString &name, const QDir &packagepath)
     : QAction(parent)
     , QScriptable()
     , ChildrenInterface()
     , ErrorInterface()
     , d(new Private())
 {
     init(this, name);
     d->searchpath = QStringList(packagepath.absolutePath());
 }
 
 Action::Action(QObject *parent, const QUrl &url)
     : QAction(parent)
     , ChildrenInterface()
     , ErrorInterface()
     , d(new Private())
 {
     init(this, url.path(), Enable);
     QFileInfo fi(url.toLocalFile());
     setText(fi.fileName());
     QMimeDatabase db;
     setIconName(db.mimeTypeForUrl(url).iconName());
     setFile(url.toLocalFile());
 }
 
 Action::~Action()
 {
 #ifdef KROSS_ACTION_DEBUG
     qCDebug(KROSS_LOG) << QStringLiteral("Action::~Action() Dtor name='%1'").arg(objectName());
 #endif
     finalize();
     ActionCollection *coll = qobject_cast<ActionCollection *>(parent());
     if (coll) {
         coll->removeAction(this);
     }
     delete d;
 }
 
 void Action::fromDomElement(const QDomElement &element)
 {
     fromDomElement(element, d->searchpath);
 }
 
 void Action::fromDomElement(const QDomElement &element, const QStringList &searchPath)
 {
     if (element.isNull()) {
         return;
     }
 
     QString file = element.attribute("file");
     if (! file.isEmpty()) {
         if (QFileInfo(file).exists()) {
             setFile(file);
         } else {
             foreach (const QString &packagepath, searchPath) {
                 QFileInfo fi(QDir(packagepath), file);
                 if (fi.exists()) {
                     setFile(fi.absoluteFilePath());
                     break;
                 }
             }
         }
     }
 
     d->version = QVariant(element.attribute("version", QString(d->version))).toInt();
 
     setText(i18nd(KLocalizedString::applicationDomain().constData(), element.attribute("text").toUtf8().constData()));
     const QString comment = element.attribute("comment");
     if (!comment.isEmpty()) {
         setDescription(i18nd(KLocalizedString::applicationDomain().constData(), comment.toUtf8().constData()));
     }
     setEnabled(true);
     setInterpreter(element.attribute("interpreter"));
     setEnabled(QVariant(element.attribute("enabled", "true")).toBool() && isEnabled());
 
     QString icon = element.attribute("icon");
     if (icon.isEmpty() && ! d->scriptfile.isNull()) {
         QMimeDatabase db;
         icon = db.mimeTypeForUrl(QUrl::fromLocalFile(d->scriptfile)).iconName();
     }
     setIconName(icon);
 
     const QString code = element.attribute("code");
     if (! code.isNull()) {
         setCode(code.toUtf8());
     }
 
     for (QDomNode node = element.firstChild(); ! node.isNull(); node = node.nextSibling()) {
         QDomElement e = node.toElement();
         if (! e.isNull()) {
             if (e.tagName() == "property") {
                 const QString n = e.attribute("name", QString());
                 if (! n.isNull()) {
 #ifdef KROSS_ACTION_DEBUG
                     qCDebug(KROSS_LOG) << "Action::readDomElement: Setting property name=" <<
                         n << " value=" << e.text();
 #endif
                     setProperty(n.toLatin1().constData(), QVariant(e.text()));
                 }
             }
         }
     }
 }
 
 QDomElement Action::toDomElement() const
 {
     return toDomElement(QStringList());
 }
 
 QDomElement Action::toDomElement(const QStringList &searchPath) const
 {
     QDomDocument doc;
     QDomElement e = doc.createElement("script");
     e.setAttribute("name", objectName());
     if (d->version > 0) {
         e.setAttribute("version", QString(d->version));
     }
     if (! text().isNull()) {
         e.setAttribute("text", text());
     }
     if (! description().isNull()) {
         e.setAttribute("comment", description());
     }
     if (! iconName().isNull()) {
         e.setAttribute("icon", iconName());
     }
     if (! isEnabled()) {
         e.setAttribute("enabled", "false");
     }
     if (! interpreter().isNull()) {
         e.setAttribute("interpreter", interpreter());
     }
 
     QString fileName = file();
     if (!searchPath.isEmpty()) {
         //fileName=QDir(searchPath.first()).relativeFilePath(fileName); //prefer absname if it is short?
         foreach (const QString &packagepath, searchPath) {
             QString nfn = QDir(packagepath).relativeFilePath(file());
             if (nfn.length() < fileName.length()) {
                 fileName = nfn;
             }
         }
     }
 
     if (! fileName.isNull()) {
         e.setAttribute("file", fileName);
     }
 
     QList<QByteArray> props = dynamicPropertyNames();
     foreach (const QByteArray &prop, props) {
         QDomElement p = doc.createElement("property");
         p.setAttribute("name", QString::fromLatin1(prop));
         p.appendChild(doc.createTextNode(property(prop.constData()).toString()));
         e.appendChild(p);
     }
     /*
     else if( ! code().isNull() ) {
         e.setAttribute("code", code());
     }
     */
 
     return e;
 }
 
 Kross::Script *Action::script() const
 {
     return d->script;
 }
 
 QString Action::name() const
 {
     return objectName();
 }
 
 int Action::version() const
 {
     return d->version;
 }
 
 QString Action::description() const
 {
     return d->description;
 }
 
 void Action::setDescription(const QString &description)
 {
     d->description = description;
     emit dataChanged(this);
     emit updated();
 }
 
 QString Action::iconName() const
 {
     return d->iconname;
 }
 
 void Action::setIconName(const QString &iconname)
 {
     setIcon(QIcon::fromTheme(iconname));
     d->iconname = iconname;
     emit dataChanged(this);
     emit updated();
 }
 
 bool Action::isEnabled() const
 {
     return QAction::isEnabled();
 }
 
 void Action::setEnabled(bool enabled)
 {
     QAction::setEnabled(enabled);
     emit dataChanged(this);
     emit updated();
 }
 
 QByteArray Action::code() const
 {
     return d->code;
 }
 
 void Action::setCode(const QByteArray &code)
 {
     if (d->code != code) {
         finalize();
         d->code = code;
         emit dataChanged(this);
         emit updated();
     }
 }
 
 QString Action::interpreter() const
 {
     return d->interpretername;
 }
 
 void Action::setInterpreter(const QString &interpretername)
 {
     if (d->interpretername != interpretername) {
         finalize();
         d->interpretername = interpretername;
         setEnabled(Manager::self().interpreters().contains(interpretername));
         if (!isEnabled()) {
             qCWarning(KROSS_LOG) << "Action::setInterpreter: interpreter not found: " << interpretername;
         }
         emit dataChanged(this);
         emit updated();
     }
 }
 
 QString Action::file() const
 {
     return d->scriptfile;
 }
 
 bool Action::setFile(const QString &scriptfile)
 {
     if (d->scriptfile != scriptfile) {
         finalize();
         if (scriptfile.isNull()) {
             if (! d->scriptfile.isNull()) {
                 d->interpretername.clear();
             }
             d->scriptfile.clear();
             d->searchpath.clear();
         } else {
             d->scriptfile = scriptfile;
             d->interpretername = Manager::self().interpreternameForFile(scriptfile);
             if (d->interpretername.isNull()) {
                 return false;
             }
         }
     }
     return true;
 }
 
 QString Action::currentPath() const
 {
     return file().isEmpty() ? QString() : QFileInfo(file()).absolutePath(); //obey Qt docs and don't cheat
 }
 
 QVariantMap Action::options() const
 {
     return d->options;
 }
 
 void Action::addQObject(QObject *obj, const QString &name)
 {
     this->addObject(obj, name);
 }
 
 QObject *Action::qobject(const QString &name) const
 {
     return this->object(name);
 }
 
 QStringList Action::qobjectNames() const
 {
     return this->objects().keys();
 }
 
 QVariant Action::option(const QString &name, const QVariant &defaultvalue)
 {
     if (d->options.contains(name)) {
         return d->options[name];
     }
     InterpreterInfo *info = Manager::self().interpreterInfo(d->interpretername);
     return info ? info->optionValue(name, defaultvalue) : defaultvalue;
 }
 
 bool Action::setOption(const QString &name, const QVariant &value)
 {
     InterpreterInfo *info = Manager::self().interpreterInfo(d->interpretername);
     if (info) {
         if (info->hasOption(name)) {
             d->options.insert(name, value);
             return true;
         } else {
             qCWarning(KROSS_LOG) << QStringLiteral("Kross::Action::setOption(%1, %2): No such option")
                 .arg(name).arg(value.toString());
         }
     } else {
         qCWarning(KROSS_LOG) << QStringLiteral("Kross::Action::setOption(%1, %2): No such interpreterinfo")
             .arg(name).arg(value.toString());
     }
     return false;
 }
 
 QStringList Action::functionNames()
 {
     if (! d->script) {
         if (! initialize()) {
             return QStringList();
         }
     }
     return d->script->functionNames();
 }
 
 QVariant Action::callFunction(const QString &name, const QVariantList &args)
 {
     if (! d->script) {
         if (! initialize()) {
             return QVariant();
         }
     }
     return d->script->callFunction(name, args);
 }
 
 QVariant Action::evaluate(const QByteArray &code)
 {
     if (! d->script) {
         if (! initialize()) {
             return QVariant();
         }
     }
     return d->script->evaluate(code);
 }
 
 bool Action::initialize()
 {
     finalize();
 
     if (! d->scriptfile.isNull()) {
         QFile f(d->scriptfile);
         if (! f.exists()) {
             setError(i18n("Scriptfile \"%1\" does not exist.", d->scriptfile));
             return false;
         }
         if (d->interpretername.isNull()) {
             setError(i18n("Failed to determine interpreter for scriptfile \"%1\"", d->scriptfile));
             return false;
         }
         if (! f.open(QIODevice::ReadOnly)) {
             setError(i18n("Failed to open scriptfile \"%1\"", d->scriptfile));
             return false;
         }
         d->code = f.readAll();
         f.close();
     }
 
     Interpreter *interpreter = Manager::self().interpreter(d->interpretername);
     if (! interpreter) {
         InterpreterInfo *info = Manager::self().interpreterInfo(d->interpretername);
         if (info) {
             setError(i18n("Failed to load interpreter \"%1\"", d->interpretername));
         } else {
             setError(i18n("No such interpreter \"%1\"", d->interpretername));
         }
         return false;
     }
 
     d->script = interpreter->createScript(this);
     if (! d->script) {
         setError(i18n("Failed to create script for interpreter \"%1\"", d->interpretername));
         return false;
     }
 
     if (d->script->hadError()) {
         setError(d->script);
         finalize();
         return false;
     }
 
     clearError(); // clear old exception
     return true;
 }
 
 void Action::finalize()
 {
     if (d->script) {
         emit finalized(this);
     }
     delete d->script;
     d->script = nullptr;
 }
 
 bool Action::isFinalized() const
 {
     return d->script == nullptr;
 }
 
 void Action::slotTriggered()
 {
 #ifdef KROSS_ACTION_DEBUG
     qCDebug(KROSS_LOG) << "Action::slotTriggered() name=" << objectName();
 #endif
 
     emit started(this);
 
     if (! d->script) {
         if (! initialize()) {
             Q_ASSERT(hadError());
         }
     }
 
     if (hadError()) {
 #ifdef KROSS_ACTION_DEBUG
         qCDebug(KROSS_LOG) << "Action::slotTriggered() on init, errorMessage=" << errorMessage();
 #endif
     } else {
         d->script->execute();
         if (d->script->hadError()) {
 #ifdef KROSS_ACTION_DEBUG
             qCDebug(KROSS_LOG) << "Action::slotTriggered() after exec, errorMessage=" << errorMessage();
 #endif
             setError(d->script);
             //emit finished(this);
             finalize();
             //return;
         }
     }
 
     emit finished(this);
 }
 
 // --------
 
 // interface files
 WrapperInterface::~WrapperInterface()
 {
 }
 
 #include "moc_action.cpp"