Development/Tutorials/Kross/Introduction: Difference between revisions

    From KDE TechBase
    (Add KDE_EXPORT)
    (properly highlight the python snippets using <code>; simplify a list; link to the {{qt}} classes)
    Line 41: Line 41:


    Each interpreter plugin needs to implement two abstract classes;
    Each interpreter plugin needs to implement two abstract classes;
    <ul>
    * The [http://websvn.kde.org/trunk/KDE/kdelibs/kross/core/interpreter.h?view=markup Kross::Interpreter] class is a singleton controlled by the    [http://websvn.kde.org/trunk/KDE/kdelibs/kross/core/manager.h?view=markup Kross::Manager] and could be used to setup the interpreter or do other things to share functionality between instances of the Script class.
      <li>The [http://websvn.kde.org/trunk/KDE/kdelibs/kross/core/interpreter.h?view=markup Kross::Interpreter] class is a singleton controlled by the    [http://websvn.kde.org/trunk/KDE/kdelibs/kross/core/manager.h?view=markup Kross::Manager] and could be used to setup the interpreter or do other things to share functionality between instances of the Script class.</li>
    * The [http://websvn.kde.org/trunk/KDE/kdelibs/kross/core/script.h?view=markup Kross::Script] class handles exactly one script instance. An application is able to deal with multiple scripts at the same time where each of them has it's own instance of the Kross::Script class controlled by an instance of the more abstract [http://websvn.kde.org/trunk/KDE/kdelibs/kross/core/action.h?view=markup Kross::Action] class.
      <li>The [http://websvn.kde.org/trunk/KDE/kdelibs/kross/core/script.h?view=markup Kross::Script] class handles exactly one script instance. An application is able to deal with multiple scripts at the same time where each of them has it's own instance of the Kross::Script class controlled by an instance of the more abstract [http://websvn.kde.org/trunk/KDE/kdelibs/kross/core/action.h?view=markup Kross::Action] class.</li>
    </ul>


    ===Python===
    ===Python===
    Line 112: Line 110:
    Modules are plugins loaded on demand at runtime to provide additional functionality. They only provide a factory to create and return a QObject instance that is then exposed to the scripting backend.
    Modules are plugins loaded on demand at runtime to provide additional functionality. They only provide a factory to create and return a QObject instance that is then exposed to the scripting backend.


    Since Qt's introspection functionality is used, we are able to throw in just QObject's and have them act as classes/objects within a scripting backend. Slots are membermethods while properties and enumerations are membervariables. If your application also likes to offer [http://hal.freedesktop.org/wiki/Software/dbus D-Bus] support it may be an idea to reuse the [http://doc.trolltech.com/4.2/qdbusabstractadaptor.html QDBusAbstractAdaptor] implementations your application has also for scripting, like for example [[Development/Tutorials/KSpread_Scripting|KSpread]] did.
    Since Qt's introspection functionality is used, we are able to throw in just {{qt|QObject}}'s and have them act as classes/objects within a scripting backend. Slots are membermethods while properties and enumerations are membervariables. If your application also likes to offer [http://hal.freedesktop.org/wiki/Software/dbus D-Bus] support it may be an idea to reuse the {{qt|QDBusAbstractAdaptor}} implementations your application has also for scripting, like for example [[Development/Tutorials/KSpread_Scripting|KSpread]] did.


    Let's take a look at the following code that implements the MyObject class which inherits from QObject;
    Let's take a look at the following code that implements the MyObject class which inherits from QObject;
    <pre>
    <code cppqt>
    class MyObject : public QObject {
    class MyObject : public QObject {
       Q_OBJECT
       Q_OBJECT
    Line 147: Line 145:
       }
       }
    }
    }
    </pre>
    </code>
    At the bottom the krossmodule() function will be called by Kross and returns an instance of MyObject that is then exposed to the scripting backend.
    At the bottom the krossmodule() function will be called by Kross and returns an instance of MyObject that is then exposed to the scripting backend.


    Line 167: Line 165:
    The following Python sample code accesses then the module at runtime and uses the QObject, calls it's slots and properties and connects a signal with a python function (e.g. save as file named "myobjecttest.py" and execute with "kross ./myobjecttest.py");
    The following Python sample code accesses then the module at runtime and uses the QObject, calls it's slots and properties and connects a signal with a python function (e.g. save as file named "myobjecttest.py" and execute with "kross ./myobjecttest.py");


    <pre>
    <code python>
    #!/usr/bin/env kross
    #!/usr/bin/env kross
    import Kross
    import Kross
    Line 178: Line 176:
    obj1.setParent(m)
    obj1.setParent(m)
    print "%s %s" % (obj1.name,obj1.parent().name)
    print "%s %s" % (obj1.name,obj1.parent().name)
    </pre>
    </code>


    ==Manager, GuiClient, Action==
    ==Manager, GuiClient, Action==
    Line 184: Line 182:
    The [http://websvn.kde.org/trunk/KDE/kdelibs/kross/core/manager.h?view=markup Kross::Manager] class is a singleton that provides access to the interpreters, to actions and to the modules. The Kross::Manager is available within scripting code as module named "Kross". Following Python script uses the Kross module to create a new Kross::Action instance, fills it with JavaScript code and executes that JavaScript code.
    The [http://websvn.kde.org/trunk/KDE/kdelibs/kross/core/manager.h?view=markup Kross::Manager] class is a singleton that provides access to the interpreters, to actions and to the modules. The Kross::Manager is available within scripting code as module named "Kross". Following Python script uses the Kross module to create a new Kross::Action instance, fills it with JavaScript code and executes that JavaScript code.


    <pre>
    <code python>
    #!/usr/bin/env kross
    #!/usr/bin/env kross
    import Kross
    import Kross
    Line 191: Line 189:
    a.setCode("println(\"Hello world from Kjs\");")
    a.setCode("println(\"Hello world from Kjs\");")
    a.trigger()
    a.trigger()
    </pre>
    </code>


    The [http://websvn.kde.org/trunk/KDE/kdelibs/kross/core/guiclient.h?view=markup Kross::GuiClient] class implements KXMLGUIClient to provide GUI functionality, handling of XML configuration files on a more abstract level and offers some predefined actions that could be optionally used in your application.
    The [http://websvn.kde.org/trunk/KDE/kdelibs/kross/core/guiclient.h?view=markup Kross::GuiClient] class implements KXMLGUIClient to provide GUI functionality, handling of XML configuration files on a more abstract level and offers some predefined actions that could be optionally used in your application.
    Line 197: Line 195:
    The [http://websvn.kde.org/trunk/KDE/kdelibs/kross/core/action.h?view=markup Kross::Action] class offers an abstract container to deal with scripts like a single standalone scriptfile. Each action holds a reference to the by the matching [http://websvn.kde.org/trunk/KDE/kdelibs/kross/core/interpreter.h?view=markup Kross::Interpreter] instance created by [http://websvn.kde.org/trunk/KDE/kdelibs/kross/core/script.h?view=markup Kross::Script] instance. Following Python script accesses the Kross module and the self variable which is our Kross::Action instance that provides the context for the running Python script.
    The [http://websvn.kde.org/trunk/KDE/kdelibs/kross/core/action.h?view=markup Kross::Action] class offers an abstract container to deal with scripts like a single standalone scriptfile. Each action holds a reference to the by the matching [http://websvn.kde.org/trunk/KDE/kdelibs/kross/core/interpreter.h?view=markup Kross::Interpreter] instance created by [http://websvn.kde.org/trunk/KDE/kdelibs/kross/core/script.h?view=markup Kross::Script] instance. Following Python script accesses the Kross module and the self variable which is our Kross::Action instance that provides the context for the running Python script.


    <pre>
    <code python>
    #!/usr/bin/env kross
    #!/usr/bin/env kross
    import Kross
    import Kross
    Line 209: Line 207:
    print "description=%s" % self.description()
    print "description=%s" % self.description()
    print "code=%s" % self.code()
    print "code=%s" % self.code()
    </pre>
    </code>


    ==D-Bus and Kross==
    ==D-Bus and Kross==
    Line 215: Line 213:
    With the [http://doc.trolltech.com/4.2/qtdbus.html QtDBus module] Qt provides a library that a Qt/KDE application is able to use to make Inter-Process Communication using the [http://dbus.freedesktop.org D-BUS protocol].
    With the [http://doc.trolltech.com/4.2/qtdbus.html QtDBus module] Qt provides a library that a Qt/KDE application is able to use to make Inter-Process Communication using the [http://dbus.freedesktop.org D-BUS protocol].


    The QtDBus module uses the Qt Signals and Slots mechanism. Applications that like to provide parts of there functionality to the D-Bus world are able to do so by implementing classes that inherit from the [http://doc.trolltech.com/4.2/qdbusabstractadaptor.html QDBusAbstractAdaptor] class.
    The QtDBus module uses the Qt Signals and Slots mechanism. Applications that like to provide parts of there functionality to the D-Bus world are able to do so by implementing classes that inherit from the {{qt|QDBusAbstractAdaptor}} class.


    Kross is able to reuse such by an application provided bindings. So, once your application supports D-Bus, Kross is able to reuse those already existing code and offers transparent access to the scripting-backends to them. How does this differ from e.g. the python-dbus package? Well, first method-calls don't go through the dbus-socket and then it's not dbus-related at all except, that we are able to reuse what your application offers anyway: a clean interface to the outside world. But that's not all, we are not limited to what's possible with D-Bus. We are also able to exchange instance-pointers to QObject or QWidget instances.
    Kross is able to reuse such by an application provided bindings. So, once your application supports D-Bus, Kross is able to reuse those already existing code and offers transparent access to the scripting-backends to them. How does this differ from e.g. the python-dbus package? Well, first method-calls don't go through the dbus-socket and then it's not dbus-related at all except, that we are able to reuse what your application offers anyway: a clean interface to the outside world. But that's not all, we are not limited to what's possible with D-Bus. We are also able to exchange instance-pointers to QObject or QWidget instances.


    For an example you may like to take a look at how it was done in the KSpread [http://websvn.kde.org/trunk/koffice/kspread/plugins/scripting/ScriptingModule.cpp?view=markup ScriptingModule] class.
    For an example you may like to take a look at how it was done in the KSpread [http://websvn.kde.org/trunk/koffice/kspread/plugins/scripting/ScriptingModule.cpp?view=markup ScriptingModule] class.

    Revision as of 11:04, 28 May 2007

    Introduction

    The Kross scripting framework provides full Python, Ruby and KDE JavaScript scripting support. The goal was to limit the work needed on applications to have them fully scriptable and to provide a modular way to transparently integrate additional interpreters and in that way extend your application with a new scripting-backend without any new line of code and even without any recompile. To achieve this internally Qt's introspection-functionality like signals, slots, properties, enums, QVariant, QObject, QMetaObject, QMetaType, etc. are used to deal with functionality at runtime.

    What Kross is

    Kross is a modular scripting framework that provides a complete framework to embed scripting interpreters like Python, Ruby and JavaScript transparently into native applications to bridge the static and dynamic worlds together.

    Scripting interpreters are plugins that are loaded dynamicly on demand at runtime by the Kross framework. The application that uses Kross to provide scripting functionality to the user does not need to know anything about the interpreter itself or any other backend-details. All the application needs to know is, that there exists scripting code that should be executed. Kross will then take care of it.

    What Kross is not

    Kross does not implement an own scripting language rather then providing access to already existing solutions. Kross does not implement a complete Toolkit-binding rather providing access to already existing solutions like PyQt/PyKDE or TkInter for Python or Korundum/QtRuby for Ruby. Kross does not auto-generate code, it is not needed to maintain any configurationfiles and Kross does not come with yet another own bindings-API. All it does is to connect things transparently together and to offer optional access to already existing technologies.

    Reuse and choice are the goals

    There exist a wide range of solutions to deal with scripting. Languages like Python did enjoyed years of evolution, a large community around them with 3rd-party modules for nearly everything exist. Same goes for a bunch of other languages where sometimes a specialy functionality is only available for some of them and where each language comes with it's own way of doing things. Each user has an own preference for what scripting language he likes to use and maybe even already collected skills in some specific areas.

    Rather then limiting us and our users to only one specific language with it's own way of doing things, Kross does offer a flexible way to be optional able to support all of them without additional code and maintaining work at the application level. To allow the user to choose what he likes and knows most does limit the entry-barrier to get his things done and even to be able to contribute own solutions significantly.

    Supported interpreters

    As of today Python, Ruby and JavaScript are supported. While all of them are passing the unittests, current state is, that Python is the most complete one followed by Ruby which is near the same state and finally JavaScript which needs some more tweaks to be as rock-stable as the other both implementations.

    Support for Java is on progress in playground/bindings/krossjava.

    For sure any interpreter-plugin you may like to implement is very welcome. At the end the open source world is about choices :)

    Advantage of Kross over other solutions

    • Scripting interpreter independend. Kross does not implement an interpreter by it's own rather then providing access to already existing solutions. You don't have to decide for your user what scripting language he should use, let him decide and keep him happy and productive that way!
    • Real embedding. Rather then communicating with scripting backends e.g. over stdin/stdout or D-Bus Kross does come with plugins that really embed the interpreters and deal with them on the native C/C++ code level to gain optimal performance and flexibility.
    • Kross is damn fast. Kross had a bit of luck to be adopted by Krita so early since one of the top-priorities Krita had on a scripting backend was performance. During the years we got it managed to increase the speed to a level where it's hard to see a difference to native in C/C++ written code.
    • Kross was designed from the beginning with platform-independency in mind. This is the result of the origin of Kross which started initial as Kexi plugin and Kexi itself runs at least on Linux, Windows and Mac since it's early days.
    • Kross is stable and well proven cause before it finally landed in kdelibs it was in use in KOffice for 3 major releases and was that way "tested" by a wide range of users worldwide.
    • There exists a bunch of documentations, scripts and applications that are using Kross already today. The later one guaranteed that Kross offers the solution for a wide range of use-case scenarios.
    • Kross could be easily extended with a new scripting interpreter. There are no changes needed at the applications. So, whatever hype we are able to see next few years, we are ready to fullfit the possible user-requests for them without much pain.
    • The synergy-effect if multiple applications are sharing the same interpreter plugin implementations ensures that bugs are discovered and fixed as soon as possible. Also each app is able to profit if someone writes for example a plugin for the LUA-interpreter each app is able to use the new backend without any recompile.
    • Kross does reuse existing technologies as much as possible. There is no code-generation at compiletime needed and no own "bindings API" is introduced since we are reusing the Qt Meta-Object System. You are able to throw in a QObject and a script is able to connect with the signals, call slots as there are functions, access enumerations, get/set properties or pass QObject/QWidget instances around as there are classes.
    • Unlimit flexibility of the interpreter backend since each interpreter-plugin is able to decide by it's own how to implement the bridging functionality. If you like for example to have it more pythonic by using the with Python 2.4 introduced Decorators, you are free to implement it and each app that uses Kross will profit by beeing able to use decorators from now on.
    • Kross will stay backward-compatible cause as part of kdelibs it needs to follow strict policies and needs to provide backward-compatibility at least during the lifetime of KDE4.

    The Interpreter plugins

    Kross offers a plugin-interface to integrate interpreter backends like Python, Ruby and KDE-Javascript. They are loaded on demand at runtime. Neither the application nor Kross needs to know any details about the backends. This clear separation between the application and scripting details enables at the one hand, to deal with scripting at an abstract level without being bound to only one backend, and at the other hand makes it easy to integrate scripting into an already existing application.

    Each interpreter plugin needs to implement two abstract classes;

    • The Kross::Interpreter class is a singleton controlled by the Kross::Manager and could be used to setup the interpreter or do other things to share functionality between instances of the Script class.
    • The Kross::Script class handles exactly one script instance. An application is able to deal with multiple scripts at the same time where each of them has it's own instance of the Kross::Script class controlled by an instance of the more abstract Kross::Action class.

    Python

    The Python plugin implements access to the Python scripting language.

    The unittest.py Python script file implements unittests for common functionality. For the unittests kross does use a special test-application that got compiled if cmake -DKDE4_BUILD_TESTS=1 was used for kdelibs. You are able to run the unittest with

    cd kdelibs/kross/test
    ./krosstest unittest.py
    

    Other scripts are...

    • The testkross.py Python script file demonstrates how to use Kross to execute some JavaScript code within a python script.
    • The testguitk.py Python script file that creates and displays a modal dialog using the TkInter GUI-toolkit.
    • The testguiqt.py Python script file shows how to use PyQt while the testguiform.py uses the Kross Form module.

    The krosspython plugin consists of...

    • The Kross::PythonInterpreter class implements Kross::Interpreter for the Python interpreter backend and implements the createScript factory method to create Kross::PythonScript instances.
    • The Kross::PythonScript class implements Kross::Script for the Python backend to provide the functionality to execute Python code within a script-container.
    • The Kross::PythonModule class is the __main__ Python environment used as global object namespace. This module is shared between the different Kross::PythonScript instances which run in there own module namespace. The Kross::PythonModule also spends access to the the whole Kross functionality and manages all the @a Kross::PythonExtension modules.
    • The Kross::PythonExtension class implements a Py::Object to wrap a QObject instance into the world of Python.
    • Within Kross::PythonVariant the Kross::PythonType helper class is used to cast between QVariant and Py::Object values while the Kross::PythonMetaTypeFactory helper class is used as factory within Kross::PythonExtension to translate an argument into a Kross::MetaType needed for QGenericArgument's data pointer.

    Ruby

    The Ruby plugin implements access to the Ruby scripting language.

    The unittest.rb Ruby script file implements unittests for common functionality. For the unittests kross does use a special test-application that got compiled if cmake -DKDE4_BUILD_TESTS=1 was used for kdelibs. You are able to run the unittest with

    cd kdelibs/kross/test
    ./krosstest unittest.rb
    

    The krossruby plugin consists of...

    • The Kross::RubyInterpreter class implements Kross::Interpreter for the Ruby interpreter backend and provides with the createScript a factory method to create Kross::RubyScript instances.
    • The Kross::RubyScript class implements Kross::Script for the Ruby backend to provide the functionality to execute Ruby code within a script-container.
    • The Kross::RubyModule class is the __main__ Ruby environment used as global object namespace. This module is shared between the different Kross::RubyScript instances which run in there own module namespace. The Kross::RubyModule also spends access to the the whole Kross functionality and manages all the @a Kross::RubyExtension modules.
    • The Kross::RubyExtension class implements a Ruby VALUE object to wrap a QObject instance into the world of Ruby.
    • Within Kross::RubyVariant the Kross::RubyType helper class is used to cast between QVariant and Ruby VALUE values while the Kross::RubyMetaTypeFactory helper class is used as factory within Kross::RubyExtension to translate an argument into a Kross::MetaType needed for QGenericArgument's data pointer.

    JavaScript

    The KDE JavaScript plugin uses the in kdelibs4 included Kjs and KjsEmbed4 frameworks to provide access to the JavaScript language.

    The unittest.js KDE-JavaScript script file implements unittests for common functionality. For the unittests kross does use a special test-application that got compiled if cmake -DKDE4_BUILD_TESTS=1 was used for kdelibs. You are able to run the unittest with

    cd kdelibs/kross/test
    ./krosstest unittest.js
    

    For details about KDE-JavaScript see...

    Java

    Within the Google Summer of Code the krossjava should provide us a backend for Java :-)

    So, this is work in progress.

    The Module plugins

    Modules are plugins loaded on demand at runtime to provide additional functionality. They only provide a factory to create and return a QObject instance that is then exposed to the scripting backend.

    Since Qt's introspection functionality is used, we are able to throw in just QObject's and have them act as classes/objects within a scripting backend. Slots are membermethods while properties and enumerations are membervariables. If your application also likes to offer D-Bus support it may be an idea to reuse the QDBusAbstractAdaptor implementations your application has also for scripting, like for example KSpread did.

    Let's take a look at the following code that implements the MyObject class which inherits from QObject; class MyObject : public QObject {

     Q_OBJECT
     Q_PROPERTY(QString name READ name WRITE setName)
     public:
       MyObject(QObject* parent = 0) : QObject(parent) {}
       virtual ~MyObject() {}
       QString name() const { return objectName(); }
       void setName(const QString& name) {
         return setObjectName(name);
       }
     public slots:
       QObject* create(const QString& name,
                       QObject* parent=0) {
         MyObject* obj = new MyObject(parent);
         obj->setObjectName(name);
         return obj;
       }
       QObject* parent() const { return QObject::parent(); }
       void setParent(QObject* parent) {
         QObject::setParent(parent);
         emit parentChanged(); 
       }
     signals:
       void parentChanged();
    

    };

    extern "C" {

     KDE_EXPORT QObject* krossmodule() {
       return new MyObject();
     }
    

    } At the bottom the krossmodule() function will be called by Kross and returns an instance of MyObject that is then exposed to the scripting backend.

    Then we just need to have our myobject.h and myobject.cpp files, filled with the content above, defined in the CMakeLists.txt file. The library needs to be named "krossmodule..." where the "..." is then the name the module is accessible as. For our example we use "krossmodulemyobjectmod" and therefore we are able to access the module if installed as "myobjectmod". The example does not depend on Kross, so you may like to replace ${KROSS_INCLUDES} with whatever else your module depends on.

    include_directories(${CMAKE_SOURCE_DIR}
      ${KROSS_INCLUDES})
    set(krossmodulemyobjectmod_PART_SRCS
      myobject.cpp)
    kde4_automoc(${krossmodulemyobjectmod_PART_SRCS})
    kde4_add_plugin(krossmodulemyobjectmod
      ${krossmodulemyobjectmod_PART_SRCS})
    target_link_libraries(krossmodulemyobjectmod
      ${KDE4_KDECORE_LIBS} ${KDE4_KROSSCORE_LIBS})
    install(TARGETS krossmodulemyobjectmod
      DESTINATION ${PLUGIN_INSTALL_DIR})
    

    The following Python sample code accesses then the module at runtime and uses the QObject, calls it's slots and properties and connects a signal with a python function (e.g. save as file named "myobjecttest.py" and execute with "kross ./myobjecttest.py");

    1. !/usr/bin/env kross

    import Kross m = Kross.module("myobjectmod") m.name = "MyObjectModuleName" obj1 = m.create("OtherObjectName") def myCallbackFunc(args):

       print "The parent of obj1 changed"
    

    obj1.connect("parentChanged()",myCallbackFunc) obj1.setParent(m) print "%s %s" % (obj1.name,obj1.parent().name)

    Manager, GuiClient, Action

    The Kross::Manager class is a singleton that provides access to the interpreters, to actions and to the modules. The Kross::Manager is available within scripting code as module named "Kross". Following Python script uses the Kross module to create a new Kross::Action instance, fills it with JavaScript code and executes that JavaScript code.

    1. !/usr/bin/env kross

    import Kross a = Kross.action("MyKjsScript") a.setInterpreter("javascript") a.setCode("println(\"Hello world from Kjs\");") a.trigger()

    The Kross::GuiClient class implements KXMLGUIClient to provide GUI functionality, handling of XML configuration files on a more abstract level and offers some predefined actions that could be optionally used in your application.

    The Kross::Action class offers an abstract container to deal with scripts like a single standalone scriptfile. Each action holds a reference to the by the matching Kross::Interpreter instance created by Kross::Script instance. Following Python script accesses the Kross module and the self variable which is our Kross::Action instance that provides the context for the running Python script.

    1. !/usr/bin/env kross

    import Kross print "objectName=%s" % Kross.objectName() print "interpreters=%s" % Kross.interpreters() print "objectName=%s" % self.objectName() print "text=%s" % self.text print "enabled=%s" % self.enabled print "currentPath=%s" % self.currentPath() print "interpreter=%s" % self.interpreter() print "description=%s" % self.description() print "code=%s" % self.code()

    D-Bus and Kross

    With the QtDBus module Qt provides a library that a Qt/KDE application is able to use to make Inter-Process Communication using the D-BUS protocol.

    The QtDBus module uses the Qt Signals and Slots mechanism. Applications that like to provide parts of there functionality to the D-Bus world are able to do so by implementing classes that inherit from the QDBusAbstractAdaptor class.

    Kross is able to reuse such by an application provided bindings. So, once your application supports D-Bus, Kross is able to reuse those already existing code and offers transparent access to the scripting-backends to them. How does this differ from e.g. the python-dbus package? Well, first method-calls don't go through the dbus-socket and then it's not dbus-related at all except, that we are able to reuse what your application offers anyway: a clean interface to the outside world. But that's not all, we are not limited to what's possible with D-Bus. We are also able to exchange instance-pointers to QObject or QWidget instances.

    For an example you may like to take a look at how it was done in the KSpread ScriptingModule class.