There is however, a lot of important stuff I’m backing up regularly: projects, documents, Basket notes, emails and so on. A long ago, I have developed a custom automated backup procedure that has been greatly improved with the help of a dedicated server in my home network. The solution is simple, based on standard Linux tools and works perfectly for me.

On the desktop

I have a special directory in my home space, ~/.toBackup, that contains symbolic links to the places I want to include into the backup. A tiny script is called by cron every hour to loop over this list and send incremental updates to the server using rsync:

#! /bin/sh
 
TO_BACKUP=$HOME/.toBackup
REMOTE=192.168.0.100::backup
 
for D in $TO_BACKUP/* do
  rsync -avzL $D $REMOTE
done

The target directory (“backup“) of the server’s rsync daemon is shared via NFS, so I always have a mirror of my things one hour back maximum.

On the server

Every night, the server runs a cron job to copy the contents of the backup directory to another hard drive, thus making a daily snapshot of my work. If something horrible would happen with both the original data and with the mirror, there is a yesterday’s copy to restore.

#! /bin/sh
 
BACKUP=/mnt/disk1/backup
DAILY_BACKUP=/mnt/disk2/backup-daily
 
rm -rf $DAILY_BACKUP
mkdir $DAILY_BACKUP
cp -R $BACKUP/* $DAILY_BACKUP

And, finally, once a week (every Friday), yet another cron job packages the latest daily backup into tar.gz archives and puts them into new directory, named after the current date:

#! /bin/sh
 
DAILY_BACKUP=/mnt/disk2/backup-daily
WEEKLY_BACKUP=/mnt/disk2/backup-weekly/`date +%Y-%m-%d
 
mkdir $WEEKLY_BACKUP
cd $DAILY_BACKUP
for D in ./* do
   tar czhf $WEEKLY_BACKUP/$D.tgz $D
done

All what I have to do manually is to burn the DVD’s with latest archives once in a couple of months and clean up the weekly backups directory (though it is possible to automate the latter too).

RDFBean interfaces and dynamic proxying

Along with traditional JavaBean-like persisting technique using RDFBean classes, the version 2.0 introduces new approach to object-RDF mapping: RDFBean interfaces.

It works simply: you define an interface of your domain model object and annotate it just like an RDFBean class:

@RDFNamespaces("foaf = http://xmlns.com/foaf/0.1/")
@RDFBean("foaf:Person")
public interface IPerson {
 
    @RDFSubject
    String getId();
 
    @RDF("foaf:name")
    String getName();
 
    void setName(String name);
 
    @RDF("foaf:mbox")
    String getEmail();
 
    void setEmail(String email);
}

Then you instantiate the RDFBeanManager (was RDFBinding in RDFBeans 1.x) upon an RDF2Go Model and create a dynamic proxy object with your interface:

ModelFactory modelFactory = RDF2Go.getModelFactory();
Model model = modelFactory.createModel();
model.open();        
RDFBeanManager manager = new RDFBeanManager(model);
IPerson person = manager.create("http://example.com/persons/jdoe", IPerson.class)

The methods of this proxy object are directed immediately to the underlying RDF triples, so that

person.setName("John Doe");
person.setEmail("john@example.com");

will cause adding the statements to the model:

<http://example.com/persons/jdoe> a <http://xmlns.com/foaf/0.1/Person> ;
	<http://xmlns.com/foaf/0.1/name> "John Doe" ;
	<http://xmlns.com/foaf/0.1/mbox> "john@example.com" ;

Similarly, the getter methods will return values retrieved directly from these statements.

RDFBean annotations

The annotations scheme has changed, so the old classes will be incompatible with RDFBeans 2.0. As you can see in the example above, @RDF annotation is now applied to the getter methods but not to the field declaration like in the previous versions.

You also can notice new annotation, @RDFNamespaces, which defines a list of URI prefixes to be used in other RDFBean annotations declared in a given class or interface. This includes class and property URIs, as well as RDFBean identifiers:

@RDFNamespaces({ 
	"foaf = http://xmlns.com/foaf/0.1/",
	"persons = http://example.com/persons/" 
})
@RDFBean("foaf:Person")
public interface IPerson {
 
	@RDFSubject(prefix = "persons:")
	String getId();
...

Annotations are now inherited from superclasses and interfaces that makes the RDFBeans markup compatible with complex domain-specific object models. See how the Thing, Agent and Person classes of the FOAF example are organized to mimic the owl:Thing → foaf:Agent → foaf:Person subclassing in RDF-Schema.

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.

Working on my current project, I had to deal with a rich object model which is persisted into a RDF triple-store, so quickly I stuck in writing the object-triples translation code. I thought it would be a good idea to automate this by providing a simple data binding framework for transparent mapping of the Java objects to RDF (like Hibernate and other tools does so for SQL or XML) with the following requirements in mind:

• It should be easy to make existing classes compatible with the framework with minimum modifications. This should not affect the business object model (no special interfaces and superclasses) and should not interfere with common JavaBeans-oriented frameworks (like Spring, etc.). Any JavaBean-like POJO class can be RDF-serializable just with few Java annotations added.
• No predefined ontologies and RDF-schemas are required.
• Class information is stored in the RDF model for transparent instantiation of the objects.
• Cascade binding for related objects should be supported.
• Basic Java Collection types should be supported.

This framework is implemented using Java annotations and Reflection APIs and works with major RDF triple-stores (via RDF2GO abstraction layer).

RDF Beans

In order to be mapped to an RDF resource, a Java class must obey certain conventions:

• The class must have a public default (no-argument) constructor.
• The class declaration must have a @RDFBean annotation to associate it with appropriate RDFS class:

  @RDFBean("http://xmlns.com/foaf/0.1/Person")
  public class Person { ...

See also: A RDFBean class example.

Properties

The class properties must be accessible using standard getter and setter methods. The properties are mapped to their RDF counterparts with @RDF annotations:

@RDF("http://xmlns.com/foaf/0.1/name")
String name;
 
@RDF("http://xmlns.com/foaf/0.1/mbox")
String email;
 
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public String getEmail() { return email; }
public void setEmail(String email) { this.email = email; }

The argument of @RDF is a valid URI of a RDF property (predicate) in a domain of the specified RDFS class. The following types of properties are permitted:

• A Literal (String, Boolean, Date, Integer, Float, Double, Long, Short, Byte, java.net.URI)
• Another RDFBean class
• A Java Collection (List or Set) of Literals or RDFBeans

Literal values are represented in RDF with corresponding XML-Schema datatypes and Collections with RDF Containers (rdf:Bag or rdf:Seq depending on a Collection type). References to other RDFBean objects will be kept as RDF object properties and the values will be represented as separate RDF resources.

RDF subject

There must be a special String property to hold an unique URI value to identify the RDF resource (the subject URI). It must be accessible with getter and setter methods and be marked with @RDFSubject annotation:

@RDFSubject
String id;

The property value must be a valid absolute URI, otherwise you can use the prefix argument for a common prefix to construct URIs from arbitrary String identifiers:

@RDFSubject(prefix="http://example.com/persons#")
String id;

Data Binding

RDFBeans data binding framework is based on RDF2Go API which creates an abstraction layer above physical RDF storages. It makes an RDF model independent from specific RDF frameworks (such as Sesame and Jena), thus it can work with any, if a RDF2Go adapter is implemented. The data binding is performed using single RDFBinding class, which is initialized with existing RDF2Go model:

import org.cyberborean.rdfbeans.RDFBinding;
import org.ontoware.rdf2go.RDF2Go;
import org.ontoware.rdf2go.model.Model;
...
Model model = RDF2Go.getModelFactory().createModel();
model.open();
RDFBinding binding = new RDFBinding(model);

The marshal method converts a Java object into a RDF resource in the model:

Person person = new Person();
person.setId("http://example.com/staff#johndoe");
person.setName("John Doe");
person.setEmail("johndoe@example.com");
...
binding.marshal(person);

This code will create a set of RDF statements representing the properties of the given object in the model:

<http://example.com/staff#johndoe> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://xmlns.com/foaf/0.1/Person> .
<http://example.com/staff#johndoe> <http://xmlns.com/foaf/0.1/name> "John Doe"^^<http://www.w3.org/2001/XMLSchema#string> .
<http://example.com/staff#johndoe> <http://xmlns.com/foaf/0.1/mbox> "johndoe@example.com"^^<http://www.w3.org/2001/XMLSchema#string> .

Additionally, it adds a special statement to associate the RDFS class with Java:

<http://xmlns.com/foaf/0.1/Person> <http://cyberborean.org/rdfbeans/1.0/bindingClass> "com.example.Person" .

The marshal method inspects the properties which link the object with other RDFBeans and initiates their cascade binding to the RDF model, thus simplifying the development and ensuring referential integrity of the RDFBeans.

To reconstruct a Java object from RDF model, there is unmarshal method:

import org.ontoware.rdf2go.model.node.URI;
...
URI subject = model.createURI("http://example.com/staff#johndoe");
Person person = (Person) binding.unmarshal(subject);

The method creates new instance of the Java class (defined by http://cyberborean.org/rdfbeans/1.0/bindingClass property) and fill the properties with data from the RDF model. If a property holds a reference to another RDFBean, it results into cascade unmarshalling of related objects, thus restoring the original object model.

Code

• RDFBeans JAR and source code
• Javadocs

[Update: 2009-08-04]

RDFBeans framework is released on SourceForge: http://rdfbeans.sourceforge.net. The API has been changed, please check the documentation and Javadocs for details.

How it works

It’s simple and easy. You press and release a special key called “Compose” (or, “Multi_key”) and then, two or three character keys – a mnemonic ASCII sequence identifies a Unicode character you want to see. For example, the sequence of letter keys “o” and “c” produces the copyright symbol (©) and it is much easier to remember than Unicode 00A9.

Where is my Compose key?

There is no Compose key defined in X.org by default. Before using it, you need to do some configuration to tell X which key you want to use as a Compose. Usually, right “Win” (“Super”) key is a good choice.

In KDE, open “Keyboard layout” configuration panel (Control Center → Regional & Accessibility → Keyboard Layout) and select “Enable xkb options” checkbox on “Xkb options” tab. Then scroll the options list down to “Compose key position” section and select a checkbox for a key you want to use as a Compose.

Alternatively, you can edit /etc/X11/Xorg.conf (as a root) to add the line to the keyboard section:

Option "XkbOptions"  "compose:rwin"

After configuration is done, restart X (simply hit Ctrl+Alt+Backspace).

Note that you’ll need Unicode fonts installed (to see all exotic characters) and a default locale with UTF-8 support (e.g. en_US.UTF-8 for US English). This seems to be the default in modern Linux distributions.

Predefined characters

Diacritics, ligatures and currency symbols

Entering extended latin letters with diacritic marks follows the pattern:

Compose diacritic_character letter

The diacritic characters are:

• ' (apostrophe) ⇒ A letter with acute (Áá)
• " (double quote) ⇒ A letter with diaeresis (Ää)
• ` (grave) ⇒ A letter with grave (Àà)
• _ (underscore) ⇒ A letter with macron (Āā)
• ^ (circumflex) ⇒ A letter with circumflex (Ââ)
• ~ (tilde) ⇒ A letter with tilde (Ãã)
• , (comma) ⇒ A letter with cedilla (Çç)
• . (period) ⇒ A letter with dot above (Ȧȧ)
• ! (exclamation) ⇒ A letter with dot below (Ạạ)
• ? (question) ⇒ A letter with hook (Ảả)
• / (slash), - (minus) ⇒ A letter with stroke (Øø, Đđ)
• ; (semicolon) ⇒ A letter with ogonek (Ąą)
• + (plus) ⇒ A letter with horn (Ơơ)
• = (equals) ⇒ A letter with double acute (Őő)
• o ⇒ A letter with ring (Åå)
• c ⇒ A letter with caron (Ǎǎ)
• b ⇒ A letter with breve (Ăă)

Some characters may be combined to create mixed diacritical marks, e.g. Compose _ " a produces ǟ (‘a’ with diaeresis and macron), and so on.

Other letters and ligatures:

• Compose A/a E/e ⇒ Æ/æ
• Compose O/o E/e ⇒ Œ/œ
• Compose T/t H/h ⇒ Þ/þ
• Compose N/n G/g ⇒ Ŋ/ŋ
• Compose s s ⇒ ß
• Compose e e ⇒ ə

Currency symbols:

• Compose c / ⇒ ¢
• Compose C = ⇒ €
• Compose L = ⇒ ₤
• Compose F r ⇒ ₣
• Compose Y = ⇒ ¥
• Compose o x ⇒ ¤

Punctuation marks and other symbols

Quotation marks:

• Compose , ' ⇒ ‚
• Compose , " ⇒ „
• Compose < ' ⇒ ‘
• Compose > ' ⇒ ’
• Compose < " ⇒ “
• Compose > " ⇒ ”
• Compose < < ⇒ «
• Compose > > ⇒ »
• Compose . < ⇒ ‹
• Compose . > ⇒ ›

Others:

• Compose . . ⇒ ·
• Compose - - - ⇒ — (em-dash)
• Compose - - . ⇒ – (en-dash)
• Compose ? ? ⇒ ¿
• Compose ! ! ⇒ ¡
• Compose + - ⇒ ±
• Compose : - ⇒ ÷
• Compose 1 2 ⇒ ½
• Compose 1 4 ⇒ ¼
• Compose 3 4 ⇒ ¾
• Compose _ 0-9 ⇒ ₀ – ₉ (subscript digit)
• Compose ^ 0-9 ⇒ ⁰ – ⁹ (superscript digit)
• Compose ( 0-9 ) ⇒ ⓪ – ⑨ (circled digit)
• Compose o c ⇒ ©
• Compose o r ⇒ ®
• Compose o o ⇒ °
• Compose o s ⇒ §
• Compose x x ⇒ ×
• Compose P P ⇒ ¶
• Compose T M ⇒ ™
• Compose m u ⇒ µ
• Compose % o ⇒ ‰

Defining custom Compose sequences

Default Compose sequences are defined in ‘Compose‘ text file in the current locale directory (/usr/share/X11/locale/xxx). This file contains the rules to define Compose keyboard sequences and corresponding Unicode characters:

# UTF-8 (Unicode) compose sequence
# David.Monniaux (at) ens.fr
#
# $XFree86: xc/nls/Compose/en_US.UTF-8,v 1.11 2004/01/06 13:14:04 pascal Exp $
...
<Multi_key> <less> <less>        	: "«"   guillemotleft # LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
<Multi_key> <greater> <greater>  	: "»"   guillemotright # RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
<Multi_key> <less> <apostrophe>  	: "‘"   U2018 # LEFT SINGLE QUOTATION MARK
...

To define new Compose sequence, we should add another rule using the syntax:

<Multi_key> <key1> [<key2> ...]   	: "character"

For instance, for a smiley character (☺, Unicode 263A), the rule could be

<Multi_key> <colon> <parenright> : "☺"  # Compose : )

There is a number of utilities (like KCharSelect in KDE) for to select the Unicode characters and insert them into the file via clipboard.

It is possible to add new rules just into this system file (if you are root), but it’s better to create ‘.XCompose‘ file in the user home directory:

# ~/.XCompose
# This file defines custom Compose sequence for Unicode characters 

# Import default rules from the system Compose file:
include "/usr/share/X11/locale/en_US.UTF-8/Compose"

<Multi_key> <colon> <parenright> : "☺" U263A   # Compose : )
<Multi_key> <minus> <less>   : "←"  U2190 # Compose - <
<Multi_key> <minus> <greater> : "→" U2192 # Compose ->
...

You also can assign whole strings to the Compose sequences — for instance, syntax constructions of your favorite programming language or HTML tags:

<Multi_key> <less> <p> : "<p></p>" # Compose < p
<Multi_key> <less> <a> : "<a href=""></a>" # Compose < a
...

A common case when you might have an idea of using a custom ClassLoader is to avoid the classpath issues using URLClassLoader for loading classes instead of the default one. Classpath is a list of locations (JAR-files or directories) where default ClassLoader is looking for the classes to load. Declaring Classpath explicitly (either with CLASSPATH environment variable, or as a command-line argument of Java virtual machine) is tedious and error-prone job and it works only in the case of monolithic, statically-linked applications with known set of libraries.

But imagine a complex component-based system with a number of replaceable modules (plug-ins). It is obvious that classpath for that system should be built automatically to reflect the configuration changes before each running. It is often done with system-specific startup scripts which analyzes the modules configuration and generates an appropriate classpath before starting the application. However, this method has its own drawbacks – especially in the case of poor Microsoft systems as their rudimentary command interpreter makes this task hardly possible. And this is a way system-dependent, of course.

URLClassLoader, from a distant point of view, looks like an elegant, simple and “100%-pure-java” solution for the classpath headache. It is instantiated with an array of locations (URL’s) so each class loaded with that ClassLoader will use this array as a classpath. An advantage is that the classpath can be generated on the fly, automatically by an application itself.

So, let’s see how it works. Imagine we have an application with main executable class Foo (in package com.example.foo) and a lot of other classes in different locations. We will develop an invocation wrapper for loading Foo using URLClassLoader with an array of locations, generated automatically:

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

/*
 * FooInvoker.java
 */
 
package com.example.foo;
 
import java.net.URL;
import java.net.URLClassLoader;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
 
public class FooInvoker {
    public static String FOO_CLASS_NAME = "com.example.foo.Foo";
 
    public static void main(String[] args) {
        URL[] classpathURLs = getClasspathURLs();
        ClassLoader loader = new URLClassLoader(classpathURLs);
        try {
            Class fooClass = loader.loadClass(FOO_CLASS_NAME);
            Method main = fooClass.getMethod("main", new Class[] {
                String[].class
            });
            int modifiers = main.getModifiers();
            if (Modifier.isPublic(modifiers) && Modifier.isStatic(modifiers)) {
                main.invoke(null, new Object[] {
                    new String[] {}
                });
                // In this example, we assume Foo.main() takes no
                // command-line arguments
            } else {
                throw new NoSuchMethodException();
            }
        } catch (Exception e) {
            System.err.println("Error running class " + FOO_CLASS_NAME
                    + e.getMessage());
            e.printStackTrace();
        }
    }
 
    private static URL[] getClasspathURLs() {
        URL[] urls = new URL[] {};
        // Here we're looking for all project-related libraries
        // and constructing the classpath array
        // ...
        return urls;
    }
}

Run it (assuming Foo and FooInvoker are packaged both into foo.jar file, which is the core library of our app):

$ java -classpath ./foo.jar com.example.foo.FooInvoker

Alas! Everything located outside the foo.jar (that is, the classpath set in JVM arguments) is failed to load. For instance, if Foo uses class Bar in it’s own bar.jar library, Foo will throw ClassNotFoundException despite of the fact that bar.jar has been passed to URLClassLoader argument. It seems we have no progress at all – all classes are loaded from default JVM classpath as with the system ClassLoader.

Let’s do some debugging. Add this to Foo.main() code to see which ClassLoader loads Foo:

System.out.println("Foo is loaded with: " +
                           Foo.class.getClassLoader().getClass().getName());

Instead of “java.net.URLClassLoader” in output (as we hoped), we will see:

Foo is loaded with: sun.misc.Launcher$AppClassLoader

This is the default system ClassLoader. We really have no progress – it seems our URLClassLoader simply does not come into play. Our code is right but it doesn’t work. Is it a Java bug? Should we give up? Or report to Sun?

Wait a minute. The problem is not in code but in how Java VM executes it. Let’s try a trick: change FooInvoker.getClasspathURLs() algorythm to include foo.jar path in the resulted array (to be passed to URLClassLoader among other locations) and compile FooInvoker as a separate class file (not inside the foo.jar). Then run it (no classpath is declared!):

$ java com.example.foo.FooInvoker
...
Foo is loaded with: java.net.URLClassLoader

Voila! Our URLClassLoader has been used to load Foo as well as other classes, including those from locations in our dynamic classpath. It works! So what is happened?

In this case we found ourselves in one of the dark and odd Java territories ruled by the Masters of The Black Java Art (also known as the Heavy Java Geeks) who believe the programs should not behave as their author expects, but following the mysterious Rules instead. One of those Rules is called “ClassLoader Delegation Model” and it reads:

The ClassLoader class uses a delegation model to search for classes and resources. Each instance of ClassLoader has an associated parent class loader. When requested to find a class or resource, a ClassLoader instance will delegate the search for the class or resource to its parent class loader before attempting to find the class or resource itself.

A parent of URLClassLoader is the default system ClassLoader (as we used single-argument constructor). When we tried to load Foo with an instance of URLClassLoader, it asked the parent if the latter could load Foo. As Foo was in the default classpath, the system ClassLoader, of course, could. By this way, it took a position of a default ClassLoader in a chain of subsequent class invocations and left our URLClassLoader out of business.

When we moved Foo and everything out the default classpath, the system ClassLoader was not able to load anything (except FooInvoker itself). So, it had no chance to took precedence over our custom ClassLoader.

Well, if you like rules, there is another one:

If you use custom ClassLoader, do not give the system one a chance to come into play.

Happy coding!

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.

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.

Swing dialogs by default have no idea about “required” text fields, that is the fields which should be filled to perform a task. In this article I suggest a simple way how to automatically highlight the fields which have to be non-empty.

Our required fields will be highlighted when empty and switched to default look when a user enters a data into them. To track the changes of a field’s content we will use DocumentEvent/DocumentListener mechanism. DocumentEvent‘s are generated by underlying Document model when it is changed by some way. Listening to these events is more reliable way than tracking the user actions (such as key pressings) directly, because it is guaranteed that any content change (including possible changes made by program itself, pasting the clipboard content from a context menu etc) will be monitored.

To listen these events, we should create an implementation of DocumentListener interface:

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

import javax.swing.BorderFactory;
import javax.swing.border.Border;
import javax.swing.event.*;
import javax.swing.text.JTextComponent;
...
 
public class HighlightListener implements DocumentListener {
 
    JTextComponent comp = null;
    Border defaultBorder = null;
    Border highlightBorder =
            BorderFactory.createLineBorder(java.awt.Color.ORANGE);
 
    public HighlightListener(JTextComponent jtc) {
        comp = jtc;
        defaultBorder = comp.getBorder();
        // Adding this listener to a specified component:
        comp.getDocument().addDocumentListener(this);
        // Highlight if empty:
        this.maybeHighlight();
    }
 
    public void insertUpdate(DocumentEvent e) {
        maybeHighlight();
    }
 
    public void removeUpdate(DocumentEvent e) {
        maybeHighlight();
    }
 
    public void changedUpdate(DocumentEvent e) {
        maybeHighlight();
    }
 
    private void maybeHighlight() {
        if (comp.getText().trim().length() > 0)
            // if a field is non-empty, switch it to default look
            comp.setBorder(defaultBorder);
        else
            // if a field is empty, highlight it
            comp.setBorder(highlightBorder);
        // ... more actions
    }
}

To add a highlighting functionality to a text component we should simply instantiate our HighlightListener with this component:

...
JTextField myField = new JTextField();
new HighlightListener(myField);
...

Note that HighlightListener constructor is parametrized with JTextComponent class, so it can work with any children (JEditorPane, JTextArea), not only with JTextField.

Our HighlightListener monitors the updates of a component document model and checks if the text is empty or not. If it is empty, it will be highlighted by adding a thin orange border:

Otherwise, the border will be reverted to its default look.

The code of HighlightListener can be customized for:

• Another highlighting method
• Additional highlighting conditions – e.g. we can check the content against a regular expression for required input format (valid email adresses for instance)
• Additional actions – e.g. to enable/disable the “OK” dialog button if required data is not entered.