• Programming is fun
• Programming is simple

It was an astonishing “You can do that” idea: you don’t have to be a mature, qualified engineer to start doing things with the computer right now. I still don’t know whether it’s a property of the C language itself, or of the book (in very good Russian translation); but even complex subjects, like pointers etc., were explained in an amusing way, intuitive for an average 13 y.o. schoolboy.

I don’t know another programming language specification that were such fundamental and detailed but simple and inspiring at the same time. I really owe to it in particular and to the C in general for I had not been lost in the jungles of something like BASIC (as it was suggested by the most of the “beginner” books of those days) and got a taste for a good language and for a fun of programming from the very beginning.

Unfortunately, I never remember Mr. Ritchie when I turn on my Linux (UNIX!) computer for doing my everyday work (those curly braces and all that stuff). And it’s sad.

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.

http://rdfbeans.sourceforge.net

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.

I’m not thinking about it as of my personal stuff and welcome everyone to suggest new antipatterns and their solutions. if you want to post to that blog yourself, please contact me (you have to be a registered WordPress user).

[sourcecode language='java']
/**
* HelloWorld
*/
public class HelloWorld {
public static void main(String[] args) {
System.out.println(“Hello world!”);
}
}
[/sourcecode]

See also this and this examples of Java code, this example of Python and this XML. Actually 12 programming/markup languages are supported by the syntax highlighter.

What’s good

• It’s an eye-candy
• Language-dependent syntax highlighting, of course
• Horizontal scrolling of the code block, if it’s needed. Now I don’t have to bother how the lines are long
• You can copy my code into your clipboard by a single click

What’s bad

There was a bug when HTML-reserved characters (“<“, “>“, “&“) were displayed as HTML entities (“<” etc). It has been fixed just today. I also noticed that the single backslash chars (“\”) are not displayed and must be escaped with another backslash (“\\”) – hi, PHP geeks!

[upd] The problem with backslash has also been fixed. Thanks to Joseph Scott from WordPress for fast responding and fixing it![/upd]

Sadly enough, code posting is incompatible with WYSIWYG, if you bother about indentation of your code. TinyMCE visual editor will eat all your leading spaces and tabs.

When testing my new Java application, I noticed strange freezing sometimes. It happened irregularly and the program did nothing serious at that time – no complex calculations, no heavy data transfers, etc. Nevertheless, I noticed that those freezings where related to my internet connection glitches – unfortunately, it occasionally happens here. But my program didn’t do anything with internet at those moments!

I did some profiling and found the bottleneck – to my surprise, it was get() method of a HashMap instance. Sometimes it took about 20 seconds only for just checking if an object exists in the map. I was shocked. HashMaps! I used it for ages and was sure they are reasonably fast kind of collections.

One way or another, I found the problem. The point was that I used java.net.URL instances as the HashMap keys. URL objects in Java, in comparison with simple strings, are convenient as they store URLs as the sets of separate fields (protocol, host, path etc), guarantee URL well-formedness and enable to create a connection with a single connect() method.

But its implementation is horrible. As it turned out, two generic object methods – equals() and hashCode() needed for internet connection and domain name resolving just to check equality of two URLs or to compute object’s hash code.

Two URL objects are equal if they have the same protocol, reference equivalent hosts, have the same port number on the host, and the same file and fragment of the file.

Two hosts are considered equivalent if both host names can be resolved into the same IP addresses; else if either host name can’t be resolved, the host names must be equal without regard to case; or both host names equal to null.

Since hosts comparison requires name resolution, this operation is a blocking operation.

(java.net.URL javadoc)

I have no idea what were the reasons to do that, but it is bad. Simply bad. Such common operations as equality test (and hash code computation) should rely on an object data only. Making it dependent on external unreliable resources is dangerous. Also, those operations must be fast as possible, because they are called frequently (often inside the loops). When the time of their execution is equal to the connection time-out, your program simply don’t work.

Even if there were some reasons for that, it works wrong.

Note: The defined behavior for equals is known to be inconsistent with virtual hosting in HTTP.

(Ibid.)

Sure. For instance, URLs of all WordPress blogs are equal from point of view of java.net.URL, as long as all of them are resolved to the same IP address. And a whole lot of other web-sites, unless they are hosted on the dedicated servers.

URLs are just the text strings with known syntax. They should work offline, no matter they are “http:” or “file:”. They don’t need to be resolved to the IP addresses, unless a referenced resource is requested.

Do not use java.net.URL. Store URLs as simple String objects. If you need to keep URLs structured and well-formed, you can use java.net.URI class instead, but the strings are faster anyway. You always can parse a string into java.net.URI object when it is needed. You can parse it into java.net.URL as well, but.. better don’t do it.

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!

Me: This microwave has very annoying, shrill beep. I hate it! I gonna break it and cut that damned beeper off.
My wife: Don’t be surprised but there is a button sequence which makes the owen silent.

Probably, I have to take a rest.

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.