ScripterNG

This article is part of the Scripts series.

ScripterNG is a new plugin to provide scripting facilities in Python and Javascript (actually Ecmascript via QtScript). The plugin is still in development and was based on the myplugin example code which is also documented in the Plugin-Howto.

Quickstart

• get Scribus from svn trunk (the Qt4 port is needed)
• get latest snapshot from http://henning.cco-ev.de/scribus/scripterng.tgz
• extract the files into the plugin directory (scribus/plugins/scripterng)
• add ADD_SUBDIRECTORY(scripterng) in scribus/plugins/CMakeLists.txt
• (perhaps disable scriptplugin for testing)
• install python-dev, python-qt4-dev, perhaps sip-dev if you haven't already
• run cmake, make, make install
• go to scribus/plugins/scripterng/scribuspyqt
• run cmake, make and copy *.py and *.so to INSTALLPREFIX/lib/scribus/plugins/scripterng (sorry this is a bug)
• start scribus
• create/open document
• menu Extras -> ScripterNG
• test and see messages on console
• send patches - thanks :)
• retry, fix thinks I forgot to mention here..

Development

About the files

• cmake/modules/*
  • Some extra macros from PyKDE to find SIP and PyQt.
  • They are used in scribuspyqt/. There seems to exist some conflicts with other existing macros.
  • So I had to compile scribuspyqt alone
  • I am not sure if they work well on Windows.
• pythonize.{cpp,h}
  • This is a nice small interface to use Python in C++
• scripterng.{cpp,h}
  • hooks into Extras menu
  • low level plugin stuff (like in myplugin)
• scripterngimpl.{cpp,h}
  • parent is QApplication::instance()
  • sets objectName to ScripterNG (only named objects are exposed)
  • loads Python and runs scripterng.py on startup
  • implements example function: aboutScripterNG()
  • object is magically available as Application.ScripterNG
• scribuspyqt/scribuspyqt.{cpp,h}
  • compiles to libscribuspyqt.so
  • provides additional code to wrap without sip
  • invokeMethod using variants (to call unwrapped objects)
• scribuspyqt/scribuspyqt.sip
  • sip interface to make invokeMethod available to Python
  • creates python module _scribuspyqt.sip
  • links against libscribuspyqt.so
• scribuspyqt/scribuspyqt.py
  • import this module instead of _scribuspyqt directly
  • PyQtObject can be used to wrap any QObject
    • slots can be called like methods
    • full property support
• scribuspyqt/scripterng.py
  • called at startup from plugin
  • looks for application instance and makes it available
  • will be used to hook into Scribus with PyQt, to provide menus to load scripts etc
• scribuspyqt/pyqtscript.py
  • prove of concept: activates QtScript from Python
  • no speed loss
  • mix Python and QtScript
• scribuspyqt/compat.py
  • start of a compatibility layer
  • provides same api as the "old" scripter

Making functions available to ScripterNG

Here is an example:

class CoreModule : QObject {
   CoreModule();
   public slots:
      void quit(bool ask_save);
      int answer();
}
CoreModule::CoreModule() : QObject(
          QApplication::instance()->findChild("ScripterNG")) {
  setObjectName("Core");
}
void CoreModule::quit(bool ask_save) {
  if (ask_save() && confirm() .. ) {
     qDebug("Bye");
     QApplication::instance()->quit();
  }
}
int CoreModule::answer() {
  return 42;
}
CoreModule *m_core = new CoreModule();

Now you can do

>> print Application.Core.answer()
42
>> Application.Core.quit(true)
Bye

API brainstorming

Petr wrote: I'd like to have some logical "object-related" structure for it. Something like e.g.:

 scribus.Document().pages[0].items[0].text()

Henning: I had similar thoughts. Instead of methods we can use the properties in Python directly:

scribus.CurrentDocument.Pages[0].Items[0].Text

This will call the get- and set-methods automatically.

Perhaps we should design an API which is similar to the API used in KOffice:

• KWord
• KSpread
• Krita
• SuperKaramba
• Kopete

See also the wiki page on public C++ API

Comparison with Kross

• ScripterNG and Kross both use the introspection features of Qt. The script language would not see any difference between called by ScripterNG or Kross. So if we start writing the C++ API now. We could switch to Kross later and could still use this API.
  • true, but it may start to get difficult if the C++ API earns additional code to work around e.g. reference-counting probs (not that they are needed, depends on how the backends is done). Re basic types / QVariant-handling, I strongly suggest to write unittests for this! Specialy it's needed to don't only test basic types like double, int and QString but also extended types like QRect and QPoint since they are handled different internaly by Qt4. I also would recommed to rethink if there is a way to use such a C++ API also for dbus. This is not much work taken into account that QDBusAbstractAdaptor's are QObject's too, but would allow to also support the same rich interface via dbus but may need additional work re reference-counting aka handling object lifetime the right(TM) way :) [sebsauer]
    • Actually I trust PyQt doing the reference counting for me. The scribuspyqt is only a very thin layer on top of it. Nevertheless some tests look useful and I will write a few. [Henning]
• Kross btw is great but it currently still depends on kdelibs. ScripterNG is available now. Of course it isn't that mature but it depends on mature technologies (PyQt, sip, pythonize).
  • re kdelibs-dependency; in kdelibs/kross/core open the files interpreter.cpp+manager.cpp and s/klibloader/qlibrary and in action.cpp kmimetype is used to fetch the icons for python+ruby+etc (so, could be easy made optional). Everything else is Qt4 only + all existing bindings (ruby, python, kjs+kjsembed, java and falcon) are Qt4 only already since quit some time. Unfortunately we lost the timeframe to get anything into kdelibs or even out of it for 4.0. While 4.1 may provide the next possibility to do so, it may also an idea to copy some of the code atm within kdelibs/kross/core to the backends themself and remove that way any remaining link-dependency to kdelibs/kross/core. This can be probably done any time depending on the freez-state of kdebindings. [sebsauer]
• One main difference is that ScripterNG tries to do most stuff in Python. So it can be more flexible and development should be faster. Any sensible speed loss by this approach is not expected.
• Kross also only has support for KJSEmbed (part of kdelibs) and not for QtScript (see http://akademy.kde.org/conference/slides/kjsembed-and-qtscript.pdf).
  • this is void (aka pre Qt4.2 knowledge) since QtScript-support is already done, but both ways; Kross can be used in QtScript and QtScript in Kross. No way to get this in now since kdelibs is under hard freez. But if you are interested, I could provide a patch-set from my local repo :) [sebsauer]
• there is a more important issue yet; I still wait for my WindowsXp-license to arrive and as long as that didn't happened I can't say for sure that the backends do work out-of-box on Windows(C) right now even if they should. Anyway, let's hope those bureaucratic within my university (who I'll earn my license from) may passed soon. [sebsauer]
• there are also quit some advantages yet. To name the probably most interesting one is the possibility that we are able to connect the "C++ API modules" on the fly. As example see here the sample how SuperKaramba accesses KSpread through Kross. On the other hand, I didn't test this with Qt-only apps yet and would assume that there are probably some problems related to missing instances of KComponent's that arn't easy to sort out :-( Another advantage is to share code. So, there is no need for additional packaging for the python/ruby/whatever-dependency + all scripting-backends are optional only anyways what is imho important for those distributors that deliver small solutions like embedded or mobile stuff. Same goes here for the PyQt+sip dependency. Kross does allow full access to them but does not depend on them, they are optional too and a script is able to check that at runtime + fallback to e.g. tkinter if it likes. [sebsauer]

• To make this clear: I really like Kross and I am happy that KDE now contains such a great technology. The only reason I started this plugin was that I wanted to learn something about sip and more about C++. And I could not wait until someone ports Kross to a Scribus plugin. For me this task looked too big. But Kross convinced me that using the Qt object system is the way to go instead of writing bindings for everything. The scribuspyqt-part of the plugin could be an interim solution which could later be replaced by Kross. In scripterngimpl.cpp only a few lines have to be changed.

[Henning]