File indexing completed on 2024-04-14 14:27:12

 /* This file is part of the KDE project
    Copyright (C) 2008 Paulo Moura Guedes <moura@kdewebdev.org>
 
    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.
 */
 
 #include "scriptingplugin.h"
 
 #include <krun.h>
 #include <kxmlguifactory.h>
 #include <kactioncollection.h>
 #include <kross/core/manager.h>
 #include <kross/core/actioncollection.h>
 
 #include <QAction>
 #include <QPointer>
 #include <QTextStream>
 #include <QDirIterator>
 #include <QUrl>
 #include <QStandardPaths>
 
 using namespace Kross;
 
 struct Object {
     QPointer<QObject> object;
     ChildrenInterface::Options options;
     Object(QObject *obj, ChildrenInterface::Options opt): object(obj), options(opt) {}
 };
 
 /// \internal d-pointer class
 class ScriptingPlugin::ScriptingPluginPrivate
 {
 public:
     QString collectionName;
     QString userActionsFile;
     QString referenceActionsDir;
     QHash<QString, Object> objects;
 
     QDomElement menuFromName(QString const &name, const QDomDocument &document)
     {
         QDomElement menuBar = document.documentElement().firstChildElement("MenuBar");
         QDomElement menu = menuBar.firstChildElement("Menu");
         for (; !menu.isNull(); menu = menu.nextSiblingElement("Menu")) {
             if (menu.attribute("name") == name) {
                 return menu;
             }
         }
         return QDomElement();
     }
 };
 
 ScriptingPlugin::ScriptingPlugin(QObject *parent)
     : KParts::Plugin(parent)
     , d(new ScriptingPluginPrivate())
 {
     d->userActionsFile = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + QLatin1Char('/') + "scripts/scriptactions.rc";
     d->collectionName = "scripting-plugin";
 }
 
 ScriptingPlugin::ScriptingPlugin(const QString &collectionName, const QString &userActionsFile, const QString &referenceActionsDir, QObject *parent)
     : KParts::Plugin(parent)
     , d(new ScriptingPluginPrivate())
 {
     d->collectionName = collectionName;
     d->userActionsFile = userActionsFile;
     d->referenceActionsDir = referenceActionsDir;
 }
 
 ScriptingPlugin::~ScriptingPlugin()
 {
     if (QFile::exists(d->userActionsFile)) {
         save();
     }
 
     Kross::ActionCollection *collection = Kross::Manager::self().actionCollection()->collection(d->collectionName);
     if (collection) {
         collection->setParentCollection(nullptr);
         collection->deleteLater();
     }
 
     delete d;
 }
 
 void ScriptingPlugin::setDOMDocument(const QDomDocument &document, bool merge)
 {
     QDomDocument doc = buildDomDocument(document);
     KXMLGUIClient::setDOMDocument(doc, merge);
 }
 
 void ScriptingPlugin::addObject(QObject *object, const QString &name)
 {
     QString n = name.isNull() ? object->objectName() : name;
     d->objects.insert(n, Object(object, ChildrenInterface::NoOption));
 }
 
 void ScriptingPlugin::addObject(QObject *object, const QString &name, ChildrenInterface::Options options)
 {
     QString n = name.isNull() ? object->objectName() : name;
     d->objects.insert(n, Object(object, options));
 }
 
 QDomDocument ScriptingPlugin::buildDomDocument(const QDomDocument &document)
 {
     Kross::ActionCollection *collection = Kross::Manager::self().actionCollection()->collection(d->collectionName);
     if (!collection) {
         collection = new Kross::ActionCollection(d->collectionName, Kross::Manager::self().actionCollection());
     }
 
     QStringList allActionFiles;
     const QStringList scriptDirs = QStandardPaths::locateAll(QStandardPaths::AppDataLocation, QStringLiteral("scripts/") + d->referenceActionsDir, QStandardPaths::LocateDirectory);
     Q_FOREACH (const QString &scriptDir, scriptDirs) {
         QDirIterator it(scriptDir, QStringList() << QStringLiteral("*.rc"));
         while (it.hasNext()) {
             allActionFiles.append(it.next());
         }
     }
 
     //move userActionsFile to the end so that it updates existing actions and adds new ones.
     int pos = allActionFiles.indexOf(d->userActionsFile);
     if (pos != -1) {
         allActionFiles.append(allActionFiles.takeAt(pos));
     } else if (QFile::exists(d->userActionsFile)) { //in case d->userActionsFile isn't in the standard local dir
         allActionFiles.append(d->userActionsFile);
     }
 
     QStringList searchPath = QStandardPaths::locateAll(QStandardPaths::AppDataLocation, QStringLiteral("scripts/") + d->referenceActionsDir, QStandardPaths::LocateDirectory);
     foreach (const QString &file, allActionFiles) {
         QFile f(file);
         if (!f.open(QIODevice::ReadOnly)) {
             continue;
         }
 
         collection->readXml(&f, searchPath + QStringList(QFileInfo(f).absolutePath()));
         f.close();
 
     }
 
     QDomDocument doc(document);
     buildDomDocument(doc, collection);
 
     return doc;
 }
 
 void ScriptingPlugin::buildDomDocument(QDomDocument &document,
                                        Kross::ActionCollection *collection)
 {
     QDomElement menuElement = d->menuFromName(collection->name(), document);
 
     foreach (Kross::Action *action, collection->actions()) {
         QHashIterator<QString, Object> i(d->objects);
         while (i.hasNext()) {
             i.next();
             action->addObject(i.value().object, i.key(), i.value().options);
         }
 
         // Create and append new Menu element if doesn't exist
         if (menuElement.isNull()) {
             menuElement = document.createElement("Menu");
             menuElement.setAttribute("name", collection->name());
             menuElement.setAttribute("noMerge", "0");
 
             QDomElement textElement = document.createElement("text");
             textElement.appendChild(document.createTextNode(collection->text()));
             menuElement.appendChild(textElement);
 
             Kross::ActionCollection *parentCollection = collection->parentCollection();
             QDomElement root;
             if (parentCollection) {
                 QDomElement parentMenuElement = d->menuFromName(parentCollection->name(), document);
                 if (!parentMenuElement.isNull()) {
                     root = parentMenuElement;
                 }
             }
             if (root.isNull()) {
                 root = document.documentElement().firstChildElement("MenuBar");
             }
             root.appendChild(menuElement);
         }
 
         // Create and append new Action element
         QDomElement newActionElement = document.createElement("Action");
         newActionElement.setAttribute("name", action->name());
 
         menuElement.appendChild(newActionElement);
 
         QAction *adaptor = new QAction(action->text(), action);
         connect(adaptor, SIGNAL(triggered()), action, SLOT(trigger()));
         adaptor->setEnabled(action->isEnabled());
         adaptor->setIcon(action->icon());
         actionCollection()->addAction(action->name(), adaptor);
     }
 
     foreach (const QString &collectionname, collection->collections()) {
         Kross::ActionCollection *c = collection->collection(collectionname);
         if (c->isEnabled()) {
             buildDomDocument(document, c);
         }
     }
 }
 
 void ScriptingPlugin::save()
 {
     QFile f(d->userActionsFile);
     if (!f.open(QIODevice::WriteOnly)) {
         return;
     }
 
     Kross::ActionCollection *collection = Kross::Manager::self().actionCollection()->collection(d->collectionName);
     bool collectionEmpty = !collection || (collection->actions().empty() && collection->collections().empty());
 
     if (!collectionEmpty) {
         QStringList searchPath = QStandardPaths::locateAll(QStandardPaths::AppDataLocation, QStringLiteral("scripts/") + d->referenceActionsDir, QStandardPaths::LocateDirectory);
         searchPath.append(QFileInfo(d->userActionsFile).absolutePath());
         if (collection->writeXml(&f, 2, searchPath)) {
             //qDebug() << "Successfully saved file: " << d->userActionsFile;
         }
     } else {
         QTextStream out(&f);
         QString xml =
             "<!-- "
             "\n"
             "Collection name attribute represents the name of the menu, e.g., to use menu \"File\" use \"file\" or \"Help\" use \"help\". You can add new menus."
             "\n\n\n"
             "If you type a relative script file beware that this script is located in $XDG_DATA_HOME/applicationname/"
             "\n\n"
             "The following example adds an action with the text \"Export...\" into the \"File\" menu"
             "\n\n"
             "<KrossScripting>"
             "\n"
             "<collection name=\"file\" text=\"File\" comment=\"File menu\">"
             "\n"
             "<script name=\"export\" text=\"Export...\" comment=\"Export content\" file=\"export.py\" />"
             "\n"
             "</collection>"
             "\n"
             "</KrossScripting>"
             "\n"
             "-->";
 
         out << xml;
     }
     f.close();
 }
 
 void ScriptingPlugin::slotEditScriptActions()
 {
     if (!QFile::exists(d->userActionsFile)) {
         QString dir = QFileInfo(d->userActionsFile).absolutePath();
         QDir().mkpath(dir);
 
         save();
     }
 
     //TODO very funny! this should use ui/view.h instead --Nick
     KRun::runUrl(QUrl::fromLocalFile(d->userActionsFile), QString("text/plain"), nullptr, false);
 }
 
 void ScriptingPlugin::slotResetScriptActions()
 {
     QFile::remove(d->userActionsFile);
 }
 
 #include "moc_scriptingplugin.cpp"