ModRana Roadmap
Contents |
Qt GUI
A Qt base is currently the main item on the modRana roadmap, due to multiple reasons:
- it enables modRana to run properly on Harmattan
- it enables the use of kinetic scrolling, smooth animations and generally improves performance
- generally better suitable for touchscreen interfaces with Qt Quick (QML)
- unlike Clutter, that needs OpenGL, QML also supports software rendering
- development experience with Mieru generally shows it's much faster to work with than doing custom UI with Cairo
- removes the dependency on GTK
- it is currently not possible to submit applications with outside dependencies both to the Ovi store and to Apps for MeeGo (AFM seems to be working on dependency support though)
What about the current Cairo + GTK based GUI ?
the new Qt based GUI should be just another alternative together with the GTK one. Also in the process more a clear core-GUI separation should be developed to enable other alternative GUIs (EFL,SDL/PyGame,Clutter/MX,etc.).
Uses for the current GTK GUI
- devices and environment with old versions of Qt
- Neo FreeRunner
- Open Pandora (not sure ?)
- Android chroot (not sure ?)
NOTE: Qt/QML unlike Clutter has a software renderer so OpenGL is not needed to use it. Might be interesting to see the QML vs GTK software rendering performance.
Main drawbacks
- only basic acceleration provided by X
- no 3D acceleration, smooth scrolling, rotation animation acceleration
- as the classic GTK widgets are basically unusable on mobile devices, modRana has to basically build its own GUI toolkit with Cairo
- while flexible, this is very labor intensive
- most of new features and improvements are not blocked by extensive GUI improvements needed to make them usable, the backend work is quite easy in comparison
- examples:
- on-map context menu - needs a new context menu widget
- long list handling with search - kinetic scrolling (is it doable with Cairo) + interactive search box [built in in Qt Components]
- clickable in text links [easy with QML]
- multiline text editing for POI descriptions, etc. [very easy with QML]
What needs to be done to get the Qt GUI in a usable state
Separating the GUI logic to a GUI module
Most of the core GUI logic currently resides in the modRana "kernel" the modrana.py file. This logic needs to be transfered to a separate GUI module tat can be loaded by modRana at startup, either by providing a CLI parameter or automatically (once implemented).
There will be a platform independent API, implemented through and abstract parent class, that enables to interact with the current GUI module in platform independent way (toggle fullscreen, set window size, etc.).
This work will be partially based on Mieru, which already uses the concept of separate GUI modules & has advanced CLI argument support.
What needs to be done ?
- add pluggable GUI module support
- move the current GTK logic to a GTK GUI module
- add proper CLI argument handling
- -d, --device - set device module
- -u, --ui - set which GUI to use
- --lat, --lon, --zoom, --layer - set a given map screen parameters at startup
- --no_gps - don't start GPS on startup
- --no_sound - disable sound on startup
- --options_path - path to an alternate options.bin file (might be useful for debugging)
- something else ?
Writing a Qt GUI module
The Qt GUI module needs to start the interface on startup - create the application window, fullscreen it and start displaying the modRana interface.
What needs to be done ?
- Qt GUI module
- create application window and fullscreen it
- fullscreen toggle
- automatic rotation & rotation lock
- set window title (if applicable)
- shutdown support
Getting data from modules to the Qt GUI
There are various methods for crossing the GML-native code(Python in this case) divide. Data access is available from bot sides - QML can access (specially crafted) Python properties and Python can fetch QML objects by name from the current QDeclarativeView.
Which way is better ? IMHO using Python properties and accessing them from QML code is cleaner and makes the QML/Python divide easily visible, PySide also makes it possible to implement callbacks and value change notifications - Python code can notify QML that value of a property changed so that QML code depending on its value can handle the change.
Directly calling QML objects from Python is on the other hand not visible from the QML code (unless manually documented). For isolated cases that (eq calling the shutdown method of the QML root object) it is IMO OK, overusage might cause the QML code to be too tightly connected with Python making it more suspect to breaking by changes in Python or QML.
Global data provider vs per-module-property
Other GUI modules
There are other graphics toolkits with Python bindings than just Qt and GTK. While not all might be viable for mobile use or even not available on mobile Linux devices, a few can be still considered.
PyGame
The most interesting at the moment is PyGame, which basically provides Python bindings for SDL. I don't have any personal experience with SDL so far but I'd guess it might be a little more lowlevel than GTK or Qt. On the plus side PyGamse is available for WebOS, being the only graphics toolkit with Python bindings on this platform so far. There is also a PyGame port for Android.
EFL
EFL seems to have some Python bindings and looks to be the only non-HTML5 toolkit available on Tizen out of the box (provided that a device running Tizen is ever released). SHR also uses EFL.
Non-GUI work
This section should contain a roadmap for work not directly depending on the GUI.