Tarballs for kdepim-4.4.6 and kdepim-runtime-4.4.6 are now available from a mirror near you.

ftp://ftp.kde.org/pub/kde/stable/kdepim-4.4.6/src

There is no associated kdepim-l10n-4.4.6 tarball since I don't know how to make one -- but there are also no new messages strings so the existing 4.4.5 translations should work.

There is also no ChangeLog since that also is something I'm not sure how to do.

If there are volunteers to make the l10n or Changelog, feel free to contact me about it.

Looks like we'll be creating a kdepim-4.4.6 tarball, with tagging expected this Thursday 9 September.

So PIMsters, get your bug fixes into the 4.4 branch as soon as possible.
No regressions please.
And no new i18n strings either.

Let me know if you need more time and want me to delay the tagging.

This does NOT mean there will be a KDE SC 4.4.6.

The KDE API Reference (api.kde.org) web site is now providing ".qch" files suitable for loading into Nokia's Qt Assistant.

Look for the "[qt]" links.

Currently, auto-regeneration of these files happens on a nightly basis for kdelibs and kdepimlibs trunk, and for kdelibs and kdepimlibs 4.5. More can be added, upon request.

To use load these files into assistant:
* download them to a safe place
* in assistant, [Add] them from the Edit->Preferences->Documentation tab

I'll leave it to the experts to tell us how best to load these files into KDevelop or QtCreator.

Warning: these files are not small.

The above combination was never a painless experience, still at some point in past it seemed to be better to have a NVidia card on Linux then anything else, so I continued to buy them whenever my system was upgraded. Lately although it started to make me rather bad. I have two computers, one that is a 4 core Intel CPU with 8GB of memory, the other is a Core2Duo with 3GB. The latter is a Lenovo laptop. Both have NVidia, nothing high end (Qudaro NVS something and 9300GE, both used with dual monitor setup), but they should be more than enough for desktop usage. Are they?
Well, something goes wrong there. Is that KDE, is that XOrg, is that the driver? I suspect the latter. From time to time (read: often), I ended up with 100% CPU usage for XOrg. Even though I had 3 cores doing nothing the desktop was unusable. Slow scroll, scroll mouse movements, things typed appearing with a delay, things like that. Like I'd have an XT. I tried several driver version, as I didn't always have this issues, but with newer kernel you cannot go back to (too) old drivers. I googled, and found others having similar experience, with no real solution. A suspicion is font rendering for some (non-aliased) fonts, eg. Monospace. Switching fonts sometimes seemed to make a difference, but in the end, the bug returned. Others said GTK apps under Qt cause the problem, and indeed closing Firefox sometimes helped. But it wasn't a solution. Or there was a suggestion to turn the "UseEvents" option on. This really seemed to help, but broke suspend to disk. Turning off the second display and turning on again seemed to help...for a while. Turning off the composite manager did not change the situation.
Finally I tried the latest driver that appeared not so long ago, 256.44. And although the CPU usage of XOrg is still visible, with pikes going up to 20-40%, I gain back the control over the desktop. Am I happy with it? Well, not....
As this was only my desktop computer. I quickly updated the driver on the laptop as well, and went on the road. Just to see 100% CPU usage there. Did all the tricks again, but nothing helped. Until I had the crazy idea to change my widget theme from the default Oxygen to Plastique. And hurray, the problem went away! It is not perfect, with dual monitor enabled sometimes maximizing a konsole window takes seconds, but still in general the desktop is now usable. And of course this should also make me have more uptime on battery.
Do I blame Oxygen? No, not directly. Although might make sense to investigate what causes there the NVidia driver going crazy and report to NVidia.

So in case you have similar problems, try to switch to 256.44 and if it doesn't help chose a different widget style.

Now, don't say me to use nouveau or nv. Nouveau gave me graphic artifacts and it (or KDE?) didn't remember the dual card setup. Nv failed the suspend to disk test with my machine and doesn't provide 3D acceleration needed eg. for Google Earth.

UPDATE: I upgraded my laptop to 4.5.1 (from openSUSE packages).Well, this broke composition completely, I got only black windows. I saw a new driver is available (256.53), let's try it. So far, so good, even with Oxygen. Let's see on the long run how it behaves, I didn't test it in deep.

In my last blog post, I showed how to use a proxy QNetworkAccessManager to restrict network accesses to sites included in a whitelist. One limitation the previous version had is that it stopped the disallowed requests by rewriting the request itself to be to an invalid url. This then caused the default implementation of QNetworkAccessManager to generate an error reply for us. This post will look at how to create a custom reply directly, to allow us to display messages to the user etc. or even provide 'virtual' content.

The approach I've taken is to try to write a reusable utility class for sending basic network replies. I've called the class QCustomNetworkReply since if there's a reasonable level of support then I'll try to work it up into a merge request for Qt. To begin with, lets see how the whitelisting proxy looks now that it uses the new class:

QNetworkReply *WhiteListNetworkAccessManager::createRequest( Operation op, const QNetworkRequest &req, QIODevice *outgoingData ) { // If host is not whitelisted then kill it if ( !isAllowed( req.url().host() ) ) { QCustomNetworkReply *reply = new QCustomNetworkReply(); reply->setHttpStatusCode( 403, "Forbidden" ); reply->setContentType("text/html"); reply->setContent( QString("<html><body><h1>That url is not in the whitelist</h1></body></html>") ); return reply; } QNetworkReply *reply = QNetworkAccessManager::createRequest( op, myReq, outgoingData ); return reply; }

The new code operates if the request is to be disallowed. First it creates our custom reply, it then specifies the HTTP response code to send. Finally it sets up the content type and the content itself. Finally, we return our custom reply. As you can see, the API of the QCustomNetworkReply class is fairly simple to use (in fact the only required part is setting the content).

Now we've seen how it's used, lets take a look at how the custom network reply works. The class declaration is fairly simple:

class QCustomNetworkReply : public QNetworkReply { Q_OBJECT public: QCustomNetworkReply( QObject *parent=0 ); ~QCustomNetworkReply(); void setHttpStatusCode( int code, const QByteArray &statusText = QByteArray() ); void setHeader( QNetworkRequest::KnownHeaders header, const QVariant &value ); void setContentType( const QByteArray &contentType ); void setContent( const QString &content ); void setContent( const QByteArray &content ); void abort(); qint64 bytesAvailable() const; bool isSequential() const; protected: qint64 readData(char *data, qint64 maxSize); private: struct QCustomNetworkReplyPrivate *d; };

The first group of methods are those for setting the various headers on our response. They are really just convenience wrappers around existing methods (for example making some protected functionality public). I won't go into any more detail about them since the implementations are obvious looking at the source. The two setContent methods are where things start to get interesting:

void QCustomNetworkReply::setContent( const QString &content ) { setContent(content.toUtf8()); } void QCustomNetworkReply::setContent( const QByteArray &content ) { d->content = content; d->offset = 0; open(ReadOnly | Unbuffered); setHeader(QNetworkRequest::ContentLengthHeader, QVariant(content.size())); QTimer::singleShot( 0, this, SIGNAL(readyRead()) ); QTimer::singleShot( 0, this, SIGNAL(finished()) ); }

The first method is simple a convenience and allows us to use a QString rather than a bytearray for the content, yhe second is where the real action is. First, we store the content. Next, we zero the offet that stores how much data has been read from our reply (remember a QNetworkReply is a QIODevice) and open our io device. Now that we have the content, we also set the response header that specifies the amount of data we have. Finally, we use two single shot timers to cause the readyRead() and finished() signal to be emitted when the event loop is reentered. We can't simply emit these signals immediately since the reply has not yet been returned by our QNetworkAccessManager, so nothing is listening for them.

The final part of the code is to provide a basic implementation of a QIODevice to allow the stored content to be read back out:

void QCustomNetworkReply::abort() { // NOOP } qint64 QCustomNetworkReply::bytesAvailable() const { return d->content.size() - d->offset; } bool QCustomNetworkReply::isSequential() const { return true; } qint64 QCustomNetworkReply::readData(char *data, qint64 maxSize) { if (d->offset >= d->content.size()) return -1; qint64 number = qMin(maxSize, d->content.size() - d->offset); memcpy(data, d->content.constData() + d->offset, number); d->offset += number; return number; }

That's all there is to it - see all fairly straight forward. The nice part is that now we have the QCustomNetworkReply, we don't need to do any of that work again and can simply reuse this class whenever we want to send data directly to clients of QNetworkAccessManager. As usual, the code is available from my qt-examples git repository at http://gitorious.org/qt-examples/.

A friendly note that KDE SC 4.5.1 will be tagged on 26 August.

So keep those bug fixes coming.

GSoC 2010 is finished. I would like to share my opinions with you.

It was great summer. I want to thank you all, especially Anne Marie Mahfouf, for trusting me I am good candidate. I learned a lot. Working with kdelibs and qt was an exciting experience to me. Trust me, I learned a lot. I believe that my little contribution will improve the quality of KHangMan. Hope so

Thank you annma, dfaure, djustice, hubnerd, Nightrose, pinotree, reavertm, SadEagle, sandsmark, sreich, thiago and others not mentioned for you help, support and answering to my questions. Anne Marie, you were very, very good mentor

Meanwhile I had HDD failure with complete data lost, so I had delay. However, I want to stay with KHangMan after GSoC, so this delay doesn't seem to be important. Below is the summary of successes and new TODOs.

Successess

1. Recent files support
2. XML-based KHangMan themes. Now artists can easly create new themes and add them to application without code modification. Anne Marie wrote a document about creating 'new' themes.
3. Spiral mode - order of words to be guessed depends on user's individual results. Words hardest to user are displayed much often, than easier. Each user has his own list of words hardness. Spiral mode stores info in XML file. The files below show the way of activating Spiral mode and sample file with user's results. Words whose haven't been ever guessed aren't listed in XML file.
   
4. Some bugs were found
5. Some bugs were patched

Things waiting to be done

1. Fixing saving recent files list, when applications is closed by pressing X
2. Cleaning hangovers of hard-coded themes. Probably prefs.h has to be cleaned
3. Patching switchable hangman images. Many bugs were found.

Thank you all for this GSoC!
Now I'm taking some days off. Expect next part of my questions (and commits ) for about 1.5 week.

Thanks!

Though this entry will be the last one about my GSoC, it certainly won't be the last one about my work on Krita or even on its new Transformation Tool. It was a great summer, I had a lot of fun working on this project. It was all the more stimulating so as I could follow the progress of the other GSoC students working for Krita. Everyone did such an incredible job, it gave me the envy and the energy to complete my project and make it as it is.

I'll be brief about what I did the past two weeks, as I prepared 3 small screencasts which will show you what the new tool looks like and how to use it.
Two weeks ago, I had just implemented warp functionality, so I still had some work to do on the UI.
First I changed the way to switch between Free Transform and Warp mode, so that the Tool Options Widget changes depending on the mode.
In warp mode, the user can either use default control points placed like a grid whose density can be changed, or place the control points by himself/herself.
In the paper I used as reference for the maths, 3 deformation functions were described, and I had only implemented one (affine). Thus I then added similitude and as-rigid-as-possible deformation functions.

Here is a picture I produced with the tool, which illustrates the difference between those functions. From left to right : original image (sorry if it's not very nice, I made it myself), warped using affine function, similitude function, and rigid-as-possible function.

Last week I essentially cleaned the code, fixed some bugs/weird behaviours, and changed some icons.

To close this entry, I wanted to show the results of my hard work, so here are some screencasts of the tool in action :

• Using Free Transform mode.
• Using Warp mode.
• And a last one using Warp mode to show the difference between warp functions.

This Friday (20th August) me and Ubuntu translations man David Planella want to spend the day making sure translations in Kubuntu are in tip top shape. Do join us on IRC in #kubuntu-devel if you want to help out. See the wiki page for some things we will be checking.

Follow up of the discussion about new UI elements: "it may look weird" first-look opinions vs positive results of usability testing. GMail has removed "select all/select none/..." buttons with single combo box for exactly one reason: elegance or UI uncluttering.

How do you like it? Feel free to share your comments below after a few days (preferably using the UI e.g. in gmail).

So, as looking that everyone is in the hiring mode...

Yes, Collabora is hiring. So if you are passionate for open source, want join a company that share the same passion as well, want to work from any place in the world and have at least some of these skills below, then we want to know you.

• KDE
• Qt
• Qml ( Qt Quick )
• C++
• WM and Graphics(3D, GL/GLES, X, Mesa) as a plus

Consider yourself a serious KDE hacker? Don't be shy, we want to know you too ! KDE is an important part of our lives now.

Then, what are you waiting for ?
Share your hacking ninja code skills contacting us at our hiring info channel, also known as email .

Hi,

I thought since others are announcing jobs here, so I can do that too

So, here we go:
The Competence Center for High Performance Computing at the Fraunhofer ITWM in Kaiserslautern has open positions:
https://jobs.fraunhofer.de/Vacancies/57538/Description

We are working here on processing terrabytes of seismic data on Linux clusters. This is the big iron, high end stuff
We need people working on the user interface (that's where Qt comes into play), the algorithms, optimizations, communication, etc. You'll be working in team of experts from different fields, from Mathematics over Geophysics to Computer Science.

Being fluent in C++ is a requirement, and if you consider yourself good also in 2 or more of the items below, we are looking forward to your application:

• Qt
• STL
• multithreaded programming
• lowlevel stuff like SSE, NUMA, etc.
• signal processing
• Linux
• Windows development knowledge also doesn't hurt
• software testing
• computer graphics, OpenGL, etc.

Location is Kaiserslautern, Germany, main work language is German.

Alex

I've been fascinated by the Oracle attack on Google's Android. I don't follow sport and just couldn't understand why so many people were getting excited about the World Cup at Akademy. But to me these epic disputes are a great spectator sport, as well as an opportunity to participate individually. The trouble is that it is all a bit slow, even slower than cricket - if it is like the SCO vs Linus train wreck, it could take up to five years to be resolved.

Anyhow, I've been doing some 'prematch' preparation reading all the blogs and news sites, studying the patents and so on. I think everyone should start by watching this presentation on Dalvik by Dan Bornstein the lead developer of Dalvik. If you watch the presentation it is clear that Dan is no Java guy, and when people ask him why did the Dalvik team choose the Java language for programming Android, he answers that Java has great tooling like Eclipse and there are many people who are familiar with the Java programming language. It was a pragmatic decision. If there were more people familiar with C# and the tooling on Linux was better, then maybe they would have chosen C#. To them Java is just another programming language. Likewise, to me, Java is just another programming language, and C# is just another programming language. The only sort of people who have an obsession about 'Programming Language A' being better than 'Programming Language B' are bad programmers. That doesn't mean that language 'A' may or may not be better than language 'B' for specific uses, but these 'religious types' are obsessed with their choice of language.

So if the choice of the Java programming language for Android was just a pragmatic decision, then why are Oracle suing Google for choosing Java? The best article I have found about the possible motivations is Oracle v Google: Why?.

I don't think Google developed Dalvik to work round licensing and patent problems with Java, they developed it simply because Sun's Java technology wasn't good enough for what they wanted to do. If you watch Dan Bornstein's presentation that is abundantly clear. Designing a new virtual machine runtime is hard, but not that hard. The JVM was influenced was influenced by the Pascal pcode system, and the Smalltalk virtual machine architecture from the 1970s has also been very influential. Recently there have been a pile of virtual machines for JavaScript being developed. Thirty years later after Smalltalk-80 the technology of virtual machines and JIT compilation is really mainstream.

However, Oracle appear to think differently. In their opinion they 'own' certain aspects of virtual machine, JIT compilation and Java .class library optimizations that nobody else is allowed to use without expensive licensing. These are the patents:

1. 6125447 Protection domains to provide security in a computer system
2. 6192476 Controlling access to a resource
3. 6530080 Method and apparatus for pre-processing and packaging class files
   
4. 6910205 Interpreting functions utilizing a hybrid of virtual and native machine
5. 6061520 Method and system for performing static initialization
   
6. 7426,720 System and method for dynamic preloading of classes through memory space cloning of a master runtime system process
7. RE38,104 Method and apparatus for resolving data references in generated code

I think the first question to ask is which of the above patents are specific to Java, and which could apply to any virtual machine implementation.

• Patent #1 talks about classes but doesn't specifically mention Java. It is really about downloading classes from the internet, which Android doesn't do. So we can count that one out.
• Patent #2 is about inter-thread protection domains which AFAIK Dalvik doesn't have. If it did have this, and it was removed I don't think it would be a great loss anyway.
• With Patent #3 it does seem to have something to do with what Dalvik does. It talks about repackaging multiple .class files into a single package to make them smaller. If the Dalvik tool to convert .class files to a .dex file does the equivalent to what the patent says, does that mean that it violates the patent? It talks about allocating dynamic memory a lot, whereas the .dex conversion is a build time thing. To me that means the patent doesn't apply, apart from what the patent does being fairly simple stuff to consolidate constant pools and so on.
• Patent #4 is about JIT technology. This is pretty standard stuff in 2010 and there are many JavaScript based JIT compilers. The patent talks about overwriting a specific JVM virtual machine instruction with a native code version. I'm not sure what this means in fact. Surely the virtual machine instructions have been optimized by very clever people at compile time, and runtime optimization doesn't make much sense. Whatever tech this is talking about appears to address some very specific problem of the JVM and it is unlikely that it would apply to the Dalvik VM.
• Moving on to patent #5 'Method and system for performing static initialization', we have a technique which clearly doesn't apply to Dalvik because it is all done at runtime, whereas Dalvik does it at compile time when the .dex files are generated. So I don't think this patent applies.
• In patent #6 we have 'System and method for dynamic preloading of classes through memory space cloning of a master runtime system process'. Well I think this would be an interesting patent if Sun had actually invented the fork() call, and copy on write of memory that the patent depends on. But they haven't and all the patent is doing is to describe a very common way to use Unix/Linux fork() calls with copy on write memory access. This technique is used by KDE where there is a kdeinit process which has a load of libs pre-loaded, and it forks off sub processes to speed things up. Similary on Maemo/MeeGo there is a process which waits for DBus calls and starts processes. On Android there is a process called 'Zygote' which waits on a socket call and starts processes. The JVM patent only talks about copy on write, it doesn't mention memory mapped files or shared memory which I believe Dalvik uses. This way of doing things is so generic to the way Unix system programmers design systems, that I can't see anything much original in the patent.
• Finally we have patent #7 'Method and apparatus for resolving data references in generated code'. This talks about 'new code arriving at a computer' and how it can be given suitable permissions. Actually this is not how Android works and I think we can just dismiss this one as being irrelevant. In Android as far as I know only whole apps are installed - you don't have the concept of a class loader loading remote classes into a running app.

So that is my brief run through of what I think of the individual patent claims. I am not a lawyer and so I could be completely wrong, but if enough people do this kind of technical analysis in conjunction with actual laywers, in the same way Groklow did for the SCO vs Linux case I hope we can manage to make the Oracle lawyers look like the technically illiterate people that they are (they are much the same set of apparently useless lawyers that were hired by SCO).

Although I don't really like Java much, Arno Rehn has been thinking of doing some Java bindings recently for Qt and I've been wondering if we could base them on the Android Dalvik VM and target them at the MeeGo environment. That way we could do our bit for hastening the demise of the regular JVM or the useless MIDP cut down Java environment, and help to make Dalvik the ubiquitous choice for running applications written in the Java language on small devices. The most interesting technical problem might be how to integrate the Android 'Zygote' process starter with the MeeGo DBus driven equivalent. Another interesting problem is that Dalvik supports JNI but Dan Bornstein mentioned that there was a more efficient mechanism for make native code calls. Maybe as the Smoke way of doing language bindings doesn't involve a JNI call for every method in the C++ api being wrapped, we could make use of that.

To me writing code is a means of Free Speech, and the Free Software movement is about preserving my rights of Free Speech in the face of the US patent system which is trying to cut down what I can say. Attacking the Oracle patent claims, and writing software to undermine their market position is the least I can do. If enough people think and do the same, I hope we can cause them trouble.

UPDATE

Charles Nutter (the JRuby developer) has written an absolutely superb review of the anti-Google patents. I defer to his views, as he obviously knows much more than I do about the subject. He comes to similar conclusions to me though, and thinks the Oracle patents are fairly light weight and that the case would fail in the context of a rational legal system.

Planet KDE is your insight into the lives and activities of KDE, a community making lovely free software.

Occasionally I get asked to add feeds to Planet KDE which aren't KDE contributor blogs. News feeds, user blogs and non-English blogs are the usual requests. So today, thanks to the helps of others, I've updated our software and added opt-in support for these different types of feeds. Just click the configure button at the top of the page.

If you have a KDE project news feed (including KDE related distro news), a KDE user blog, or a KDE blog in Spanish or another language do file a bug or add it yourself to the feed (it's in svn) with the new define_feedclass attribute.

I also updated the software to Rawdog 2.12 which should help keep the memory usage on the server down.

Thanks to Ade, Stuart and Kurt for helping with various bits.

Update: The new feeds are not added to the RSS feed (they were yesterday but I stopped that now). Also the history is longer, you get 5 pages now instead of just 2, click on the "older blog entries" link at the bottom.

Marble 0.10.0 has been released as a major update last week together with KDE SC 4.5. As a user you might be interested in our Visual ChangeLog which is also available in spanish over at muylinux.com.

But Marble is also a library. So it can be used as a widget in other applications. Today I'd like to show you how.
In our previous tutorial I already introduced you to the very first steps of Qt Programming and Marble Programming. Now the last few Summer days in Germany have been rather rainy. So in the second part of our tutorial I'd like to show you how to create a weather map!

Creating a weather map

We'd like to display a small weather map. So we need to modify the map defaults of MarbleWidget. And we need to turn on the satellite view, enable the clouds and enable the country border lines.

Again MarbleWidget provides a convenient way to make these changes to the overall look and feel of the map.

By default Marble shows a few info boxes: Overview Map, Compass and ScaleBar. But the size for the widget is very limited. Therefore we want to shrink the compass. And we want to get rid of all the clutter, so we turn off the Overview Map and the ScaleBar. In the source code the class AbstractFloatItem is used to display all kinds of Info Boxes. All the Info Boxes are derived from the AbstractFloatItem class. Now we get a list of all the float items that are known to MarbleWidget and we go through it. Once we reach the float item which has got the name id compass we make all the changes we want to it (this has been simplified in Marble pre-0.11.0 where you will be able to access AbstractFloatItems directly via their nameId):

#include <QtGui/QApplication>

#include <marble/global.h>
#include <marble/MarbleWidget.h>
#include <marble/AbstractFloatItem.h>

using namespace Marble;

int main(int argc, char** argv)
{
    QApplication app(argc,argv);

    // Create a Marble QWidget without a parent
    MarbleWidget *mapWidget = new MarbleWidget();

    // Load the Satellite View map
    mapWidget->setMapThemeId("earth/bluemarble/bluemarble.dgml");

    mapWidget->setProjection( Mercator );
   
    // Enable the cloud cover and enable the country borders
    mapWidget->setShowClouds( true );
    mapWidget->setShowBorders( true );
   
    // Hide the FloatItems: Compass and StatusBar
    mapWidget->setShowOverviewMap(false);
    mapWidget->setShowScaleBar(false);
   
    foreach ( AbstractFloatItem * floatItem, mapWidget->floatItems() )
        if ( floatItem && floatItem->nameId() == "compass" ) {
           
            // Put the compass onto the left hand side
            floatItem->setPosition( QPoint( 10, 10 ) );
            // Make the content size of the compass smaller
            floatItem->setContentSize( QSize( 50, 50 ) );
        }
   
    mapWidget->resize( 400, 300 );
    mapWidget->show();

    return app.exec();
}

Save the code above as marble_weather.cpp and compile it:

g++ -I /usr/include/qt4/ -o marble_weather marble_weather.cpp -lmarblewidget -lQtGui

Instead of calling the compiler directly you can also create a qmake project file:

TEMPLATE = app
TARGET = marble_weather
DEPENDPATH += .
INCLUDEPATH += .
SOURCES += marble_weather.cpp
LIBS += -lmarblewidget

Store it as marble_weather.pro in the same directory and call

qmake marble_weather.pro
make

If things go fine, execute ./marble_weather and you end up with a map application that displays clouds on top of a flat map:

That's all for today. In our third chapter we'll show how to load KML and GPX files into Marble. So stay tuned. If you need help join us on our mailing list marble-devel@kde.org or on #marble (IRC on Freenode). If you want to obtain the latest Marble source code have a look at Marble's website.

If you are interested in more news about Marble then join us and feel welcome in our Marble Facebook Group!

Marble 0.10 was released on August 10th, 2010. It is part of the KDE 4.5 Software Compilation. In the good tradition of recent years, we have collected those changes directly visible to the user. Unfortunately we were a bit late with our visual changelog for the release. So please enjoy looking over the new and noteworthy:

Online Routing

Do you want to plan a bicycle tour in the nearby wood? Need driving instructions to get to an address in a foreign city? Besides searching for places, Marble can now display possible routes between two or more of them.
And the best thing is: The routes are draggable!

Online Routing in Marble

Places to travel along can be entered using search terms (e.g. addresses) in the new Routing tab on the left. Of course Marble also allows you to input them directly on the map. Routes are retrieved using OpenRouteService and displayed on the map. Turn-by-turn instructions are displayed on the left.

You can customize the route using preferences like transport type (car, bicycle, foot). An arbitrary number of via points can be added easily: Use either search terms or create stopovers quickly and conveniently by dragging them out of the existing route and dropping them at the desired position. While a real-time navigation mode is scheduled for Marble 0.11, you can already export the route in the GPX format now. This feature is handy for using routes in conjunction with your navigation device or other software.

Bulk Download for Tile data in Marble for Offline Usage

For normal usage, Marble downloads the map data that is needed on the fly in the background. It also saves the data that has been downloaded on the hard disc. Now imagine that you make a trip to Norway, and you don't know for sure whether you'll have internet during the trip. So you want to download the whole Oslo area in advance. Up to now this hasn't been possible. But with Marble 0.10.0 you can click "File->Download Region ..." and you get a dialog where you can specify the region and the zoom levels that you want to download. This feature was brought to you by Jens-Michael Hoffmann.

Download of the Visible Region

Support for Multiple Layers in Marble

So far, Marble has had support only for displaying a single map texture on top of the globe. (The only exception was the cloud feature which allowed having clouds displayed on top of the satellite map. This, however, was hard-coded and not extensible.)
For this release, Jens-Michal Hoffmann has worked on Multiple Layer support.
This means that maps can now be created which display multiple texture layers. For instance: a cloud layer on top of a street texture layer on top of a satellite texture layer. This is all done in a generic way. So people who create maps for Marble can create an arbitrary amount of layers blended on top of each other. The best thing is: Due to the way the feature was implemented the performance doesn't change! And the clouds feature has been reworked to make use of the new mechanism.


Support for Gimp-like Filters Between Layers in Marble

of OpenStreetMap data via Multiply Blending." class="showonplanet">

The City of Dresden shown in Marble with multiple layers: Satellite images provided via WMS displayed on top of OpenStreetMap data via Multiply Blending.

As described before, Marble has support for multiple layers now. Layers can get blended
on top of each other using Gimp-style "filters": You can choose among more than 30 blending algorithms, such as: Overlay, ColorBurn, Darken, Divide,Multiply, HardLight, ColorDodge, Lighten, Screen, SoftLight and VividLight. If you've ever use an application like Photoshop (TM), Krita or Gimp then you probably know what this means.


Quick and Dirty WMS Support and More Url Download Schemes.

Lots of map data is provided on the internet on servers via the Web Map Service ("WMS") protocol. Bernhard Beschow has added initial quick and dirty WMS support to Marble. This means that there are now a huge number of maps that can be easily displayed using Marble.


Marble Goes Mobile: Support for Nokia's N900 and UI profiles

With KDE 4.5, we have completed the first step toward mobile platform support: Marble will show a slightly different and simplified UI on the N900 Maemo platform compared to the desktop. For KDE 4.6 we aim for an even better user experience and improved performance.

Marble on a Nokia N900

Marble Routing on Maemo5

For more information please visit the Marble Garage Project. Next stop will be the MeeGo version for Marble.


Display APRS (Automatic Packet Reporting System) Senders with Marble

This is one of our first more specialized Online Service Plugins: The APRS plugin created by
Wes Hardaker shows worldwide Ham-Radio stations. HAM Radio's APRS program allows radio transmitters to send their position and other information and is frequently used in disaster relief efforts for coordinating team distribution.

APRS senders displayed in Marble

We are still looking for programmers who would like to create more Online-Plugins: e.g. Twitter, News, Earthquakes or a social network plugin. It's easy to do and there's an Online Service Plugin tutorial available on our website that shows how to do it.


Performance Improvements and More Changes Under the Hood ...

In addition to these major improvements, our Marble developers have worked on several other small features, bug fixes and performance improvements:

• Two additional search backends: Hostip (try "planetkde.org") and OSM Nominatim (try "ATM,
  Karlsruhe") (Dennis Nienhüser)
• Improved animation support for zoom and panning (Dennis Nienhüser)

Ryan Melton announced on the kde-bindings mailing list that he had set up a project on github called 'qtbindings' with the aim of doing cross-platform gems for QtRuby. This is great news, and congratulations to Ryan for making it happen

Ryan announced:

"..I put together a new cross-platform gem for the Ruby bindings to Qt and put it out on rubygems.org as "qtbindings". This should make it a lot easier for people to install the ruby bindings on non-KDE systems. I've tested it out on Windows XP, Ubuntu Linux, and Mac OSX Snow Leopard so far and it seems to work great. It is mainly the code straight from KDE bindings, but it also includes the patches for building on Windows I submitted to this list back in February, the fix for ExtraSelection, and some new fixes I've put in for the HWND__* classes on Windows. I will be submitting the new patches back to this list soon. Some other changes include minor modifications to the CMakelists.txt files, and reorganizing the folders into a standard ruby gem structure that I doubt you would want to incorporate back into the kdebindings repository. Enjoy and I hope this increases the adoption of the great bindings you guys put together! .."

So although it is a fork, it isn't a hostile fork and so I think the benefits of making QtRuby easy to install on Windows and Mac OS X outweigh the disadvantages.

Over on the RubyForge site there is a new version of QtRuby, qt4-qtruby-2.1.0, which I didn't produce either (Jan Pilz? not sure, need to find out), and that is great news too. A new release there was long overdue.

Meanwhile the Maemo/MeeGo widget testing guys are really keen to have a version of QtRuby that wrapped the MeeGo Touch (ie libdui) libs, and Qt Mobility. They use Gitorious and so a version of QtRuby that you could be with qmake instead of cmake would be really good, and ideally hosted on Gitorious so they would be able to make enhancements and fixes using their Gitorious accounts.

I worked on a major refactoring of QtRuby which is long overdue. But that work has stalled because I have been waiting for KDE to migrate to git. I was expecting it to have happened a month or two ago as we were negotiating with the Gitorious guys for a long time, and it seemed as though we were going to get the migration done about June 2010 time when I was thinking about it last Christmas. That wasn't to be as the Gitorious negotiations fell through, and instead on his recent blog Tom Albers reports that the schedule for git conversion won't start converting the main kde modules like kdebindings until November 17th:

November 17th: "..
After the initial flow of individual projects that have moved to git, we are open to assist in moving the KDE modules. How this part will happen is unknown and will probably not happen directly at this point in time.."

I have other projects like the JSmoke JavaScript bindings on Gitorious, or the Wt::Ruby bindings on github that I would like to be able to coordinate with QtRuby and the smokegen bindings generation tool. All the other projects are in git, and it is becoming increasingly difficult to know how to cope if I just leave QtRuby in the KDE svn where it has been since the project started seven years ago. But clearly if I don't do something, things will just get into even more of an unmanageable mess than they are at the moment.

As far as I know it will be possible to move to the KDE git repo in advance of sometime next year, otherwise that would be after the KDE 4.6 release, and I'm just not keen on waiting that long. If the move isn't a lot sooner than that, I feel I will just have to give up, and probably treat the 'qtbindings' github repo as the main center of development for QtRuby.

On an unrelated note my employer, Codethink, are looking to qt/qml guys, Alberto Ruiz sent me this:

Codethink Ltd. is looking at the possibility of hiring a
few people with Qt/QML experience, people that have contributed stuff to
Qt upstream is a plus. Please send your CVs to jobs@codethink.co.uk.
Codethink is an exciting place to work at, and they allow people to work
from home which is great, the head offices are in Manchester so if you
don't like working from home you can always join us from our offices.

I can confirm that Codethink is an interesting place to work, and their tee-shirts aren't bad either. So get in contact if it appeals.

I was actually going to investigate QML and language bindings and do a blog about that to make it more relevant to what Alberto is asking for. But I found it a really hard problem and I haven't decided what the best thing to do is yet. Should we try and do a Ruby version of QML and compile it to the same form as if it had been JavaScript, or do we keep all the JavaScript stuff and attempt to mix it up with Ruby code? I don't know yet.

• KOffice Developer Meeting (pictures).
• Akademy time! One Kexi dev was available for hugs^wdiscussion; chatted a bit with the ownCloud hackers about exposing Kexi databases though it, KDevelop guys about injecting Kexi database plugin in a form of KDevelop's "Database view" and mobile guys about possible options for Kexi Mobile.
• http://userbase.kde.org/Kexi updated. New tutorial added: Kexi Reports for Beginners
• Adam works on porting the remaining Q/K3 code in Kexi, starting with the Project Navigator. Ported now.
• The works on Kexi 2.2 Handbook started within the KDE Userbase wiki: http://userbase.kde.org/Kexi/Handbook
• Kexi now supports multipage (large up to 64 KB) memo values when importing data from MS Access. And it's the only open source app doing it!
• Some work on Predicate, database connectivity and creation library, a new iteration of KexiDB library developed within Kexi (Jarosław). Expect a more in August.

By and large I don't really care about what Microsoft do - I don't use their software, and I actively avoid making my career dependent on them. But I am a fan of the C# programming language and think the Qyoto/Kimono bindings for the Qt and KDE apis are pretty neat.

However, the recent decision to lay off all the IronPython and IronRuby guys is so monumentally stupid, I don't know where to start. I still think C# and Mono are really innovative, and don't agree with all the Free Software trolling against them, even when it is from Richard Stallman himself. So what should we do? Arno is clearly not happy with working on C# bindings even though they are technically pretty amazing. Steve Ballmer why are you are still in charge?

Last weekend I received a postal package that contained a classroom atlas from Austria: the Neuer Kozenn Atlas. Inside there was a nice shiny CD with the title GEOTHEK Schulatlas, Version 1.1 Digitaler Weltatlas. The publisher of this atlas and its software is Ed. Hölzel.

The Kozenn Atlas (named after the slovenian born teacher Blasius Kozenn) has been produced in Vienna since 1861. It has been updated continously by the Geographical Institute Ed. Hölzel. And it has been published in a lot of other countries as a world atlas (France, Netherlands, Belgium, etc.). Up to these days it's the most famous austrian school atlas.

Geothek is a software published by Ed. Hölzel that had been developed by Helmut Mülner from the renowned Joanneum Research. I was curious since this was supposed to be the first version based on the Free Software Marble.

So I booted up the Windows 7 partition of my Thinkpad and put the CD into my external DVD drive. The setup application started automatically and I had to approve the License:

Afterwards the Nullsoft Installer quickly installed the files into the directory that I had chosen. A help text showed up and a new entry Geothek Schulatlas appeared in the Start Menu. A click on Atlas started the Geothek. It turned out that this version of Geothek is a nicely enhanced version of the Qt version of Marble: The application is fully translated into German. Also the location database is replaced by data from Ed. Hölzel.

Entering a location in the Search query field centers the globe onto the selected place as usual. However a second tab in addition to the globe view had also been added which contains a 2D-Viewer for the physical maps of the Kozenn atlas (see screenshot above). This 2D viewer would automatically choose the correct physical map and center and zoom it according to the search query. Symbols are added on top of the the physical map which the user can click on and which interactively provide hundreds or thousands of encyclopedic articles, climate diagrams and beautiful photo material for lots of popular places.

The "Map Theme" tab contains additional maps featuring topics like "Population Density", "Climate Zones" and "World Trade". And for each of these a specific legend had been created. Of course all those maps can be panned and zoomed as always in Marble. Very nice quality work!

At the bottom left there is a "Statistics" page. Clicking onto it makes a big table appear: The table lists all countries of the world. The columns cover all kinds of topics, like area, population, life expectancy and lots of other interesting facts. After selecting one of the columns the second tab displays a map that nicely color-codes this information. There are more configuration options for this map and it's pretty evident that the application developer had a lot of fun in developing this particular feature.

Another interesting addition is the 3D Satellite View. Marble itself which serves as a base doesn't provide a true OpenGL view with flights over mountain landscape sceneries. Adding something like this is on our roadmap. But it will still take some time to add it properly.

So the Geothek developer added a special separate OpenGL based canvas which would allow to fly over a given area. The view features satellite imagery on a "flat" map and it's possible to tilt and rotate the view in all directions. Also the elevation of the landscape can be exaggerated:

As a bonus access to a set of "silent maps" is provided for teachers via the application menu.

All in all this application is a great showcase how Marble can be turned into a customized and polished quality product that is fun to use! The current version of Geothek is based on Marble 0.7/0.8, which is more than a year old. Since then Marble has developed a lot furter, adding stuff like Routing, WMS support, multiple layers, better OpenStreetMap integration and a lot of details that make life of application developers easier.
So I think that Marble nowadays should be an even more attractive solution for publishers of schoolatlases and encyclopedias: They could just rip out the original Marble content (if necessary) and replace it with their own high quality data. That would cost a lot less than building up a full custom solution on their own. In the Marble project we'd really like to support such kinds of projects. And since the Marble development pace seems to increase I wonder what the next two years will bring.

I'd like to congratulate and thank Helmut Mülner and Lukas Birsak for this amazing product they have created. I was also very impressed by the way they credited the Marble team's work. Even better: The Geothek was published as an LGPL project on sourceforge. Of course the Hölzel maps are not included in the source code but that was naturally to be expected. But we also liked how the Geothek developer contributed his bug fixes back to the Marble Project in the best possible way.