off-topic

Okular - KDE4 PDF Viewer (and much more)

2009-05-13T10:36:00.006+02:00

One of the exciting new programs introduced in KDE 4.0 is a unified document viewer called Okular.

Based on the solid foundation of KPDF from the KDE3 era, Okular became a document viewer with many more features and support for a large number of formats. At the time I wrote about it in my blog post about KDE4.0.0 it supported 28 file types. In version 0.8.2 (part of KDE 4.2.2) as shipped with Kubuntu Jaunty it supports 45 file types. Note that these numbers may vary greatly with the number of packages supporting various file types installed and that some of the supported types are just compressed versions of others.

Here is what it looks like displaying in order: a PDF file, a JPG image, an OpenDocument document and a Comic Book Archive comic.

Additionally Okular supports a presentation mode (not pictured) as well as annotations and reviews:

Okular is slick, powerful and easy to use. It is a great example of the new user interaction ideals seen in all components of KDE 4.

Location-Based Services on the Android Platform

2009-04-09T21:01:00.007+02:00

If you are like me you have ever large plans for projects and products, which more often than not are doomed from the outset by a severe lack of time. All this changes of course when the project you are tackling is one which you are being watched and mentored to do. The amount of time at your disposal doesn't change, of course. Instead it is not the project being doomed, it is you if you don't make the time. This post is about a project, which started in a relaxing atmosphere such as this. If you want all the gory details get the paper I am about to introduce to you now.

For the last far too long period of time I have been developing a project for university. The goal of which was to evaluate the new Google Android mobile device platform for its suitability to the development of location-based services.

A location-based service - besides sounding remarkably cool - is made up of a program or set of programs which supply the user with information and actions depending on his or her location. It is a comparatively easy to achieve kind of context-awareness. The idea being that if we supply our assistant devices with information about our current environment they ought to be able to filter the information we might want to access and present us with actions we are more likely to take than they would otherwise be. The research community has high hopes for location-based services. Projecting that it will allow major gains in usability, going so far as to make ideas practical, which have so far never come to fruition.

With a whole new player (Android) with powerful backing (Google) entering the mobile arena the question of whether it might be able to stir things up in the location-based service space was intriguing. So I set out to build a location-based service to evaluate the Android platform.

The project

Say you are getting dozens of emails every day. (Reading - as you are - a blog post about an operating system designed to run on a mobile communications device, I'd say this is probably not too far from the truth.) Many of these messages will ask you to do stuff you really cannot be bothered to do right now. A sufficiently advanced and knowledgeable assistant device would be able to filter these messages and present them to you when you are ready to act upon them, when otherwise you'd just become cross. This is obviously an example of a context-aware application. And the information required to fulfill this vision are notoriously hard to come by. So as everybody does, I took a step back and morphed this concept into an application which could work on the subset of context information I might somewhat easily obtain: location and time.

The resulting application is this: A friend of yours sends you a message. She knows she stands a better chance of you getting back to her if you receive the message when you are in the mood and have the opportunity to act upon it. So she annotates the message with a time and place she thinks you might be willing to receive it. Say an invitation for dinner is likely to be interesting to you beginning around 5 in the evening and only if you are at home (ie not working or commuting).
The finished application works. With a little huge problem beyond my control, which I will get to.

Developing on Android

Android is well suited to the development of mobile applications. This is rather important if you want to develop any kind of meaningful location-based service. A location-based service running on your desktop computer might before long turn out to be rather boring.
Android requires that developers design applications differently from traditional environments. And in my opinion (hey, that's what blogs are for) it was a good decision that it does. Android applications are split into a number of comparatively loosely coupled components, which act in concert to produce the "experience" of the product. Saving of data is one component's responsibility, showing one particular view is another, reacting to changes in the environment is a third. Together these components create an application, which is capable of storing data, interacting with the user and reacting to changes in the environment. (If this sounds interesting to you, you should really read the paper.)

These applications are just as powerful as more monolithic ones, but they offer the system a lot more power to manage its components. This way the system can guarantee that applications remain as responsive as possible under resource constraints. Which is rather important in a mobile environment.

Follow the Android

Unfortunately, when I started developing the project the current version of Android was a pre-release. For one this meant that I had to port the project a number of times as the API changed. For another there were a number of bugs, which were not documented, requiring me to debug the project without actually turning up any bugs.

But in hindsight worst of all was that the Google decided to remove built-in XMPP capabilities in one of the last pre-releases. At the beginning of the project it looked as though tight XMPP integration would become a major selling point. So the message transfer mechanism I built the whole baby around of is all XMPP. And when Google decided to drop that technology (for dubious reasons) I was left out in the cold. So no using the application on real devices in the foreseeable future. Sucks? Yeah, big time.

Is Android the sliced bread of location-based services?

As any answer to such a question my results can only be seen as a kind of well-informed opinion. Generally yes. Android provides a number of useful features in the context of location-based services. For one it has built-in location APIs and a maps widget, which is readily available on most devices (by virtue of being a Google-supplied "Optional API"). So if all you are after is a well integrated location system, Android is as good a choice as any. Additionally, being a new platform Android is certainly not any less advanced concerning the technologies which have so far proven to be interesting.
Is that enough to learn a new platform? Frankly, I don't know. Assuming most of the bugs that bothered me so much have been worked out, I think Android should be a pretty nice environment to program in. Designing my project took a few iterations to get right and I think this is probably the largest obstacle facing any newcomer to the Android platform.

The Location-Based Services on the Android Platform paper can be downloaded on my website. My presentations are usually not easy to comprehend without the accompanying talk. And it is in German. But here is the Location-Based Services on Android presentation as well.

I sincerely hope this project is of value to you. If there is any information you'd like me to give you or if you have something for me, please leave a comment.

Simple atom aggregator in PHP (with source code)

2009-02-01T16:04:00.003+01:00

I wrote a small class to fetch and parse atom feeds in PHP. This could be useful to someone, so I release it under the GPL. The result of this little project can be seen on my web site. Prominently featured at the top of the page is a list with my recent blog posts aggregated from various web services.

This was an interesting little project, which lends itself as a nice example for people interested in PHP programming. Note though that PHP is not really my area of expertise, so there are likely ways this could be improved. Leave a comment!

This fun little project consists of two classes: Entry and AtomParser. AtomParser fetches a feed and parses its contents. This is made easy by PHP's XML Parser facilities. The information likely to be interesting to people wanting to show the contents of a blog on a different website (most importantly title and text of the post) are stored in Entry objects.

For convenience AtomParser supports adding multiple sources and sorting them by date. Retrival of the entries is realized in a for-loop friendly getEntryIterator(), hasNextEntry(), getNextEntry() way.

Combined this allows the following snippet to work:


$parser = new AtomParser();
$parser->addSource("http://identi.ca/api/statuses/user_timeline/mauder.atom", true /*microblog*/);
$parser->addSource("http://drowstar.blogspot.com/feeds/posts/default", false);
$parser->sortByDate();

for($iterator = $parser->getEntryIterator();
  $parser->hasNextEntry();
) {
  $entry = $parser->getNextEntry();
  printf("<h1>%s (%s)</h1>\n%s\n", $entry->title, date("Y-m-d", $entry->date), $entry->text);
}

The snippet I actually use on mauder.name is rather more complicated, but as the presentation is very much a matter of taste I leave it to the reader to find one he is happy with.

I release this snippet under the GPL. Email me if you need a different license.

Integrating GTK apps with the KDE4 desktop with gtk-qt for Qt4 (screenshots)

2008-02-14T12:34:00.013+01:00

For KDE3 David Sansome wrote a special GTK theme gtk-qt, which instead of drawing its own representation of buttons and other user interface elements, called the corresponding Qt3 drawing functions. Believe me, this sounds a lot more trivial than it is.

When it was done, it showed some very impressive results.

Image courtesy of David Sansome

However, after KDE4 was released (my review), Qt3 started to look equally out of place as gtk rather quickly, when the Oxygen widget style manifested itself as the default KDE4 look:

When Firefox 3 beta 3 was released the other day I tried to get a glimpse of the new gtk widget integration. Suffice it to say: It looked really strange and not like something they would have bragged about.

It's obviously KDE3 showing here. So I decided to see if there was a KDE4 version of gtk-qt. It turns out there isn't. But I found this bug report and a reply by David Sansome himself, stating that:

Just wanted to let you know that I *am* working on this, but as previous posters have said Qt4 has changed a lot in the theming department and it's not as simple as just porting the old code over.

He has created a branch in the development repository, which I have checked out. Screnshots incoming!

Keep in mind: THIS IS NOT A RELEASE! But very much a work in progress. If there are problems, they will be ironed out!

The first impression is that it looks very impressive!

The not quite so straight-forward firefox interface reveals some drawing issue though:

But they are IMHO a lot better to look at than the qt3 version, which just looks thoroughly out of place:

There are also issues with widgets embedded into web pages, which disappear on a re-draw (for example scrolling page-wise, not progressively).

Compare with the same piece rendered by Konqueror:

Overall the port seems to be progressing well (the repository is seeing frequent commits) and I look forward to GTK apps integrating more smoothly with the KDE4 desktop.

Update: I have made a mistake attributing the brokenness we saw with the current firefox beta to gtkqt. Instead it appears the feature was not working quite correctly in firefox itself. I noticed a couple of days after this post was published that the same drawing weirdness we saw in the screenshot also appears on a pure gnome system. I can't reproduce it now and as matter of fact the current ubuntu packages on hardy make firefox fit in nicely.
Sorry about this mis-information. It seems gtkqt4 is in even better shape than I originally thought.

The new Google Android interface

2008-02-13T22:52:00.005+01:00

Google released a new version of the SDK of its Android mobile platform today. News that this release would introduce a new interface has been going around and in fact the new interface has appeared.

Being a sucker for this kind of thing (and having some work for university to put off...), I installed the new SDK and prepared a few screenshots of the new interface for your viewing pleasure.

Keep in mind that Google still calls this interface a work in progress.

home screen

During boot Android shows a Cylon eye. After its done booting up it shows this new home screen, which gives a first impression of the new softer appearance of the interface. After you have used it for a bit it collects the most recently used applications in a list on the home screen.

Making calls

The contact list and dialer are layed out much more generously than in previous versions. You can already see that the interface has a unified look.

Maps

Maps has gained features in this release. The basic interface hasn't changed much, but you can now find a place to eat in Sweden and get driving directions in Australia.

Browser

The browser is based on webkit like the one in the iphone. As such its capable of rendering real web pages. Here two we find the familiar playful Android interface.

3D and advanced eye candy

Android has some graphics niftiness up its sleeves, which has not been put to very extensive use in the current SDK yet. There are some transparency effects, the dialog and user interface elements animate into view and there is even the occasional trace of 3D rendering. The most impressive looking effects are still only visible in developer demos though.

Conclusions

While the user interface has seen a major revamp in this release, this is still an early look for developers and will likely still receive more work.
The user interface was just one change in this release. Many interesting things were added under the hood. For example two interesting non-GUI additions are geo-coding (making the map searches pictured above possible) and more media codecs (among many others there is now support for ogg vorbis (yay for free codecs)).

The Android team is clearly making progress and have created a much more unified looking interface. For my taste they have overdone the playfulness just a little bit though.

First look at the unreleased KDE4.0.0 (with screenshots)

2008-01-06T14:00:00.000+01:00

KDE 4.0.0 is days away from being released. In this post I show you some pieces of the final look of KDE4.0.0 and mention some of the most anticipated features of this great step forward for the Free software desktop. Let's take a look at the final state of this highly anticipated release.

While some of the most shift-key-challenged KDE personalities have cautioned against too high hopes for KDE4.0.0 and despite it being the very first in a long row of releases: KDE4.0.0 is a very impressive desktop.
As the version number suggests KDE4.0.0 is the very first release since KDE3.0.0 to break binary compatibility with KDE3. Being allowed to burn some bridges is the reason so many new frameworks and large changes have landed in just one release.

Starting up

I have been following the development of KDE4 for quite a few months now. The version I base this post on is from the main KDE development (trunk in svn) at the time of the release tagging freeze. As such it should be very similar to the packages you will receive from your favorite distribution on the 11th.

Progress all around

Many of the new frameworks are still almost unused in the user interface of the first KDE4 release. But some more obvious and easily implementable changes have already appeared in KDE4.0.0.

Graphics

Oxygen: Originally planned as the new icon set for KDE4, Oxygen has re-defined all aspects of KDE's user interface, including the window decorations and theme.

Plasma: Plasma is the new desktop shell of KDE4, one of the most anticipated components of KDE4 and the one which was started last.

Because of its late start plasma has not realized its full potential yet, but as with many things in KDE4.0.0 it will gain features rapidly in the future. Plasma's vision is a lot more than to display a panel and cool looking widgets. Stay tuned, already KDE4.1 will introduce new features.

KWin: KWin has been a very robust window manager for a long time. New in KDE4 is its ability to use desktop effects, window shadows and subtle animations. These features depend on the availability of OpenGL or at least XRender, which are not fully supported on all graphics cards yet although the situation is improving rapidly.

However to reduce the risk of an unusable interface, desktop effects may be disabled by default in KDE4.0.0. They can be easily enabled in Systemsettings (KDE4's control center replacement) under Desktop -> Desktop Effects.

Applications

Dolphin: The new default file manager in KDE4. While Konqueror has retained its ability to manage files (and cook coffee) dolphin is written specifically for this task.

The first visible piece of KDE4's new semantic search backend Nepomuk (the name won't be visible in the UI) is dolphin's ability to annotate and rate files.
In the future Nepomuk and Strigi will help you answer questions like "Who gave me this file?" or "What sources did I use on that KDE4.0.0 blog post?"
Progress in Qt4 (the toolkit KDE4 is based on) allows user interface polish like dolphin's sidebar, which changes its layout dynamically as the user drags it. No screenshot, you have to see this one in action.

Gwenview: KDE's image viewer Gwenview has received a lot of polish while it was ported to KDE4 and handles really, really well.

Okular: The new document viewer for KDE4, based on KDE3's KPDF application. It sports annotation features, previews, presentation mode, bookmarks and support for no less than 28 file types in my build.

Unreleased Applications

Amarok: The famous KDE based audio player has been ported to KDE4 and is receiving a major overhaul. It is currently in pre-alpha state, but I have been able to use it normally over the last few weeks. When it is ready, it may also be released for windows.

Dragon Player: Based on the Codein video player from the KDE3 days, Dragon Player continues a successful carrier as a simple and enjoybale video player.

These are some of the highlights of the upcoming KDE4.0.0. I hope you enjoyed this preview and have come to share my opinion that KDE4 is going to rock!

Take a look at this album for these and a few more screenshots I didn't include in this post. If you would like me to screenshot another application for you let me know in the comments and I will add it.

Pointers for the win

2007-06-27T15:11:00.000+02:00

In my last post I used quite a bit of pointer magic to implement a linked list.

If you are not familiar with what pointers are you will have had a hard time understanding the implementation. Let's do something about this, shall we?

Why not use variables only?

A pointer is a way to refer to some data without having to copy it.

That alone may not seem worth the trouble, but there are some (or rather very many) occasions when it is easier to point at the same variable from other places of your code than it is to keep two values in sync.

It may help you at first to think about pointers as meta-variables, a variable you can asign other variables to.

So why did I use them for the linked lists?

Let's go back to linked lists for a moment:

A linked list is comprised of several list elements.

There are two aspects of linked lists, which would make them very hard to implement without pointers:

The first element is not the list, but when you refer to the list, you need to refer to the first element, which in turn lets you iterate through the rest.

Elements don't contain each other, rather they point the user at the next element in line.

Have I seen pointers before?

Chances are you have used pointers before without realizing it. For example, in C arrays are simply pointers, which are automatically dereferenced when you refer to an element inside the array.

Another area you will have come across are strings. You may have learned that a string in C has the type char* or something. Actually, all char* means is a pointer to a character. The string handling functions are smart enough to search the memory at the position the pointer points to for more characters. To mark the end of a string, C uses the zero-termination, ie the last character of a string is always a '\0'.

If you are just starting out ignore this implementation detail. But remember you can impress your friends by dropping that pointers are old hat and that you use them every day.

What is the syntax?

Certainly by now - with all these exciting opportunities stretching out before you - you can't bear the suspence any longer and want to know how you can use this amazing power at your finger tips:

To create a pointer, you do exactly the same as you would when declaring a variable. Except you prefix the name with an asterisk *:

    int *pointer;

And to point to another variable you assign the variable to the pointer, except you prefix its name with an ampersand &:

    int value = 42;
    pointer = &value;

And that's pretty much all there is to basic usage of pointers already. Maybe you'd also like to know what the variable you are pointing at contains? Get that by prefixing the pointer with an asterisk * again. Note that this time we are not declaring the pointer, although the prefix is the same:

    printf("the value of the pointer is %d\n", *pointer);

Example

Maybe you have noticed that when you assign to a variable from inside a function its value is not changed when your function returns. This happens by design so the rest of the program is shielded from changes by one function.

But what do you do, when you want to change a variable inside a function which calls another?

Well, you could make the variable public of course, but that would allow every other function to change its value as well. The answer is - you guessed it - use a pointer!

A pointer is really just the address of a variable in memory (you can see this address when you do a printf("the address of pointer is 0x%x\n", pointer);. Of course you very rarely want to know this address!). So you can pass a pointer and write to the address in memory where it actually lies. This happens to be inside the space of the calling function, which is why changes to the value of the pointer affect the value of the variable inside the calling function.

That's a mouthful, so let me illustrate with an example:

#include <stdio.h>

void set_to_five(int *variable)
{
    printf("changing value from %d to 5\n", *variable);
    *variable = 5;
}

int main(int argc, char *argv[])
{
    int myvar = 3;
    printf("myvar = %d\n", myvar);
    set_to_five(&myvar);
    printf("myvar = %d\n", myvar);

    return 0;
}

Yeah, this may seem confusing at first, because of all the * and & and the other *. Make yourself clear what happens in the above example and you have understood pointers.

Good luck and have fun!

linked lists

2007-02-02T17:31:00.000+01:00

What does this statement mean?

current = current->next;

It means that you have a structure named current, which has an attribute called next, which is of the same type as current itself. The programmer instructs the machine to use next in place of current from here on.
Typically this statement is used to realize linked lists. These work like this: The programmer creates a couple of these structs and gives each the data we actually care about and information about the next element in line.
For example, consider a list of people: John, Frank, Alice, Jennifer. In order to find all four of these, it is sufficient to remember that John was the first one in our list and to tell John to remember Frank, Frank to remember Alice and Alice to remember Jennifer. Now if we want to list the age of all four of them it is enough to call up John, ask him how old he is and who was the next in line and repeat this until Jennifer tells us that there was no one next.

To realize this example as a program, we first need a data structure, which can hold our friends and a link to the next in line. (For simplicity we will only save the name of each in the data structure, more information would be trivial to add):

struct friendList {
  char *name;
  struct friendList *next;
};

To iterate through them the following will work:

struct friendList *current = john;
while(current != NULL)
{
  printf("%s\n", current->name);
  current = current->next;
}

Here is the example in full:


#include <stdio.h>
#include <stdlib.h>

struct friendList {
  char *name;
  struct friendList *next;
};


int main(int argc, char *argv[])
{
  struct friendList friends[10];

  struct friendList *current = (struct friendList *)NULL;

  //link each friend to next one
  int i = 0;
  for(i = 0; i < 3; i++)
  {
    friends[i].next  = &friends[i+1];
  }
  friends[3].next = NULL;

  //assign values to friends we know
  friends[0].name = "John";
  friends[1].name = "Frank";
  friends[2].name = "Alice";
  friends[3].name = "Jennifer";

  //lets see how easy iterating through this list really is
  printf("My friends are:\n");
  current = friends;   //point to first element
  while(current != NULL)
  {
    printf("%s\n", current->name);
    current = current->next;   //remember this one?
  }

  return EXIT_SUCCESS;
}

Linked lists become much more useful when you make them doubly-linked-lists by specifying a previous as well as a next member of each element. This allows you to iterate through the list in both directions and from any point.
In real life link lists are usually used to make it possible to sort them or to add elements to the list at any place, which you cannot easily do with simpler data structures like arrays.

For example, to add your new friend Sarah to the list right behind John, you could do the following:

  current = friends;
  struct friendList sarah;
  sarah.name = "Sarah";
  sarah.next = current->next;
  current->next = &sarah;

As an exercise try adding the snippet above to the program and let the same while-loop run again. You will see that without any changes to the loop the output shows Sarah has joined the list and is at the correct position.

Fixing what AOL broke (fixing ICQ logon in Kubuntu Dapper)

2006-07-13T21:33:00.000+02:00

Recently (around the July 13) AOL made some changes the software running the ICQ servers, making it impossible for users of old and alternative clients to log into (and therefore use) ICQ.

If you are running Kopete, a fix for this problem is already in SVN (where Kopete is developed). Unfortunatelly there is no new version of Kopete and Kubuntu has not (yet?) distributed updated packages either.

There is an unofficial package by djclue917 up on kde-apps.org.

To fix your setup (and update your version of Kopete as an added benefit), follow these steps:
1) Download the packages kopete_3.5.3+kopete0.12.0-0.4_i386.deb and libortp_0.7.1-0_i386.deb from kde-apps.org to your Desktop.
2) Open a Konsole window (where you can type commands). Don't panic, it's not hard!
Hit alt-f2, type "konsole" in the window that appears and hit enter.
3) In the window that appears type the following series of commands (written in bold italics):
a) cd Desktop (change to your Desktop directory, where you downloaded the package to)
b) sudo dpkg -i libortp* (tell Kubuntu to install the package Kopete needs to be installed)
c) sudo dpkg -i kopete* (tell Kubuntu to install a new version of Kopete)
4) Done! You can close Konsole now if everything went according to plan. If there was a problem, rest assured, it is very unlikely that his broke anything.

Remember: Get yourself an account with jabber.org. Jabber is a free instant messaging protocol (and much more), which guarantees that you won't have to put up with the bullshit of arrogant companies again!

irrepressible.info

2006-07-10T15:51:00.000+02:00

irrepressible.info is a campaign by the British section of ai:

Amnesty International, with the support of The Observer, is launching a campaign to show that online or offline the human voice and human rights are impossible to repress.

Help spread the word!

Update

2006-03-23T13:10:00.000+01:00

I wonder how many people will notice that this blog is about six months late. Oh well.

Greece was great. We actually ended up doing quite a bit of travelling. Here are a few impressions from the trip:

First stop was Naxos, where we stayed the longest while Daniel's mother and grandmother were there.
Naxos is a very nice island, which is very much stamped by tourism. We had a good time there, lying at the beach, driving around the rather large island for a day and generally doing all kinds of vacation stuff.

After Naxos we went to Mykonos. Forget what I said about Naxos being stamped by tourism. That's nothing compared to Mykonos. Don't get me wrong though: There is a reason everyone and his parrot want to go to Mykonos: Its a small and very greek island and it is close to Delos, where we went next.

Delos is a mess! Wasn't always like that though: In the good old times it used to be an Apollon sanctuary with a very striving city around it. It's still in very good shape for having been destroyed and then lying there for many centuries, which is why so many people go there, I guess. Impressive place.

The next day we departed for Syros. This place was quite different from the other islands we visited. It is much less focused on tourism and not as expensive as Mykonos. Unfortunatelly we could only stay there for less than two full days, but I enjoyed being there a lot.
The time we spent there was not the most exciting (we went to a very quiet beach), but it was a great place for getting a feeling of having been on vacation. A good last stop for our trip.

Holidays in Greece

2005-08-27T19:34:00.000+02:00

I am going to Greece!!! Yeeha :)

This morning Daniel and I booked our flights. We are leaving on the 14th and are going to stay there until the 23rd. It's going to be lots of fun. I hope to travel a lot inside Greece as well (so I can say I have been there). Adventure here we come.

Well, I hope everyone else is having a good time as well. I know I will.

P.S.: I completely forgot I chose this complete nerd-title for my blog. Need to grow up some time :)

So this is it, huh?

2004-05-12T18:51:00.000+02:00

Hi everyone,
I have just opened this blog, because I have found it a really cool idea. In fact, I see myself participating in more and more online communities.
I am not quite sure, if this is a good thing? On the one hand, of course, it lets me socialize with people who have similar interests as I.
I guess and hope, time will tell. Anyways, this is certainly a good way of making public the stuff I want people to see. Pretty soon I will even know what that could be :)
Anyways, this is it!

Stay tuned for what I am going to do with this great tool,
- drowstar