Sometimes we have to clone ourselves 5 or 6 times to manage to do everything. It’s a kind of magic we rarely succeed, but sometimes we do 🙂
Between Akademy and bugfixes for the SC 4.5 release, I managed to get some work done on the Plasma Mobile front, and a quick video of it can be seen there:
Now there is a new kind of activity for managing widgets there, a new addition to the Desktop (that you normally use on normal computers) and the newspaper (designed for netbooks and big tablets)
This one, that is called mobile desktop, is explicitly tought for very small screens (in phisical size, pixel resolution has nothing to do with size!). It’s based on a big flicking scroll widget, just as the newspaper, because the main method of interaction if a touchscreen, but shows only 2 widgets per screen, (at their minimal size to still make sense)
If you scroll everything around no interaction with the widgets will happen, but if you tap one, it will get maximized, getting a size big enough to be really interacted.
The behaviour of the shell changed a bit as well, since it was quite difficult to hit empty areas to make the whole thing flip, now dragging the panel of the activities, pulls the whole screen, making everything rotate in a 3d way (it has also considerably been optimized for speed)
In the video you can also see the progress of the mobile status indicator summer of code, by Yuen.
I’ll give a talk at Akademy together with Alessandro Diaferia, so the topc can be easily guessable 🙂
We’ll talk about the adaption of Plasma to completely different use cases to its usual dress, that is to be the main user interface of a desktop system.
In particular i’ll talk more about the Netbook Shell and Alessandro will talk about the media center project.
I’ll leave Alessandro going in more details on the mediacenter, I’ll try instead to answer to some question, some generic, about porting plasma on different devices some specific to the Netbook use case:
Why netbooks need something different?
Why KDE SC is a good platform on non desktop devices?
What Plasma has to offer there?
What has to offer to users?
What about toys for developers?
What are the components of the Netbook shell and why they are designed the way they are?
It will be on Saturday 3 July, 17:45, at the mobile track, stay tuned 😀
Sometimes when times are ready some ideas really want to come up and be used
Without calling the examples in the history of science, that is quite a bit exagerated here, in the recent history of computing, at all levels from low level stuff to the UI.
this happened over and over again, because of advancement in hardware that makes something possible, because a certain fraework matured enough, because some projects take inspiration from another one, maybe with changes that may improve over the original one or may get it worse (that’s all about the evolution in nature is btw) or some times they just pop out in the same moment even if one doesn’t really know about each others work.
As a result, the evolution follows very similar steps on several quite different platform.
I’ve tought about it quite a lot when i seen this video:
(no, don’t have other formats since that video isn’t mine)
This is a preview video of the user interface intended for the MeeGo distribution to run on tablet devices. The main “primary” UI shows two “pages”, one is a grid of icons with an optional search field that has been seen in several places already, from the very very old mobile devices such as the first Palms to things like The iPhone or the Plasma Netbook Search and Launch interface (where our search functionality is quite more powerful than just searching applications to launch)
The second interesting “page” is a space where is possible to have widgets that connects to webservices, list your media files, PIM data etc.. does this ring a bell?
This is quite similar to the netbook “Newspaper” ui, there is quite different, instead of being two columns that scrolls vertically, it’s one single row that scrolls horizontally, because when you have only touch as input, it’s indeed a way to use it quite more convenient.
Now, what’s interesting, that in prevision of adapting pieces of the netbook ui on devices like tablets, there is an hidden mode in the netbook ui that permits exactly this behaviour. In not suspect times (November 2009) i did shot a screencast that shown also that feature among other things (go to 2:39 to see it):
Yes, it’s quite funny to see this video now, since the project came quite a long way in the meantime and so it works way more smootly, but it shows the idea already basically working.
In KDE SC 4.5 the newspaper ui as well the other components received quite some love, so now the general usage feels much more smooth, even this hidden just-a-little-experimental feature of the newspaper, so for today I’m leaving you with a brand new video of this kind of interface as is in today’s trunk (and SC 4.5) running on the usual low powered VIA tablet:
Probably I should had written this little notice uhm, a quite while :), anyways, it’s quite technical but here there are a little hint on how to make the Netbook shell a garzillion times faster, if you’re hit by an unfortunate series of circumstances that makes it run sloooowly 🙂
Why on some netbooks it runs slow
As shown here, The Plasma Netbook shell can be quite fast on a standard netbook, however many are experiencing it going rather slow. Why?
Qt can use different graphics backends to render the graphics, now on X11 systems the default is the one that is called surprisingly enough, X11, that relies heavily on XLib and XRender. Now, this sounds allgreat, but two things tends to happen.
If the Xrender acceleration of the video drivers is pretty poor, things tend to slow down.
Second, if QPainter hits some code patch that aren’t directly implemented via the X11 graphics system it will have to fall back to another paint system: raster, that is totally software based, so pixmap-to-image conversion (and memory copy) is involved (and is necessary, to not actually lose features depending on what graphics system you’re on), and things slow down.
Now, with Intel drivers things seem to not go soo well, especially for items clipping: that’s unfortunately what’s used more heavily in Plasma Netbook 🙂 the newspaper and the search and launch result works as follows: a smaller QGraphicsWidget contains a bigger one, that contains the actual contents that could be the plasmoids of the newspaper for instance. the outer widget has a particular flag that enables clipping, so what overflows from the parent widget won’t be actually drawn.
with Intel drivers and the X11 graphics system this seems to be pretty fast until the parent widget is of a certain size, then performance degrades significantly pretty quickly.
The actual how to
So the alternative is to use the raster graphicssystem from the start, that is really fast (especially if one think about that is completely software based rendering) there are basically 3 ways to do it:
the application can be invoked with the graphicssystem commanline switch, so:
plasma-netbook -graphicssystem raster
But this has to be done every time, or Qt can be configured at build time to use this as default (some distributions such as Gentoo or MeeGo actually do this) but will have the effect on every Qt application.
So I’ve added a config file option in Plasma Netbook to use it as default even if Qt has X11 as default: with Plasma Netbook not running, edit the file
~/.kde/share/config/plasma-netbookrc (in some distributions could be ~/.kde4 instead)
And add the following line:
GraphicsSystem=raster
That’s it 🙂
Here is a video that compares before and after on the usual EeePC 1005ha, with a bright note: the difference isn’t anymore so noticeable like it was used to some months ago, even tough it’s still makes the difference.
Two reasons: it’s still quite unstable sometimes, overall with X11 Plasma (and other Kde apps as well) seems to (still) be more stable.
But most importat, as said it’s purely software based, so it could be not so gentle on the CPU (so with the battery life). I mean, it’s impressive how much it’s efficient, but will never belike a working gpu based solution. So if you aren’t running on the problem described before, it’s probably better you keep it as is.
So there is hope for the future?
Absolutely! a still experimental new graphics system is in the works, using this time OpenGL. The whole application (any Qt one actually) can be run completely with OpenGl drawing with the -graphicssystem opengl, or just a QGraphicsView can use it (by using a QGLWidget as viewport). That’s exactly what happens if you start Plasma Netbook with
plasma-netbook --opengl
This works in the new born Plasma Mobile too by the way. and is a great hope especially in those two sheels, since GPUs of small devices are designed to be not soo fast, but to be very low power, a bit less than the cpu, actually.
Right now, as in KDE SC 4.5 and Qt 4.6/4.7 is still not for everyday use, is still not so stable and there are some graphical glithces (this actually varies from a graphics driver/video card model like crazy) but what is encouraging is that since this feature was introduced (Qt 4.4) it came a very long way, it’s really sooo better than when it was originally out.
This post is of the boring-with code type, but if you are a distribution packager read till the end, it’s important 🙂
As said by Aaron some days ago, now Plasma can be controlled vith Javascript code.
This is useful for creating the default setup, for quicly controlling the desktop look and feel, to handle updates in the configuration files and even for controlling large deployments.
Setup scripts can also be packaged in the same format as the Javascript based plasmoids, so in the future (probably 4.6 timeframe?) will be possible to distribute and downoad setup for actvities, for instance with get hot new stuff.
Now not only the Plasma Desktop is using it: also the netbook has full scripting support, this will make really easy for distributions to customize the default layout as needed.
It loads 3 packages, one for the Search and launch activity, one for the panel and one for the newspaper. The newspaper is:
var page = new Activity("newspaper")
//not shown by default
page.screen = -1
//properties for the wallpaper
page.wallpaperPlugin = 'image'
page.wallpaperMode = 'SingleImage'
//templateName comes from the desktop file of the package,
//and will be translated
page.name = templateName
page.addWidgetAt("news", 0, 0)
page.addWidgetAt("weather", 1, 0)
page.addWidgetAt("opendesktop", 0, 1)
page.addWidgetAt("knowledgebase", 1, 1)
It adds the default widgets, will be possible to distribute and download different pages. The search and launch instead is the following:
var sal = new Activity("sal")
sal.screen = 0
sal.wallpaperPlugin = 'image'
sal.wallpaperMode = 'SingleImage'
sal.name = templateName
sal.writeConfig("PackageManager", "kpackagekit")
sal.reloadConfig()
The PackageManager bit here is particularly important: a new feature of the Search and Launch activity for 4.5 is a new button in the toolbox, called “Add applications” (complementar to the usual “add widgets”) it will launch the gui for the package manager… now, since it’s highly distribution dependent it will have to be customized. Here uses as default “kpackagekit” this is the name of the desktop file of the application, in OpenSuse that line would become for instance sal.writeConfig(“PackageManager”, “package-manager”) and so on
It’s a small little bit, but it’s an important piece to give it a more integrated and easy experience.
This entry will show off a new cute thing, while also being a pretty shameless call for help 🙂
Last couple of days i was playing with the MeeGo sdk, it’s still a very young system but is really interesting (probably also exactly -because- it’s so young)
After installing the meego atom image on a netbook (by basically copying everything by hand, don’t think there is already an automated installation procedure yet?) and after updating all the packages I noticed at the current stage there indeed -is- a working X11 on it, so the subsequent step was quite obvious of course 🙂
The setup of the main SDK on the development machine as described on their wiki is really straightforward, so having a complete chrooted build environment is a matter of a moment.
Then i started to build a trunk version of KDE… almost all packages -required- for a build are already available (and recent enough 🙂 in the standard MeeGo repository, so I did a pretty basic build (with optional stuff kept to the minimum, will be important to decide carefully what would or would not be included in a build for that, since is targeting mostly low power mobile devices)
The result can be seen in this video (of course with Plasma Netbook shell, since we are on a particular environment like that)
As a side note on this video, is also show some new features of the Plasma Netbook shell in the upcoming KDE SC 4.5, but this is another story 🙂 (will do screencasts on those shortly)
It can be seen that the boot is really really fast, and the performance is quite good too. It is significantly faster than on an older X11 on the same machine, however there are still some graphics glitches (not present on OpenSuse on the same machine) But I’m confident all of this will be gone on a new release of video drivers/X11/Qt (we have been here some times already after all :))
So, moral of the story, this shows KDE libraries and apps can be build really quickly there, they can work really well and that is the platform where some of our new projects can really shine, like the Netbook, the Mobile and the Mediacenter shells. Now think about for instance remote widgets between a mediacenter and a phone, or a phone and a netbook, just to name some of our technologies that would really come to full potential when having them on different devices
So, if you know how to do -good quality- packages, (that honestly, is really -not- my expertise :)), maybe already involved in the MeeGo packaging effort, some help will be really really appreciated, it would be really cool to set up a repository that people can use to quickly install a whole KDE stack on a (at the moment still text mode only) MeeGo install
In in an old screencast for Plasma Mobile, you seen a demonstration of an on-screen keyboard, it was a working proof of concept, but the interactin was still a bit wonky…
I love when those things happen: The autor of that plasmoid, Bjorn Ruberg (hats off) seen it and wanted to do something about… the result is a completely reworked widget, (that will be shipped with SC 4.5) now it’s faster, it has a way smaller memory footprint and more important is way more accurate now. typing on it has became quite fast.
In this little video it’s shown the keyboard widget working in an external little app that takes over a part of the screen (designed for small mobile devices) on the small Jax10 and on a larger old via-based tablet.
This micro screenshot has two new little features that will come for KDE SC 4.5:
KWin team worked hard to write a new cool effect: blur under transparent windows: the plasma theme will notice and use more transparent windows if that effect is enabled
Monochromatic icons support for systemtray icons that use the new shiny protocol (dependent from the Plasma theme)
I’ve been mainly working on polishing the systemtray and the Netbbok stuff lately. Among the other things a massive rework of the Search and launch nterface, but sadly it’s one of those architectural things that opposed to an huge change in the code there is barely anything to see visually 🙂 well, actually there is a new animation effect that i will maybe screencast later, but changes are mainly under the hood.
But this doesn’t mean i did neglet our new born baby: Plasma Mobile
It also had some not easy to see under the hood change, but this made possible to implement what it was just a gray background stub in the last screencast.
As we seen, we have a main view, with the “activities” (there will be useful widgets here like fast updates on social network services, presence on im network, summaries on new messages such as mails and sms and things like that)
Clicking anywhere not occupied by a widget makes the entire screen flip, showing launchers for all installed applications, categorized by the main activities. At the moment what’s it’s showing are results of KRunner queries.
In this video you can see how the thing is already basically working, both the effects, (quite fast already even if there is still a big optimization work to do) and the functionality of the widgets as well of the main launcher
Today, as Aaron and Frederik said, we just launched a really cool thing: periodically updated images of a reference distribution for KDE Plasma Netbook. It’s done with the openSUSE build service and is based on opensuse; however it’s quite customized with our artwork and settings, so the general feeling of the distribution is exactly what the name suggests: a reference.
It is (or, will be since we’re at very early stages of development) how we envision a complete system that boots straight into the Plasma netbook shell, and to be also a way to quickly test the really really bleeding edge development version without messing up your own system 😉
It is also very easy to customize the build on the openSUSE build service to make your own branch, so remixes and sperimentations of new ideas is really welcome 🙂
Here you can find the usb stick image, and here some useful documentation on Techbase.
