Pimp my Nepomuk

Being both a really old KDE user and a semantic desktop partisan at the same time, I am, of course, keeping my eye on the progress in Nepomuk project.  It was apparently close to my old dream of a tagging framework supported natively and consistently across the whole desktop environment, so I highly appreciated this effort and it was nice to hear that Nepomuk would be officially included into KDE – my desktop of choice for many years.

Unfortunately, the experience was rather disappointing. It’s turned out to be painfully slow, not only slow by itself, but being a brake for overall desktop navigation. Even hovering the cursor over files and folders in Dolphin made Nepomuk process to eat above 50% of CPU time and caused annoying delays. The simple operations like assigning a tag to a file took seconds, the responsiveness which is obviously inappropriate for a real-world desktop system. It thus was turned off in a hope that the things would be improved in future versions (I was confused a bit by how it might appear in the production release, but, frankly, early KDE 4 was full of much more disastrous things). Since then, I checked it after every KDE version upgrade, but there was no visible progress in performance, alas.

It was really good news – the author of the post above argues that the performance issues are in fact, caused by a storage backend which Soprano, an RDF framework underlying to Nepomuk, uses to keep RDF data. By default, it’s shipped with Redland (aka librdf), an RDF database library written in C. Luckily, the backend is easily replaceable and it’s worth to try to install a faster alternative seeking for a better performance. The author recommends Sesame2 – a 100% pure Java RDF framework which works (surprisingly for many, I think – but not for me!) much faster than it’s native code counterpart.

I tested Nepomuk with Sesame and convinced that now it works really faster – as it should, in fact. There is of course, a room for improvements in Nepomuk to be a real end-user tool – e.g. a tag navigation interface without which the tags are rather useless, but its another story. At least, the performance is not a blocker anymore, so Nepomuk now is enabled in my KDE all the time.

For Kubuntu users: How-to

I tested the Sesame2 backend for Nepomuk on Kubuntu 9.04 Jaunty Jackalope, KDE 4.3.0 and Sun JRE 6 (I have no idea if it works with GNU Java, but you can give it a try).

1. Install soprano-backend-sesame package (sudo apt-get install soprano-backend-sesame)
2. Make a symlink from $JAVA_HOME/jre/lib/i386/client/libjvm.so in the /usr/lib directory
3. Restart Nepomuk server

Check if Sesame2 backend is used now:

qdbus org.kde.NepomukStorage /nepomukstorage usedSopranoBackend

It should answer “sesame2“. If it still answers “redland“, something was wrong. You may need also to replace the value “redland” to “sesame2” in ~/.kde/share/config/nepomukserverrc file manually and restart Nepomuk again.

As I skipped 7.10 “Gutsy” release, I preferred to do a fresh install from Hardy Heron LiveCD instead of two-step “Feisty » Gutsy » Hardy” network upgrade. I installed Hardy right into the existing Feisty partition replacing the old installation. Separate home partition was left untouched to keep all my personal preferences and data in new system.

It took ~25 minutes from booting the installation CD to logging into a working system.

Unsurprisingly good

No doubts, Kubuntu developers and packagers spent this year not for nothing. In general, Hardy is a better system than previous Kubuntu versions. It loads essentially faster and many little annoyances was fixed. Good job!

Hardware compatibility

Ubuntu systems are known to have great hardware support. As far back as 7.04 version, it recognized my hardware configuration including such exotic devices like DVB-card and CDMA modem without any problem. The only trouble was my HP LaserJet 1020 printer for which I had to install and configure foo2zjs package manually. So, it was nice to see it’s fixed in Hardy; now my printer is supported via native HP open source drivers and working out the box.

A bad surprise was that Hardy could not detect my monitor automatically and set failsafe 640×480 resolution as a result. It was strange as it was no problem with it in Feisty. Even when I’ve clicked “Detect monitor” button manually, it detected it as default “plug-n-play” monitor. I had to remember a model of my monitor and select it from the list. Not a big deal, but a pity though.

KDE 4

Looking great and nice but apparently, a lot of work is still needed there. Crashes are not unusual everywhere and the single Plasma panel looks more like a prototype than a part of a desktop for the real world. It’s half-baked, almost not configurable and I cannot setup a desktop I need for my tasks (IMHO, an essential fault for any Linux software).

So, I’m use the “solid rock” KDE 3.5.9 as a primary desktop environment for work and sometimes switch to KDE 4 just to get a feeling of  bleeding edge desktop technologies.

Grumbles

• Dolphin – I already grumbled at it and I still have no idea what are the reasons to have yet another desktop file manager. Konqueror was a default KDE file manager for years and a whole generation of Linux users grew up with an idea of this software inspired by Konq. Dolphin’s user experience is different in many ways and totally unusual for me (and I think, I’m not alone). No matter if Dolphin is good or bad, I need Konqueror, thanks!
• Samba didn’t see my home network after installation. And I was unsuccesfull to fix it using configuration GUI in KDE Control Center (though I’m not a sysadmin guru and might miss some options). Finally I managed to configure the network by manual editing ‘smb.conf’ taken file from a backup of previous installation. Maybe it sounds trivial for experienced network administrators, however I remember that I didn’t edit any configs to get Samba working in Kubuntu 7.04.

We assuming Memoranda is already installed on your Linux system (that is, ZIP archive is unpacked) into, say, “/opt/memoranda” directory. To be sure that the executables have proper permissions, run:

chmod 755 /opt/memoranda/memoranda.sh
chmod 755 /opt/memoranda/lib/kde/systray4jd

Creating a desktop shortcut

1. Right-click anywhere on your desktop, select “Create New->Link to application…” and enter “Memoranda”.
2. Go to “Application” tab and enter into the fields
   Command: /opt/memoranda/memoranda.sh
   Work path: /opt/memoranda
3. Go back to “General” tab and click the icon. In the icon dialog box select “Other icons”, “Browse” and point it to ‘/opt/memoranda/lib/icons/memoranda48x48.png’
4. Press “Ok”

To put new shortcut into KDE panel also, simply drag-n-drop it from the desktop.

Creating a menu item

1. Right click the desktop shortcut created before and select “Copy”
2. Open Konqueror and navigate to “/home/you/.kde/share/applnk” directory. Tip: if Konqueror does not display “.kde” directory, select “Show hidden files” in its “View” menu.
3. Create new subdirectory (say, “Utilites”, “Office” or “PIM”) or go into an existing one. These subdirectories are the sections of your K menu. Right click anywhere in this directory and select “Paste file”.

Done.

A lot of people know about Beryl due to its show-stopper feature – a 3D-dimensional “Desktop cube” where each edge of it is a separate desktop. You can place the windows on separate edges and rotate the cube to change the current desktop. For those who are not on Linux, I should say that multiple desktops is a common practice in Linux desktop environments, and Beryl’s cube is just a metaphor for to visualise that old concept.

What’s good

• Switching between windows using their scaled live previews (like in OS X) is great.

• It is an eye-candy. True transparency and realistic shadows effects make the windows looking awesome.

• It is very customizable. You can spend hours to explore all options and adjust Beryl settings by your taste.
• A rich set of customizable window decoration themes.
• Zooming the screen is amusing and pays for accessibility.

What’s bad

• Beryl didn’t work out of the box with ATI Radeon graphic card. This howto helped to fix the problem.
• Java applications do not display correctly. See the solution.
• I could not find an option to display taskbar icons only for a current desktop, as I used to do in default KDE mode.
• There is a sort of conflict of Beryl and default KDE desktop switcher (“Pager”). It is better to turn it off when using Beryl.

[Upd: Unfortunately, the bad things list is growing]

• Beryl makes SuperKaramba widgets invisible if SuperKaramba is started first. See a trick with autostarting order.
• Beryl prevents the system to awake from Hibernate or Suspend mode. The solution is to kill Beryl before hibernating and to start it automatically on awakening.

[/Upd]
Resume: Install it if you care about the desktop aesthetics or want to amaze your Windows friends.

I have no idea what is it doing in Windows, but the greatest advantage of this key in KDE is that it does nothing by default. Also, this is a modifier key (like Shift, Ctrl or Alt), so it can be used for setting a lot of custom keyboard shortcuts. While the most of “Ctrl+” and “Alt+” combinations are usually reserved by applications, “Win+” is vacant and ideal for defining various global system shortcuts.

There is my experience of using Win-key combinations:

“Win” is for the windows, I think

The most of shortcuts are related to the windows and desktop management actions:

• Win+Return maximizes a window and Ctrl+Win+Return makes it full-screen.
• Win+Backspace minimizes a window.
• Win+Esc closes a window.
• Win+Space shows desktop (minimizes all windows).
• Win+number (Win+1, Win+2…) switches to the given desktop. Also, Win+Up/Down switches to the previous or next desktop (I use vertical desktop pager).
• Ctrl+Win+number and Ctrl+Win+Up/Down moves active window to the specified desktop.
• Win+Menu shows a list of all windows on all desktops.

AmaroK

Win-key in combination with additional numeric keypad (aka “grey keys”) is used for controlling AmaroK audioplayer.

• Win+GrayInsert is for play/pause.
• Win+GrayPlus and Win+GrayMinus manage sound volume and Win+GrayMultiply mutes volume.
• Win+GrayLeft/Win+GrayRight switches the tracks

Launching the applications

Combinations of the Win-key with alphabetic keys are used for quick launching the most needed applications and utilities. There are lot of them and it makes no sense to enumerate them here – every user has her own list of preferred software.

Win-key is a good thing, whatever a logo is there. Finally, everyone might put a penguin or K-gear sticker on it :-)

Instead of developing some Yet Another Big Animated Clock, I decided to write something practical. What I’d like to have is a widget which would ask my e-mail client (KMail) for the headers of the latest unread messages to show them on the desktop.

Two buttons in the top bar are for checking new mail from a server and for opening new message window. Clicking on the top bar somewhere else will open main KMail window.

SuperKaramba comes with a Python API, so everyone who is familiar with Pyton basics can write her own widget (aka “theme”) as a Python script. In my case, I wrote two scripts – one is for widget output and another as a simple KMail folder API wrapped around DCOP calls.

Patching KMail

There was a major problem – KMail DCOP interface had no a call to get unread message headers; only getting a number of them is possible. So I have had to dig into the KMail sourcecode (my current version is 1.9.4) for to add new function to FolderIFace interface (folderIface.cpp).

kmail.diff:

diff kmail/folderIface.cpp kmail_patched/folderIface.cpp
147a148,162
> QStringList
> FolderIface::unreadMessageHeaders()
> {
>      QStringList msgs;
>      mFolder->open();
>      for( int i = 0; i < mFolder->count(); i++) {
>          KMMsgBase *msg = mFolder->getMsgBase(i);
> 	     if (msg->isNew() || msg->isUnread()) {
> 	       msgs.append(msg->fromStrip() + "\\t" + msg->subject() + "\\t" + msg->dateStr());
>          }
>      }
>      mFolder->close();
>      return msgs;
> }
>
diff kmail/folderIface.h kmail_patched/folderIface.h
61c61,62
<
---
>     virtual QStringList unreadMessageHeaders();
>

After adding new function header to folderIface.h and rebuilding KMail, new DCOP call “kmail FolderIface unreadMessageHeaders” became available to get the list of message headers in format “From/Subject/Date” divided by tab characters (\t).

Sourcecode

skkmail.py:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

import karamba
import kmail
 
text = []
images = []
clickAreas = []
 
# Define widget area width here (height is adjusted automatically)
s_width = 350
 
# If an actual height is above this value, a widget area will be clipped
maxHeight = 600
 
# Margins inside a widget area
s_x = 10
s_y = 10
 
def _update(widget):
    global text, images, clickAreas, s_width, s_x, s_y
    x_gap = 10
    y_gap = 4
 
    s_height = 14
    s_col1 = (s_width-x_gap)*0.66
    s_col2 = s_width
    s_col3 = (s_width-x_gap-16)*0.33
 
    folderFont = "Franklin Gothic Medium"
    folderFontSize = 14
 
    for t in text:
        try:
          karamba.deleteText(widget, t)
        except:
          pass
    for i in images:
        try:
          karamba.deleteImage(widget, i)
        except:
          pass
    for c in clickAreas:
        try:
          karamba.removeClickArea(widget, c)
        except:
          pass
    text = []
    images = []
    clickAreas = []
    folders = kmail.getFolders()
    y = s_y + 25;
    for f in folders:
        msgs = f.unreadMessages
        if (len(msgs) > 0):
            y0 = y
            t = karamba.createText(widget, s_x+15, y, s_width, s_height,
                f.name+" ("+str(len(msgs))+")")
            karamba.changeTextFont(widget, t, folderFont)
            karamba.changeTextSize(widget, t, folderFontSize)
            text.append(t)
            images.append(karamba.createImage(widget, s_x-10, y, "icons/folder.png"))
            y = y + s_height + y_gap*2 +10
            for m in msgs:
                t = karamba.createText(widget, s_x+20, y, s_col1, s_height, m[0])
                text.append(t)
                t = karamba.createText(widget, s_x, y+s_height, s_col2, s_height, m[1])
                text.append(t)
                t = karamba.createText(widget, s_x+20+s_col1+x_gap, y, s_col3, s_height, m[2])
                karamba.setTextAlign(widget, t, "RIGHT")
                text.append(t)
                images.append(karamba.createImage(widget, s_x, y, "icons/mail.png"))
                y = y + s_height*2 + y_gap*2
            clickAreas.append(karamba.createClickArea(widget, s_x-10, y0, s_width, y-y0,
                "dcop kmail KMailIface selectFolder "+f.path+" && kmail"))
            y = y + y_gap*2
    if (y < maxHeight - 20):
        karamba.resizeWidget(widget, s_width+s_x*2, y+20)
 
#this is called when you widget is initialized
def initWidget(widget):
    bgImage = karamba.createBackgroundImage(widget, 0, 5, "icons/bg.png")
    karamba.resizeImage(widget, bgImage, s_width+s_x*2, 20)
    logo = karamba.createImage(widget, 0, 0, "icons/kmail.png")
    t = karamba.createText(widget, 35, 5, 100, 20, "new mail")
    karamba.changeTextFont(widget, t, "Franklin Gothic Medium")
    karamba.changeTextSize(widget, t, 16)
    karamba.createClickArea(widget, 0, 0, 100, 30, "kmail")
    karamba.createImage(widget, s_width+s_x*2-18, 7, "icons/mail_get.png")
    karamba.createClickArea(widget, s_width+s_x*2-18, 7, 16, 16, "dcop kmail KMailIface checkMail")
    karamba.createImage(widget, s_width+s_x*2-40, 7, "icons/mail_new.png")
    karamba.createClickArea(widget, s_width+s_x*2-40, 7, 16, 16,
        "dcop kmail KMailIface openComposer '' '' '' '' '' ''")
    _update(widget)
 
#this is called everytime your widget is updated
#the update inverval is specified in the .theme file
def widgetUpdated(widget):
    _update(widget)
 
#This gets called everytime our widget is clicked.
# Middle button click forces to check new mail
def widgetClicked(widget, x, y, button):
    if (button == 2):
        kmail.dcopCall("kmail KMailIface checkMail")

kmail.py:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

#!/usr/bin/python
 
import os, subprocess, string
 
def dcopCall(call):
  cmd = "dcop "+call
  pipe = subprocess.Popen(cmd, shell=True, bufsize=1024, stdout=subprocess.PIPE).stdout
  res = pipe.read()
  pipe.close()
  return res
 
class Folder:
  path = ""
  name = ""
  unreadCount = 0
  unreadMessages = []
 
  def __init__(self, path):
    dcopCall("kmail KMailIface getFolder "+path)
    self.path = path
    self.unreadMessages = self.getUnreadMessages()
 
  def getUnreadMessages(self):
    r = dcopCall("kmail FolderIface unreadMessageHeaders")
    ss = string.split(r, "\\n")
    msg = []
    for s in ss:
        if (len(s) > 0):
            msg.append(string.split(s, "\\t"))
    unreadCount = len(msg)
    if (unreadCount > 0):
        self.name = string.strip(dcopCall("kmail FolderIface displayName"))
    msg.reverse()
    return msg
 
def getFolders():
    r = dcopCall("kmail KMailIface folderList")
    folders = []
    for f in string.split(r, "\\n"):
        folders.append(Folder(f))
    return folders

skkmail.theme:

1
2
3

# you can change initial widget position, area size and updatin interval (default = 1min)
karamba x=100 y=100 w=400 h=200 interval=60000
defaultfont font="Franklin Gothic Book" fontsize=12 color=230,230,230

All code above is GPL‘ed.

BasKet acts as a persistent clipboard manager for various data types (plain text, rich text, images, links, files and application shortcuts). You can create few containers (baskets) inside it to organize your data items as you wish. You can copy (or drag-n-drop) the items into the baskets from applications and paste them back from the baskets. In my case, I set the global keyboard shortcuts “Win+C” for to copy a selected item to a current basket and “Win+V” to paste the latest copied item (from the top of a current basket’s stack) into the current selection (like conventional Crtl+C/Ctrl+V for default system clipboard).

Moreover, BasKet can track all your operations with system clipboard and store the whole clipboard history in special “Clipboard manager” basket, if you would create it. Though, I found this feature not very useful – I don’t want to store all data passing through my clipboard for ages and bother to clear the overblowed stack. So, I used to press Ctrl+C/Ctrl+V when I want to use the default system clipboard and Win+C/Win+V for important things which I’d like to save for the future.

What is good

• Convenient storage for small important data items – quick as the system clipboard but persistent and structured.
• Is not limited by text data types. The specific types of items are opened with appropriate programs (for instance, double-clicking the email address opens new message window).
• Inline editing the basket items
• Along with copying existing data from applications, it is possible to create new items and fill them in place – this feature is very useful for taking the text notes.
• Quick search the items
• Special basket type for mirroring the files in selected folders.
• Global shortcuts support
• Transparent and inobtrusive – no saving/loading operations, lives in the system tray, accessible by one click and hides automatically when inactive.

What is bad

• There is a bug with Firefox – when a piece of text is copied from a web-page to the basket, a link is inserted instead of the text.
• Every time when items are deleted from the basket, the annoying “are-u-sure?” dialog is appeared. At least, it should contain a checkbox to not asking me anymore, I believe.
• Occasional crashes by unknown reasons.

For years I used no special software for digital photography and photoalbums management. Just command-line gphoto2, GIMP and usual filemanager in preview mode were enough, or at least I thought so. Few months ago I decided to scan my old photo archives to have them in digital form and was drowned quickly in the thousands of shots many of which needed for some correction. And new shots from my digital camera are going on. So, once I felt I’ve lost control on my photo collection.

I looked for a software which could help me and found digiKam – a great photo organizer, editor and more.

Acquiring photos

digiKam works directly with a digital camera. In fact, it depends on gPhoto framework, so you need to have gphoto2 installed and working (if you are a photographer on Linux, you probably already have it). digiKam provides an easy to use interface to the camera that enables you to browse, preview, download and delete your images.

Camera interface

For those who used to download photos with gphoto2 from console, this new experience is really impressive.

digiKam also can acquire images directly from a scanner (through SANE interface) and grab the screenshots. Of course, you can also import your existing photo directories into the digiKam database.

Organizing

An essential part of digiKam what makes it a really great app is its photo organizing functionality. It makes use of a database to store tags, comments and other metadata related to images and albums. So, you can easily find, browse and sort images in your collection.

The photo browser supports faceted navigation – you can explore your collection by albums (just the folders), tags or dates. It is possible to assign a number of tags for each photo which makes its finding extremely easy (if you are a Flickr user, you know what help the tags make).

    
Faceted navigation by tags and dates

[added]
The key difference from the Flickr tags (not too obvious) is that the tags can be organized hierarchically – they are rather taxonomical categories than usual labels. So you can set, say the “Roses” tag as a child of “Flowers”, and “Flowers” in turn, as a child of “Nature”. Then, all your “Roses” photos will automatically be assigned to “Flowers” and “Nature” which makes a great help in further navigation

The advanced search functionality enables to select the shots which match the specific criteria (it looks like the queries to database). You can save your queries to quickly repeat them in future.

There is a bit of fantastics – searching images by similarity. It makes use of an intellectual algorithm of “fingerprints” to compare images and find their “optical similarities”. You can adjust a treshold level to find more or less similar images – from the exact duplicates to the “slightly resembling” shots (for instance, from the same session).

It supposes these shots are similar. I think so too :-)

Editing: Goodbye, GIMP?

digiKam integrates an advanced image viewer/editor (ShowFoto) which also can be used as a standalone application. Along with basic image processing functionality (cropping, resizing, rotating, color correction) it supports a plugins architecture for to add new tools and image effects. digiKam plugins are developed by another project and should be downloaded and installed separately. Current distribution includes a variety (about 30) of plugins including correction filters, funny artistic and distortion effects, adding borders and text to images and so on.

The most interesting and useful tools for photographers are, of course, those for improving image quality. digiKam provides a rich set of those tools (both embedded and pluggable) – from basic brightness/contrast/color adjustments to sophisticated photo restoration utilities. They are collected in a “Fix” menu of the image editor:

I think, even a professional photographer will be happy with that toolkit. All filters have the live previews and work surprisingly quickly. In general, digiKam seems to work much more faster in comparison with monsters like GIMP or Photoshop.

There is a magic feature which really impressed me – an “auto-correction”. It is unbelievable, but by a single mouse click you can turn your ugly dark or low-contrast photo into an eye-candy. Just take a look:

Auto-correction: before and after

digiKam makes use of the KIPI plugin framework which aimed to be a common shared plugin infrastructure for KDE graphic apps. The current set of KIPI plugins enables very useful features of batch image processing. You can do resizing, converting, adjustment, applying filters and effects on the selected photos or even on the whole directories just by few mouse clicks.

Sharing and exporting

Yes, digiKam does flickring! Uploading photos to there is a snap – just choose images you want to upload and (optionally) enter the Flickr tags and privacy options. At very first time it will open your default browser for logging in to Flickr. A very useful feature is that it can resize the uploading shots on the fly, so you don’t need to prepare the special low-res variants of your original shots. For instance, I usually take the hi-res shots of 1600×1200 or even more, and reduce them for Flickr to 640×480, so automatical scaling makes a great help for me.

digiKam also can build HTML photo galleries, burn CD/DVD with your photo collections (via external b3d software) and of course, print your photos.

A really cool and handy app which seems to have no competitors in Linux world for now. Recommended for all Linux photographers – profies and amateurs like me.