cleanup:global:Reformat with astyle and remove trailing spaces

Mirrors 8a76acb and 41a1264

Signed-off-by: mvglasow <michael -at- vonglasow.com>

14 files changed, 2133 insertions, 2271 deletions

diff --git a/navit/binding/dbus/CMakeLists.txt b/navit/binding/dbus/CMakeLists.txt
index 6f081ab09..ad6858346 100644
--- a/navit/binding/dbus/CMakeLists.txt
+++ b/navit/binding/dbus/CMakeLists.txt
@@ -1,4 +1,4 @@
-module_add_library(binding_dbus binding_dbus.c) 
+module_add_library(binding_dbus binding_dbus.c)
 set(bindir ${CMAKE_INSTALL_PREFIX}/${BIN_DIR})
 
 configure_file (
diff --git a/navit/binding/dbus/binding_dbus.c b/navit/binding/dbus/binding_dbus.c
index fbae259de..10b2faf68 100644
--- a/navit/binding/dbus/binding_dbus.c
+++ b/navit/binding/dbus/binding_dbus.c
@@ -77,373 +77,355 @@ GHashTable *object_hash_rev;
 GHashTable *object_count;
 
 struct dbus_callback {
-	struct callback *callback;
-	char *signal;
+    struct callback *callback;
+    char *signal;
 };
 
 static char *
-object_new(char *type, void *object)
-{
-	int id;
-	char *ret;
-	dbg(lvl_debug,"enter %s", type);
-	if ((ret=g_hash_table_lookup(object_hash_rev, object)))
-		return ret;
-	id=GPOINTER_TO_INT(g_hash_table_lookup(object_count, type));
-	g_hash_table_insert(object_count, type, GINT_TO_POINTER((id+1)));
-	ret=g_strdup_printf("%s/%s/%d", object_path, type, id);
-	g_hash_table_insert(object_hash, ret, object);
-	g_hash_table_insert(object_hash_rev, object, ret);
-	dbg(lvl_debug,"return %s", ret);
-	return (ret);
+object_new(char *type, void *object) {
+    int id;
+    char *ret;
+    dbg(lvl_debug,"enter %s", type);
+    if ((ret=g_hash_table_lookup(object_hash_rev, object)))
+        return ret;
+    id=GPOINTER_TO_INT(g_hash_table_lookup(object_count, type));
+    g_hash_table_insert(object_count, type, GINT_TO_POINTER((id+1)));
+    ret=g_strdup_printf("%s/%s/%d", object_path, type, id);
+    g_hash_table_insert(object_hash, ret, object);
+    g_hash_table_insert(object_hash_rev, object, ret);
+    dbg(lvl_debug,"return %s", ret);
+    return (ret);
 }
 
 static void *
-object_get(const char *path)
-{
-	return g_hash_table_lookup(object_hash, path);
+object_get(const char *path) {
+    return g_hash_table_lookup(object_hash, path);
 }
 
 static void
-object_destroy(const char *path, void *object)
-{
-	if (!path && !object)
-		return;
-	if (!object)
-		object=g_hash_table_lookup(object_hash, path);
-	if (!path)
-		path=g_hash_table_lookup(object_hash_rev, object);
-	g_hash_table_remove(object_hash, path);
-	g_hash_table_remove(object_hash_rev, object);
+object_destroy(const char *path, void *object) {
+    if (!path && !object)
+        return;
+    if (!object)
+        object=g_hash_table_lookup(object_hash, path);
+    if (!path)
+        path=g_hash_table_lookup(object_hash_rev, object);
+    g_hash_table_remove(object_hash, path);
+    g_hash_table_remove(object_hash_rev, object);
 }
 
 static void *
-resolve_object(const char *opath, char *type)
-{
-	char *prefix;
-	const char *oprefix;
-	void *ret=NULL;
-	char *def_navit="/default_navit";
-	char *def_gui="/default_gui";
-	char *def_graphics="/default_graphics";
-	char *def_vehicle="/default_vehicle";
-	char *def_vehicleprofile="/default_vehicleprofile";
-	char *def_mapset="/default_mapset";
-	char *def_map="/default_map";
-	char *def_navigation="/default_navigation";
-	char *def_route="/default_route";
-	char *def_tracking="/default_tracking";
-	struct attr attr;
-
-	if (strncmp(opath, object_path, strlen(object_path))) {
-		dbg(lvl_error,"wrong object path %s",opath);
-		return NULL;
-	}
-	prefix=g_strdup_printf("%s/%s/", object_path, type);
-	if (!strncmp(prefix, opath, strlen(prefix))) {
-		ret=object_get(opath);
-		g_free(prefix);
-		return ret;
-	}
-	g_free(prefix);
-	oprefix=opath+strlen(object_path);
-	if (!strncmp(oprefix,def_navit,strlen(def_navit))) {
-		oprefix+=strlen(def_navit);
-		struct attr navit;
-		if (!config_get_attr(config, attr_navit, &navit, NULL))
-			return NULL;
-		if (!oprefix[0]) {
-			dbg(lvl_debug,"default_navit");
-			return navit.u.navit;
-		}
-		if (!strncmp(oprefix,def_graphics,strlen(def_graphics))) {
-			if (navit_get_attr(navit.u.navit, attr_graphics, &attr, NULL)) {
-				return attr.u.graphics;
-			}
-			return NULL;
-		}
-		if (!strncmp(oprefix,def_gui,strlen(def_gui))) {
-			if (navit_get_attr(navit.u.navit, attr_gui, &attr, NULL)) {
-				return attr.u.gui;
-			}
-			return NULL;
-		}
-		if (!strncmp(oprefix,def_vehicleprofile,strlen(def_vehicleprofile))) {
-			if (navit_get_attr(navit.u.navit, attr_vehicleprofile, &attr, NULL)) {
-				return attr.u.vehicleprofile;
-			}
-			return NULL;
-		}
-		if (!strncmp(oprefix,def_vehicle,strlen(def_vehicle))) {
-			if (navit_get_attr(navit.u.navit, attr_vehicle, &attr, NULL)) {
-				return attr.u.vehicle;
-			}
-			return NULL;
-		}
-		if (!strncmp(oprefix,def_mapset,strlen(def_mapset))) {
-			oprefix+=strlen(def_mapset);
-			if (navit_get_attr(navit.u.navit, attr_mapset, &attr, NULL)) {
-				if (!oprefix[0]) {
-					return attr.u.mapset;
-				}
-				if (!strncmp(oprefix,def_map,strlen(def_map))) {
-					if (mapset_get_attr(attr.u.mapset, attr_map, &attr, NULL)) {
-						return attr.u.map;
-					}
-					return NULL;
-				}
-			}
-			return NULL;
-		}
-		if (!strncmp(oprefix,def_navigation,strlen(def_navigation))) {
-			if (navit_get_attr(navit.u.navit, attr_navigation, &attr, NULL)) {
-				return attr.u.navigation;
-			}
-			return NULL;
-		}
-		if (!strncmp(oprefix,def_route,strlen(def_route))) {
-			oprefix+=strlen(def_route);
-			if (navit_get_attr(navit.u.navit, attr_route, &attr, NULL)) {
-				return attr.u.route;
-			}
-			return NULL;
-		}
-		if (!strncmp(oprefix,def_tracking,strlen(def_tracking))) {
-			if (navit_get_attr(navit.u.navit, attr_trackingo, &attr, NULL)) {
-				return attr.u.tracking;
-			}
-			return NULL;
-		}
-	}
-	return NULL;
+resolve_object(const char *opath, char *type) {
+    char *prefix;
+    const char *oprefix;
+    void *ret=NULL;
+    char *def_navit="/default_navit";
+    char *def_gui="/default_gui";
+    char *def_graphics="/default_graphics";
+    char *def_vehicle="/default_vehicle";
+    char *def_vehicleprofile="/default_vehicleprofile";
+    char *def_mapset="/default_mapset";
+    char *def_map="/default_map";
+    char *def_navigation="/default_navigation";
+    char *def_route="/default_route";
+    char *def_tracking="/default_tracking";
+    struct attr attr;
+
+    if (strncmp(opath, object_path, strlen(object_path))) {
+        dbg(lvl_error,"wrong object path %s",opath);
+        return NULL;
+    }
+    prefix=g_strdup_printf("%s/%s/", object_path, type);
+    if (!strncmp(prefix, opath, strlen(prefix))) {
+        ret=object_get(opath);
+        g_free(prefix);
+        return ret;
+    }
+    g_free(prefix);
+    oprefix=opath+strlen(object_path);
+    if (!strncmp(oprefix,def_navit,strlen(def_navit))) {
+        oprefix+=strlen(def_navit);
+        struct attr navit;
+        if (!config_get_attr(config, attr_navit, &navit, NULL))
+            return NULL;
+        if (!oprefix[0]) {
+            dbg(lvl_debug,"default_navit");
+            return navit.u.navit;
+        }
+        if (!strncmp(oprefix,def_graphics,strlen(def_graphics))) {
+            if (navit_get_attr(navit.u.navit, attr_graphics, &attr, NULL)) {
+                return attr.u.graphics;
+            }
+            return NULL;
+        }
+        if (!strncmp(oprefix,def_gui,strlen(def_gui))) {
+            if (navit_get_attr(navit.u.navit, attr_gui, &attr, NULL)) {
+                return attr.u.gui;
+            }
+            return NULL;
+        }
+        if (!strncmp(oprefix,def_vehicleprofile,strlen(def_vehicleprofile))) {
+            if (navit_get_attr(navit.u.navit, attr_vehicleprofile, &attr, NULL)) {
+                return attr.u.vehicleprofile;
+            }
+            return NULL;
+        }
+        if (!strncmp(oprefix,def_vehicle,strlen(def_vehicle))) {
+            if (navit_get_attr(navit.u.navit, attr_vehicle, &attr, NULL)) {
+                return attr.u.vehicle;
+            }
+            return NULL;
+        }
+        if (!strncmp(oprefix,def_mapset,strlen(def_mapset))) {
+            oprefix+=strlen(def_mapset);
+            if (navit_get_attr(navit.u.navit, attr_mapset, &attr, NULL)) {
+                if (!oprefix[0]) {
+                    return attr.u.mapset;
+                }
+                if (!strncmp(oprefix,def_map,strlen(def_map))) {
+                    if (mapset_get_attr(attr.u.mapset, attr_map, &attr, NULL)) {
+                        return attr.u.map;
+                    }
+                    return NULL;
+                }
+            }
+            return NULL;
+        }
+        if (!strncmp(oprefix,def_navigation,strlen(def_navigation))) {
+            if (navit_get_attr(navit.u.navit, attr_navigation, &attr, NULL)) {
+                return attr.u.navigation;
+            }
+            return NULL;
+        }
+        if (!strncmp(oprefix,def_route,strlen(def_route))) {
+            oprefix+=strlen(def_route);
+            if (navit_get_attr(navit.u.navit, attr_route, &attr, NULL)) {
+                return attr.u.route;
+            }
+            return NULL;
+        }
+        if (!strncmp(oprefix,def_tracking,strlen(def_tracking))) {
+            if (navit_get_attr(navit.u.navit, attr_trackingo, &attr, NULL)) {
+                return attr.u.tracking;
+            }
+            return NULL;
+        }
+    }
+    return NULL;
 }
 
 static void *
-object_get_from_message_arg(DBusMessageIter *iter, char *type)
-{
-	char *opath;
+object_get_from_message_arg(DBusMessageIter *iter, char *type) {
+    char *opath;
 
-	if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_OBJECT_PATH)
-		return NULL;
-	dbus_message_iter_get_basic(iter, &opath);
-	dbus_message_iter_next(iter);
-	return resolve_object(opath, type);
+    if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_OBJECT_PATH)
+        return NULL;
+    dbus_message_iter_get_basic(iter, &opath);
+    dbus_message_iter_next(iter);
+    return resolve_object(opath, type);
 }
 
 static void *
-object_get_from_message(DBusMessage *message, char *type)
-{
-	return resolve_object(dbus_message_get_path(message), type);
+object_get_from_message(DBusMessage *message, char *type) {
+    return resolve_object(dbus_message_get_path(message), type);
 }
 
 static enum attr_type
-attr_type_get_from_message(DBusMessageIter *iter)
-{
-	char *attr_type;
+attr_type_get_from_message(DBusMessageIter *iter) {
+    char *attr_type;
 
-	if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_STRING)
-		return attr_none;
-	dbus_message_iter_get_basic(iter, &attr_type);
-	dbus_message_iter_next(iter);
-	return attr_from_name(attr_type);
+    if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_STRING)
+        return attr_none;
+    dbus_message_iter_get_basic(iter, &attr_type);
+    dbus_message_iter_next(iter);
+    return attr_from_name(attr_type);
 }
 
 static void
-encode_variant_string(DBusMessageIter *iter, char *str)
-{
-	DBusMessageIter variant;
-	dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, DBUS_TYPE_STRING_AS_STRING, &variant);
-	dbus_message_iter_append_basic(&variant, DBUS_TYPE_STRING, &str);
-	dbus_message_iter_close_container(iter, &variant);
+encode_variant_string(DBusMessageIter *iter, char *str) {
+    DBusMessageIter variant;
+    dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, DBUS_TYPE_STRING_AS_STRING, &variant);
+    dbus_message_iter_append_basic(&variant, DBUS_TYPE_STRING, &str);
+    dbus_message_iter_close_container(iter, &variant);
 }
 
 static void
-encode_dict_string_variant_string(DBusMessageIter *iter, char *key, char *value)
-{
-	DBusMessageIter dict;
-	dbus_message_iter_open_container(iter, DBUS_TYPE_DICT_ENTRY, NULL, &dict);
-	dbus_message_iter_append_basic(&dict, DBUS_TYPE_STRING, &key);
-	encode_variant_string(&dict, value);
-	dbus_message_iter_close_container(iter, &dict);
+encode_dict_string_variant_string(DBusMessageIter *iter, char *key, char *value) {
+    DBusMessageIter dict;
+    dbus_message_iter_open_container(iter, DBUS_TYPE_DICT_ENTRY, NULL, &dict);
+    dbus_message_iter_append_basic(&dict, DBUS_TYPE_STRING, &key);
+    encode_variant_string(&dict, value);
+    dbus_message_iter_close_container(iter, &dict);
 }
 
 static int
-encode_attr(DBusMessageIter *iter1, struct attr *attr)
-{
-	char *name=attr_to_name(attr->type);
-	DBusMessageIter iter2,iter3;
-	dbus_message_iter_append_basic(iter1, DBUS_TYPE_STRING, &name);
-	if (attr->type >= attr_type_int_begin && attr->type < attr_type_boolean_begin) {
-		dbus_message_iter_open_container(iter1, DBUS_TYPE_VARIANT, DBUS_TYPE_INT32_AS_STRING, &iter2);
-		dbus_message_iter_append_basic(&iter2, DBUS_TYPE_INT32, &attr->u.num);
-		dbus_message_iter_close_container(iter1, &iter2);
-	}
-	if (attr->type >= attr_type_boolean_begin && attr->type <= attr_type_int_end) {
-		dbus_message_iter_open_container(iter1, DBUS_TYPE_VARIANT, DBUS_TYPE_BOOLEAN_AS_STRING, &iter2);
-		dbus_message_iter_append_basic(&iter2, DBUS_TYPE_BOOLEAN, &attr->u.num);
-		dbus_message_iter_close_container(iter1, &iter2);
-	}
-	if (attr->type >= attr_type_string_begin && attr->type <= attr_type_string_end) {
-		encode_variant_string(iter1, attr->u.str);
-	}
-	if ((attr->type >= attr_type_item_type_begin && attr->type <= attr_type_item_type_end) || attr->type == attr_item_type) {
-		encode_variant_string(iter1, item_to_name(attr->u.item_type));
-	}
-	if (attr->type >= attr_type_pcoord_begin && attr->type <= attr_type_pcoord_end) {
-		dbus_message_iter_open_container(iter1, DBUS_TYPE_VARIANT, "ai", &iter2);
-		dbus_message_iter_open_container(&iter2, DBUS_TYPE_ARRAY, "i", &iter3);
-		if (attr->u.pcoord) {
-			dbus_message_iter_append_basic(&iter3, DBUS_TYPE_INT32, &attr->u.pcoord->pro);
-			dbus_message_iter_append_basic(&iter3, DBUS_TYPE_INT32, &attr->u.pcoord->x);
-			dbus_message_iter_append_basic(&iter3, DBUS_TYPE_INT32, &attr->u.pcoord->y);
-		}
-		dbus_message_iter_close_container(&iter2, &iter3);
-		dbus_message_iter_close_container(iter1, &iter2);
-	}
-	if (attr->type >= attr_type_object_begin && attr->type <= attr_type_object_end) {
-		char *object=object_new(attr_to_name(attr->type), attr->u.data);
-		dbus_message_iter_open_container(iter1, DBUS_TYPE_VARIANT, DBUS_TYPE_OBJECT_PATH_AS_STRING, &iter2);
-		dbus_message_iter_append_basic(&iter2, DBUS_TYPE_OBJECT_PATH, &object);
-		dbus_message_iter_close_container(iter1, &iter2);
-	}
-	if (attr->type == attr_item_types) {
-		char *str=attr_to_text(attr,NULL,0);
-		encode_variant_string(iter1, str);
-		g_free(str);
-	}
-	return 1;
+encode_attr(DBusMessageIter *iter1, struct attr *attr) {
+    char *name=attr_to_name(attr->type);
+    DBusMessageIter iter2,iter3;
+    dbus_message_iter_append_basic(iter1, DBUS_TYPE_STRING, &name);
+    if (attr->type >= attr_type_int_begin && attr->type < attr_type_boolean_begin) {
+        dbus_message_iter_open_container(iter1, DBUS_TYPE_VARIANT, DBUS_TYPE_INT32_AS_STRING, &iter2);
+        dbus_message_iter_append_basic(&iter2, DBUS_TYPE_INT32, &attr->u.num);
+        dbus_message_iter_close_container(iter1, &iter2);
+    }
+    if (attr->type >= attr_type_boolean_begin && attr->type <= attr_type_int_end) {
+        dbus_message_iter_open_container(iter1, DBUS_TYPE_VARIANT, DBUS_TYPE_BOOLEAN_AS_STRING, &iter2);
+        dbus_message_iter_append_basic(&iter2, DBUS_TYPE_BOOLEAN, &attr->u.num);
+        dbus_message_iter_close_container(iter1, &iter2);
+    }
+    if (attr->type >= attr_type_string_begin && attr->type <= attr_type_string_end) {
+        encode_variant_string(iter1, attr->u.str);
+    }
+    if ((attr->type >= attr_type_item_type_begin && attr->type <= attr_type_item_type_end)
+            || attr->type == attr_item_type) {
+        encode_variant_string(iter1, item_to_name(attr->u.item_type));
+    }
+    if (attr->type >= attr_type_pcoord_begin && attr->type <= attr_type_pcoord_end) {
+        dbus_message_iter_open_container(iter1, DBUS_TYPE_VARIANT, "ai", &iter2);
+        dbus_message_iter_open_container(&iter2, DBUS_TYPE_ARRAY, "i", &iter3);
+        if (attr->u.pcoord) {
+            dbus_message_iter_append_basic(&iter3, DBUS_TYPE_INT32, &attr->u.pcoord->pro);
+            dbus_message_iter_append_basic(&iter3, DBUS_TYPE_INT32, &attr->u.pcoord->x);
+            dbus_message_iter_append_basic(&iter3, DBUS_TYPE_INT32, &attr->u.pcoord->y);
+        }
+        dbus_message_iter_close_container(&iter2, &iter3);
+        dbus_message_iter_close_container(iter1, &iter2);
+    }
+    if (attr->type >= attr_type_object_begin && attr->type <= attr_type_object_end) {
+        char *object=object_new(attr_to_name(attr->type), attr->u.data);
+        dbus_message_iter_open_container(iter1, DBUS_TYPE_VARIANT, DBUS_TYPE_OBJECT_PATH_AS_STRING, &iter2);
+        dbus_message_iter_append_basic(&iter2, DBUS_TYPE_OBJECT_PATH, &object);
+        dbus_message_iter_close_container(iter1, &iter2);
+    }
+    if (attr->type == attr_item_types) {
+        char *str=attr_to_text(attr,NULL,0);
+        encode_variant_string(iter1, str);
+        g_free(str);
+    }
+    return 1;
 }
 
 
 static DBusHandlerResult
-empty_reply(DBusConnection *connection, DBusMessage *message)
-{
-	DBusMessage *reply;
+empty_reply(DBusConnection *connection, DBusMessage *message) {
+    DBusMessage *reply;
 
-	reply = dbus_message_new_method_return(message);
-	dbus_connection_send (connection, reply, NULL);
-	dbus_message_unref (reply);
+    reply = dbus_message_new_method_return(message);
+    dbus_connection_send (connection, reply, NULL);
+    dbus_message_unref (reply);
 
-	return DBUS_HANDLER_RESULT_HANDLED;
+    return DBUS_HANDLER_RESULT_HANDLED;
 }
 
 
 static DBusHandlerResult
-dbus_error(DBusConnection *connection, DBusMessage *message, char *error, char *msg)
-{
-	DBusMessage *reply;
+dbus_error(DBusConnection *connection, DBusMessage *message, char *error, char *msg) {
+    DBusMessage *reply;
 
-	reply = dbus_message_new_error(message, error, msg);
-	dbus_connection_send (connection, reply, NULL);
-	dbus_message_unref (reply);
-	return DBUS_HANDLER_RESULT_HANDLED;
+    reply = dbus_message_new_error(message, error, msg);
+    dbus_connection_send (connection, reply, NULL);
+    dbus_message_unref (reply);
+    return DBUS_HANDLER_RESULT_HANDLED;
 }
 
 static DBusHandlerResult
-dbus_error_invalid_attr_type(DBusConnection *connection, DBusMessage *message)
-{
-	return dbus_error(connection, message, DBUS_ERROR_INVALID_ARGS, "attribute type invalid");
+dbus_error_invalid_attr_type(DBusConnection *connection, DBusMessage *message) {
+    return dbus_error(connection, message, DBUS_ERROR_INVALID_ARGS, "attribute type invalid");
 }
 
 static DBusHandlerResult
-dbus_error_invalid_parameter(DBusConnection *connection, DBusMessage *message)
-{
-	return dbus_error(connection, message, DBUS_ERROR_INVALID_ARGS, "parameter invalid");
+dbus_error_invalid_parameter(DBusConnection *connection, DBusMessage *message) {
+    return dbus_error(connection, message, DBUS_ERROR_INVALID_ARGS, "parameter invalid");
 }
 
 static DBusHandlerResult
-dbus_error_invalid_object_path(DBusConnection *connection, DBusMessage *message)
-{
-	return dbus_error(connection, message, DBUS_ERROR_BAD_ADDRESS, "object path invalid");
+dbus_error_invalid_object_path(DBusConnection *connection, DBusMessage *message) {
+    return dbus_error(connection, message, DBUS_ERROR_BAD_ADDRESS, "object path invalid");
 }
 
 static DBusHandlerResult
-dbus_error_invalid_object_path_parameter(DBusConnection *connection, DBusMessage *message)
-{
-	return dbus_error(connection, message, DBUS_ERROR_BAD_ADDRESS, "object path parameter invalid");
+dbus_error_invalid_object_path_parameter(DBusConnection *connection, DBusMessage *message) {
+    return dbus_error(connection, message, DBUS_ERROR_BAD_ADDRESS, "object path parameter invalid");
 }
 
 static DBusHandlerResult
-dbus_error_navigation_not_configured(DBusConnection *connection, DBusMessage *message)
-{
-	return dbus_error(connection, message, DBUS_ERROR_FAILED, "navigation is not configured (no <navigation> element in config file?)");
+dbus_error_navigation_not_configured(DBusConnection *connection, DBusMessage *message) {
+    return dbus_error(connection, message, DBUS_ERROR_FAILED,
+                      "navigation is not configured (no <navigation> element in config file?)");
 }
 
 static DBusHandlerResult
-dbus_error_traffic_not_configured(DBusConnection *connection, DBusMessage *message)
-{
-	return dbus_error(connection, message, DBUS_ERROR_FAILED, "traffic is not configured (no <traffic> element in config file?)");
+dbus_error_traffic_not_configured(DBusConnection *connection, DBusMessage *message) {
+    return dbus_error(connection, message, DBUS_ERROR_FAILED,
+                      "traffic is not configured (no <traffic> element in config file?)");
 }
 
 static DBusHandlerResult
-dbus_error_no_data_available(DBusConnection *connection, DBusMessage *message)
-{
+dbus_error_no_data_available(DBusConnection *connection, DBusMessage *message) {
 #if 1
-	return dbus_error(connection, message, DBUS_ERROR_FILE_NOT_FOUND, "no data available");
+    return dbus_error(connection, message, DBUS_ERROR_FILE_NOT_FOUND, "no data available");
 #else
-	return empty_reply(connection, message);
+    return empty_reply(connection, message);
 #endif
 }
 
 #if 0
 static void
-dbus_dump_iter(char *prefix, DBusMessageIter *iter)
-{
-	char *prefixr,*vals;
-	int arg,vali;
-	DBusMessageIter iterr;
-	while ((arg=dbus_message_iter_get_arg_type(iter)) != DBUS_TYPE_INVALID) {
-		switch (arg) {
-		case DBUS_TYPE_INT32:
-            		dbus_message_iter_get_basic(iter, &vali);
-			dbg(lvl_debug,"%sDBUS_TYPE_INT32: %d",prefix,vali);
-			break;
-		case DBUS_TYPE_STRING:
-            		dbus_message_iter_get_basic(iter, &vals);
-			dbg(lvl_debug,"%sDBUS_TYPE_STRING: %s",prefix,vals);
-			break;
-		case DBUS_TYPE_STRUCT:
-			dbg(lvl_debug,"%sDBUS_TYPE_STRUCT:",prefix);
-			prefixr=g_strdup_printf("%s  ",prefix);
-        		dbus_message_iter_recurse(iter, &iterr);
-			dbus_dump_iter(prefixr, &iterr);
-			g_free(prefixr);
-			break;
-		case DBUS_TYPE_VARIANT:
-			dbg(lvl_debug,"%sDBUS_TYPE_VARIANT:",prefix);
-			prefixr=g_strdup_printf("%s  ",prefix);
-        		dbus_message_iter_recurse(iter, &iterr);
-			dbus_dump_iter(prefixr, &iterr);
-			g_free(prefixr);
-			break;
-		case DBUS_TYPE_DICT_ENTRY:
-			dbg(lvl_debug,"%sDBUS_TYPE_DICT_ENTRY:",prefix);
-			prefixr=g_strdup_printf("%s  ",prefix);
-        		dbus_message_iter_recurse(iter, &iterr);
-			dbus_dump_iter(prefixr, &iterr);
-			g_free(prefixr);
-			break;
-		case DBUS_TYPE_ARRAY:
-			dbg(lvl_debug,"%sDBUS_TYPE_ARRAY:",prefix);
-			prefixr=g_strdup_printf("%s  ",prefix);
-        		dbus_message_iter_recurse(iter, &iterr);
-			dbus_dump_iter(prefixr, &iterr);
-			g_free(prefixr);
-			break;
-		default:
-			dbg(lvl_debug,"%c",arg);
-		}
-		dbus_message_iter_next(iter);
-	}
+dbus_dump_iter(char *prefix, DBusMessageIter *iter) {
+    char *prefixr,*vals;
+    int arg,vali;
+    DBusMessageIter iterr;
+    while ((arg=dbus_message_iter_get_arg_type(iter)) != DBUS_TYPE_INVALID) {
+        switch (arg) {
+        case DBUS_TYPE_INT32:
+            dbus_message_iter_get_basic(iter, &vali);
+            dbg(lvl_debug,"%sDBUS_TYPE_INT32: %d",prefix,vali);
+            break;
+        case DBUS_TYPE_STRING:
+            dbus_message_iter_get_basic(iter, &vals);
+            dbg(lvl_debug,"%sDBUS_TYPE_STRING: %s",prefix,vals);
+            break;
+        case DBUS_TYPE_STRUCT:
+            dbg(lvl_debug,"%sDBUS_TYPE_STRUCT:",prefix);
+            prefixr=g_strdup_printf("%s  ",prefix);
+            dbus_message_iter_recurse(iter, &iterr);
+            dbus_dump_iter(prefixr, &iterr);
+            g_free(prefixr);
+            break;
+        case DBUS_TYPE_VARIANT:
+            dbg(lvl_debug,"%sDBUS_TYPE_VARIANT:",prefix);
+            prefixr=g_strdup_printf("%s  ",prefix);
+            dbus_message_iter_recurse(iter, &iterr);
+            dbus_dump_iter(prefixr, &iterr);
+            g_free(prefixr);
+            break;
+        case DBUS_TYPE_DICT_ENTRY:
+            dbg(lvl_debug,"%sDBUS_TYPE_DICT_ENTRY:",prefix);
+            prefixr=g_strdup_printf("%s  ",prefix);
+            dbus_message_iter_recurse(iter, &iterr);
+            dbus_dump_iter(prefixr, &iterr);
+            g_free(prefixr);
+            break;
+        case DBUS_TYPE_ARRAY:
+            dbg(lvl_debug,"%sDBUS_TYPE_ARRAY:",prefix);
+            prefixr=g_strdup_printf("%s  ",prefix);
+            dbus_message_iter_recurse(iter, &iterr);
+            dbus_dump_iter(prefixr, &iterr);
+            g_free(prefixr);
+            break;
+        default:
+            dbg(lvl_debug,"%c",arg);
+        }
+        dbus_message_iter_next(iter);
+    }
 }
 
 static void
-dbus_dump(DBusMessage *message)
-{
-	DBusMessageIter iter;
+dbus_dump(DBusMessage *message) {
+    DBusMessageIter iter;
 
-	dbus_message_iter_init(message, &iter);
-	dbus_dump_iter("",&iter);
+    dbus_message_iter_init(message, &iter);
+    dbus_dump_iter("",&iter);
 
 }
 #endif
@@ -457,8 +439,7 @@ dbus_dump(DBusMessage *message)
  * @returns Returns 1 when everything went right, otherwise 0
  */
 static int
-pcoord_get_from_message(DBusMessage *message, DBusMessageIter *iter, struct pcoord *pc)
-{
+pcoord_get_from_message(DBusMessage *message, DBusMessageIter *iter, struct pcoord *pc) {
 
     if(!strcmp(dbus_message_iter_get_signature(iter), "s")) {
         char *coordstring;
@@ -503,416 +484,401 @@ pcoord_get_from_message(DBusMessage *message, DBusMessageIter *iter, struct pcoo
 }
 
 static void
-pcoord_encode(DBusMessageIter *iter, struct pcoord *pc)
-{
-	DBusMessageIter iter2;
-	dbus_message_iter_open_container(iter,DBUS_TYPE_STRUCT,NULL,&iter2);
-	if (pc) {
-		dbus_message_iter_append_basic(&iter2, DBUS_TYPE_INT32, &pc->pro);
-		dbus_message_iter_append_basic(&iter2, DBUS_TYPE_INT32, &pc->x);
-		dbus_message_iter_append_basic(&iter2, DBUS_TYPE_INT32, &pc->y);
-	} else {
-		int n=0;
-		dbus_message_iter_append_basic(&iter2, DBUS_TYPE_INT32, &n);
-		dbus_message_iter_append_basic(&iter2, DBUS_TYPE_INT32, &n);
-		dbus_message_iter_append_basic(&iter2, DBUS_TYPE_INT32, &n);
-	}
-	dbus_message_iter_close_container(iter, &iter2);
+pcoord_encode(DBusMessageIter *iter, struct pcoord *pc) {
+    DBusMessageIter iter2;
+    dbus_message_iter_open_container(iter,DBUS_TYPE_STRUCT,NULL,&iter2);
+    if (pc) {
+        dbus_message_iter_append_basic(&iter2, DBUS_TYPE_INT32, &pc->pro);
+        dbus_message_iter_append_basic(&iter2, DBUS_TYPE_INT32, &pc->x);
+        dbus_message_iter_append_basic(&iter2, DBUS_TYPE_INT32, &pc->y);
+    } else {
+        int n=0;
+        dbus_message_iter_append_basic(&iter2, DBUS_TYPE_INT32, &n);
+        dbus_message_iter_append_basic(&iter2, DBUS_TYPE_INT32, &n);
+        dbus_message_iter_append_basic(&iter2, DBUS_TYPE_INT32, &n);
+    }
+    dbus_message_iter_close_container(iter, &iter2);
 }
 
 static enum attr_type
-decode_attr_type_from_iter(DBusMessageIter *iter)
-{
-	char *attr_type;
-	enum attr_type ret;
+decode_attr_type_from_iter(DBusMessageIter *iter) {
+    char *attr_type;
+    enum attr_type ret;
 
-	if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_STRING)
-		return attr_none;
-	dbus_message_iter_get_basic(iter, &attr_type);
-	dbus_message_iter_next(iter);
-	ret=attr_from_name(attr_type);
-	dbg(lvl_debug, "attr value: 0x%x string: %s", ret, attr_type);
-	return ret;
+    if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_STRING)
+        return attr_none;
+    dbus_message_iter_get_basic(iter, &attr_type);
+    dbus_message_iter_next(iter);
+    ret=attr_from_name(attr_type);
+    dbg(lvl_debug, "attr value: 0x%x string: %s", ret, attr_type);
+    return ret;
 }
 
 static int
-decode_attr_from_iter(DBusMessageIter *iter, struct attr *attr)
-{
-	DBusMessageIter iterattr, iterstruct;
-	int ret=1;
-	double d;
-
-	attr->type=decode_attr_type_from_iter(iter);
-	if (attr->type == attr_none)
-		return 0;
-
-	dbus_message_iter_recurse(iter, &iterattr);
-	dbus_message_iter_next(iter);
-	dbg(lvl_debug, "seems valid. signature: %s", dbus_message_iter_get_signature(&iterattr));
-
-	if (attr->type >= attr_type_item_begin && attr->type <= attr_type_item_end)
-		return 0;
-
-	if (attr->type >= attr_type_int_begin && attr->type <= attr_type_boolean_begin) {
-		if (dbus_message_iter_get_arg_type(&iterattr) == DBUS_TYPE_INT32) {
-			int val;
-			dbus_message_iter_get_basic(&iterattr, &val);
-			attr->u.num=val;
-			return 1;
-		}
-		return 0;
-	}
-	if(attr->type >= attr_type_boolean_begin && attr->type <= attr_type_int_end) {
-		if (dbus_message_iter_get_arg_type(&iterattr) == DBUS_TYPE_BOOLEAN) {
-			int val;
-			dbus_message_iter_get_basic(&iterattr, &val);
-			attr->u.num=val;
-			return 1;
-		}
-		return 0;
+decode_attr_from_iter(DBusMessageIter *iter, struct attr *attr) {
+    DBusMessageIter iterattr, iterstruct;
+    int ret=1;
+    double d;
+
+    attr->type=decode_attr_type_from_iter(iter);
+    if (attr->type == attr_none)
+        return 0;
+
+    dbus_message_iter_recurse(iter, &iterattr);
+    dbus_message_iter_next(iter);
+    dbg(lvl_debug, "seems valid. signature: %s", dbus_message_iter_get_signature(&iterattr));
+
+    if (attr->type >= attr_type_item_begin && attr->type <= attr_type_item_end)
+        return 0;
+
+    if (attr->type >= attr_type_int_begin && attr->type <= attr_type_boolean_begin) {
+        if (dbus_message_iter_get_arg_type(&iterattr) == DBUS_TYPE_INT32) {
+            int val;
+            dbus_message_iter_get_basic(&iterattr, &val);
+            attr->u.num=val;
+            return 1;
+        }
+        return 0;
+    }
+    if(attr->type >= attr_type_boolean_begin && attr->type <= attr_type_int_end) {
+        if (dbus_message_iter_get_arg_type(&iterattr) == DBUS_TYPE_BOOLEAN) {
+            int val;
+            dbus_message_iter_get_basic(&iterattr, &val);
+            attr->u.num=val;
+            return 1;
         }
-	if(attr->type >= attr_type_string_begin && attr->type <= attr_type_string_end) {
-		if (dbus_message_iter_get_arg_type(&iterattr) == DBUS_TYPE_STRING) {
-			dbus_message_iter_get_basic(&iterattr, &attr->u.str);
-			return 1;
-		}
-		return 0;
+        return 0;
+    }
+    if(attr->type >= attr_type_string_begin && attr->type <= attr_type_string_end) {
+        if (dbus_message_iter_get_arg_type(&iterattr) == DBUS_TYPE_STRING) {
+            dbus_message_iter_get_basic(&iterattr, &attr->u.str);
+            return 1;
+        }
+        return 0;
+    }
+    if(attr->type >= attr_type_double_begin && attr->type <= attr_type_double_end) {
+        if (dbus_message_iter_get_arg_type(&iterattr) == DBUS_TYPE_DOUBLE) {
+            attr->u.numd=g_new(typeof(*attr->u.numd),1);
+            dbus_message_iter_get_basic(&iterattr, attr->u.numd);
+            return 1;
+        }
+    }
+    if(attr->type >= attr_type_object_begin && attr->type <= attr_type_object_end) {
+        if (dbus_message_iter_get_arg_type(&iterattr) == DBUS_TYPE_OBJECT_PATH) {
+            char *obj;
+            dbus_message_iter_get_basic(&iterattr, &obj);
+            attr->u.data=object_get(obj);
+            if (attr->u.data) {
+                return 1;
+            }
+        }
+        return 0;
+    }
+    if(attr->type >= attr_type_coord_geo_begin && attr->type <= attr_type_coord_geo_end) {
+        if (dbus_message_iter_get_arg_type(&iterattr) == DBUS_TYPE_STRUCT) {
+            attr->u.coord_geo=g_new(typeof(*attr->u.coord_geo),1);
+            dbus_message_iter_recurse(&iterattr, &iterstruct);
+            if (dbus_message_iter_get_arg_type(&iterstruct) == DBUS_TYPE_DOUBLE) {
+                dbus_message_iter_get_basic(&iterstruct, &d);
+                dbus_message_iter_next(&iterstruct);
+                attr->u.coord_geo->lng=d;
+            } else
+                ret=0;
+            if (dbus_message_iter_get_arg_type(&iterstruct) == DBUS_TYPE_DOUBLE) {
+                dbus_message_iter_get_basic(&iterstruct, &d);
+                attr->u.coord_geo->lat=d;
+            } else
+                ret=0;
+            if (!ret) {
+                g_free(attr->u.coord_geo);
+                attr->u.coord_geo=NULL;
+            }
+            return ret;
+        }
+    }
+    if(attr->type >= attr_type_pcoord_begin && attr->type <= attr_type_pcoord_end) {
+        int i;
+        if (dbus_message_iter_get_arg_type(&iterattr) == DBUS_TYPE_STRUCT) {
+            attr->u.pcoord=g_new(typeof(*attr->u.pcoord),1);
+            dbus_message_iter_recurse(&iterattr, &iterstruct);
+            if (dbus_message_iter_get_arg_type(&iterstruct) == DBUS_TYPE_INT32) {
+                dbus_message_iter_get_basic(&iterstruct, &i);
+                dbus_message_iter_next(&iterstruct);
+                attr->u.pcoord->pro=i;
+            } else
+                ret=0;
+            if (dbus_message_iter_get_arg_type(&iterstruct) == DBUS_TYPE_INT32) {
+                dbus_message_iter_get_basic(&iterstruct, &i);
+                dbus_message_iter_next(&iterstruct);
+                attr->u.pcoord->x=i;
+            } else
+                ret=0;
+            if (dbus_message_iter_get_arg_type(&iterstruct) == DBUS_TYPE_INT32) {
+                dbus_message_iter_get_basic(&iterstruct, &i);
+                attr->u.pcoord->y=i;
+            } else
+                ret=0;
+            if (!ret) {
+                g_free(attr->u.pcoord);
+                attr->u.pcoord=NULL;
+            }
+            return ret;
         }
-	if(attr->type >= attr_type_double_begin && attr->type <= attr_type_double_end) {
-		if (dbus_message_iter_get_arg_type(&iterattr) == DBUS_TYPE_DOUBLE) {
-			attr->u.numd=g_new(typeof(*attr->u.numd),1);
-			dbus_message_iter_get_basic(&iterattr, attr->u.numd);
-			return 1;
-		}
-	}
-	if(attr->type >= attr_type_object_begin && attr->type <= attr_type_object_end) {
-		if (dbus_message_iter_get_arg_type(&iterattr) == DBUS_TYPE_OBJECT_PATH) {
-			char *obj;
-			dbus_message_iter_get_basic(&iterattr, &obj);
-			attr->u.data=object_get(obj);
-			if (attr->u.data) {
-				return 1;
-			}
-		}
-		return 0;
-	}
-	if(attr->type >= attr_type_coord_geo_begin && attr->type <= attr_type_coord_geo_end) {
-		if (dbus_message_iter_get_arg_type(&iterattr) == DBUS_TYPE_STRUCT) {
-			attr->u.coord_geo=g_new(typeof(*attr->u.coord_geo),1);
-			dbus_message_iter_recurse(&iterattr, &iterstruct);
-			if (dbus_message_iter_get_arg_type(&iterstruct) == DBUS_TYPE_DOUBLE) {
-				dbus_message_iter_get_basic(&iterstruct, &d);
-				dbus_message_iter_next(&iterstruct);
-				attr->u.coord_geo->lng=d;
-			} else
-				ret=0;
-			if (dbus_message_iter_get_arg_type(&iterstruct) == DBUS_TYPE_DOUBLE) {
-				dbus_message_iter_get_basic(&iterstruct, &d);
-				attr->u.coord_geo->lat=d;
-			} else
-				ret=0;
-			if (!ret) {
-				g_free(attr->u.coord_geo);
-				attr->u.coord_geo=NULL;
-			}
-			return ret;
-		}
-	}
-	if(attr->type >= attr_type_pcoord_begin && attr->type <= attr_type_pcoord_end) {
-		int i;
-		if (dbus_message_iter_get_arg_type(&iterattr) == DBUS_TYPE_STRUCT) {
-			attr->u.pcoord=g_new(typeof(*attr->u.pcoord),1);
-			dbus_message_iter_recurse(&iterattr, &iterstruct);
-			if (dbus_message_iter_get_arg_type(&iterstruct) == DBUS_TYPE_INT32) {
-				dbus_message_iter_get_basic(&iterstruct, &i);
-				dbus_message_iter_next(&iterstruct);
-				attr->u.pcoord->pro=i;
-			} else
-				ret=0;
-			if (dbus_message_iter_get_arg_type(&iterstruct) == DBUS_TYPE_INT32) {
-				dbus_message_iter_get_basic(&iterstruct, &i);
-				dbus_message_iter_next(&iterstruct);
-				attr->u.pcoord->x=i;
-			} else
-				ret=0;
-			if (dbus_message_iter_get_arg_type(&iterstruct) == DBUS_TYPE_INT32) {
-				dbus_message_iter_get_basic(&iterstruct, &i);
-				attr->u.pcoord->y=i;
-			} else
-				ret=0;
-			if (!ret) {
-				g_free(attr->u.pcoord);
-				attr->u.pcoord=NULL;
-			}
-			return ret;
-		}
-	}
-	if (attr->type == attr_callback) {
-		struct dbus_callback *callback=object_get_from_message_arg(&iterattr, "callback");
-		if (callback) {
-			attr->u.callback=callback->callback;
-			return 1;
-		}
-	}
-	return 0;
+    }
+    if (attr->type == attr_callback) {
+        struct dbus_callback *callback=object_get_from_message_arg(&iterattr, "callback");
+        if (callback) {
+            attr->u.callback=callback->callback;
+            return 1;
+        }
+    }
+    return 0;
 }
 
 static int
-decode_attr(DBusMessage *message, struct attr *attr)
-{
-	DBusMessageIter iter;
+decode_attr(DBusMessage *message, struct attr *attr) {
+    DBusMessageIter iter;
 
-	dbus_message_iter_init(message, &iter);
-	return decode_attr_from_iter(&iter, attr);
+    dbus_message_iter_init(message, &iter);
+    return decode_attr_from_iter(&iter, attr);
 }
 
 static void
-destroy_attr(struct attr *attr)
-{
-	if(attr->type > attr_type_double_begin && attr->type < attr_type_double_end) {
-		g_free(attr->u.numd);
-	}
+destroy_attr(struct attr *attr) {
+    if(attr->type > attr_type_double_begin && attr->type < attr_type_double_end) {
+        g_free(attr->u.numd);
+    }
 }
 
 static char *
-get_iter_name(char *type)
-{
-	return g_strdup_printf("%s_attr_iter",type);
-}
-
-static DBusHandlerResult
-request_attr_iter(DBusConnection *connection, DBusMessage *message, char *type, struct attr_iter *(*func)(void))
-{
-	DBusMessage *reply;
-	char *iter_name;
-	char *opath;
-	struct attr_iter *attr_iter;
-
-	attr_iter=(*func)();
-	iter_name=get_iter_name(type);
-	opath=object_new(iter_name,attr_iter);
-	g_free(iter_name);
-	reply = dbus_message_new_method_return(message);
-	dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &opath, DBUS_TYPE_INVALID);
-	dbus_connection_send (connection, reply, NULL);
-	dbus_message_unref (reply);
-
-	return DBUS_HANDLER_RESULT_HANDLED;
-}
+get_iter_name(char *type) {
+    return g_strdup_printf("%s_attr_iter",type);
+}
+
+static DBusHandlerResult
+request_attr_iter(DBusConnection *connection, DBusMessage *message, char *type, struct attr_iter *(*func)(void)) {
+    DBusMessage *reply;
+    char *iter_name;
+    char *opath;
+    struct attr_iter *attr_iter;
+
+    attr_iter=(*func)();
+    iter_name=get_iter_name(type);
+    opath=object_new(iter_name,attr_iter);
+    g_free(iter_name);
+    reply = dbus_message_new_method_return(message);
+    dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &opath, DBUS_TYPE_INVALID);
+    dbus_connection_send (connection, reply, NULL);
+    dbus_message_unref (reply);
+
+    return DBUS_HANDLER_RESULT_HANDLED;
+}
+
+static DBusHandlerResult
+request_attr_iter_destroy(DBusConnection *connection, DBusMessage *message, char *type,
+                          void (*func)(struct attr_iter *)) {
+    struct attr_iter *attr_iter;
+    DBusMessageIter iter;
+    char *iter_name;
+
+    dbus_message_iter_init(message, &iter);
+    iter_name=get_iter_name(type);
+    attr_iter=object_get_from_message_arg(&iter, iter_name);
+    g_free(iter_name);
+    if (! attr_iter)
+        return dbus_error_invalid_object_path_parameter(connection, message);
+    object_destroy(NULL, attr_iter);
+    func(attr_iter);
+
+    return empty_reply(connection, message);
+}
+
+static DBusHandlerResult
+request_destroy(DBusConnection *connection, DBusMessage *message, char *type, void *data, void (*func)(void *)) {
+    if (!data)
+        data=object_get_from_message(message, type);
+    if (!data)
+        return dbus_error_invalid_object_path(connection, message);
+    object_destroy(NULL, data);
+    func(data);
+
+    return empty_reply(connection, message);
+}
+
 
 static DBusHandlerResult
-request_attr_iter_destroy(DBusConnection *connection, DBusMessage *message, char *type, void (*func)(struct attr_iter *))
-{
-	struct attr_iter *attr_iter;
-	DBusMessageIter iter;
-	char *iter_name;
-
-	dbus_message_iter_init(message, &iter);
-	iter_name=get_iter_name(type);
-	attr_iter=object_get_from_message_arg(&iter, iter_name);
-	g_free(iter_name);
-	if (! attr_iter)
-		return dbus_error_invalid_object_path_parameter(connection, message);
-	object_destroy(NULL, attr_iter);
-	func(attr_iter);
+request_dup(DBusConnection *connection, DBusMessage *message, char *type, void *data, void *(*func)(void *)) {
+    DBusMessage *reply;
+    char *opath;
+    void *obj;
+    if (!data)
+        data=object_get_from_message(message, type);
+    if (!data)
+        return dbus_error_invalid_object_path(connection, message);
+    obj=func(data);
+    opath=object_new(type,obj);
+    reply = dbus_message_new_method_return(message);
+    dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &opath, DBUS_TYPE_INVALID);
+    dbus_connection_send (connection, reply, NULL);
+    dbus_message_unref (reply);
+
+    return DBUS_HANDLER_RESULT_HANDLED;
+}
+
+
+static DBusHandlerResult
+request_get_attr(DBusConnection *connection, DBusMessage *message, char *type, void *data, int (*func)(void *data,
+                 enum attr_type type, struct attr *attr, struct attr_iter *iter)) {
+    DBusMessage *reply;
+    DBusMessageIter iter;
+    struct attr attr;
+    enum attr_type attr_type;
+    struct attr_iter *attr_iter;
+    char *iter_name;
+
+    if (! data)
+        data = object_get_from_message(message, type);
+    if (! data)
+        return dbus_error_invalid_object_path(connection, message);
+
+    dbus_message_iter_init(message, &iter);
+    attr_type=attr_type_get_from_message(&iter);
+    if (attr_type == attr_none)
+        return dbus_error_invalid_attr_type(connection, message);
+    iter_name=get_iter_name(type);
+    attr_iter=object_get_from_message_arg(&iter, iter_name);
+    g_free(iter_name);
+    if (func(data, attr_type, &attr, attr_iter)) {
+        DBusMessageIter iter1;
+        reply = dbus_message_new_method_return(message);
+        dbus_message_iter_init_append(reply, &iter1);
+        encode_attr(&iter1, &attr);
+        dbus_connection_send (connection, reply, NULL);
+        dbus_message_unref (reply);
+        return DBUS_HANDLER_RESULT_HANDLED;
+    }
+    return dbus_error_no_data_available(connection, message);
 
-	return empty_reply(connection, message);
 }
-
+
 static DBusHandlerResult
-request_destroy(DBusConnection *connection, DBusMessage *message, char *type, void *data, void (*func)(void *))
-{
-	if (!data)
-		data=object_get_from_message(message, type);
-	if (!data)
-		return dbus_error_invalid_object_path(connection, message);
-	object_destroy(NULL, data);
-	func(data);
-
-	return empty_reply(connection, message);
-}
-
-
-static DBusHandlerResult
-request_dup(DBusConnection *connection, DBusMessage *message, char *type, void *data, void *(*func)(void *))
-{
-	DBusMessage *reply;
-	char *opath;
-	void *obj;
-	if (!data)
-		data=object_get_from_message(message, type);
-	if (!data)
-		return dbus_error_invalid_object_path(connection, message);
-	obj=func(data);
-	opath=object_new(type,obj);
-	reply = dbus_message_new_method_return(message);
-	dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &opath, DBUS_TYPE_INVALID);
-	dbus_connection_send (connection, reply, NULL);
-	dbus_message_unref (reply);
-
-	return DBUS_HANDLER_RESULT_HANDLED;
-}
-
-
-static DBusHandlerResult
-request_get_attr(DBusConnection *connection, DBusMessage *message, char *type, void *data, int (*func)(void *data, enum attr_type type, struct attr *attr, struct attr_iter *iter))
-{
-	DBusMessage *reply;
-	DBusMessageIter iter;
-	struct attr attr;
-	enum attr_type attr_type;
-	struct attr_iter *attr_iter;
-	char *iter_name;
-
-	if (! data)
-		data = object_get_from_message(message, type);
-	if (! data)
-		return dbus_error_invalid_object_path(connection, message);
-
-	dbus_message_iter_init(message, &iter);
-	attr_type=attr_type_get_from_message(&iter);
-	if (attr_type == attr_none)
-		return dbus_error_invalid_attr_type(connection, message);
-	iter_name=get_iter_name(type);
-	attr_iter=object_get_from_message_arg(&iter, iter_name);
-	g_free(iter_name);
-	if (func(data, attr_type, &attr, attr_iter)) {
-		DBusMessageIter iter1;
-		reply = dbus_message_new_method_return(message);
-		dbus_message_iter_init_append(reply, &iter1);
-		encode_attr(&iter1, &attr);
-		dbus_connection_send (connection, reply, NULL);
-		dbus_message_unref (reply);
-		return DBUS_HANDLER_RESULT_HANDLED;
-	}
-	return dbus_error_no_data_available(connection, message);
-
-}
-
-static DBusHandlerResult
-request_command(DBusConnection *connection, DBusMessage *message, char *type, void *data, int (*func)(void *data, enum attr_type type, struct attr *attr, struct attr_iter *iter))
-{
-	DBusMessageIter iter;
-	struct attr attr;
-	char *command;
-
-	if (! data)
-		data = object_get_from_message(message, type);
-	if (! data)
-		return dbus_error_invalid_object_path(connection, message);
-
-	dbus_message_iter_init(message, &iter);
-	if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
-		return dbus_error_invalid_parameter(connection, message);
-	dbus_message_iter_get_basic(&iter, &command);
-	dbus_message_iter_next(&iter);
-	if (func(data, attr_callback_list, &attr, NULL)) {
-		int valid=0;
-                callback_list_call_attr_4(attr.u.callback_list, attr_command, command, NULL, NULL, &valid);
-	}
-	return empty_reply(connection, message);
-
-}
+request_command(DBusConnection *connection, DBusMessage *message, char *type, void *data, int (*func)(void *data,
+                enum attr_type type, struct attr *attr, struct attr_iter *iter)) {
+    DBusMessageIter iter;
+    struct attr attr;
+    char *command;
+
+    if (! data)
+        data = object_get_from_message(message, type);
+    if (! data)
+        return dbus_error_invalid_object_path(connection, message);
+
+    dbus_message_iter_init(message, &iter);
+    if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
+        return dbus_error_invalid_parameter(connection, message);
+    dbus_message_iter_get_basic(&iter, &command);
+    dbus_message_iter_next(&iter);
+    if (func(data, attr_callback_list, &attr, NULL)) {
+        int valid=0;
+        callback_list_call_attr_4(attr.u.callback_list, attr_command, command, NULL, NULL, &valid);
+    }
+    return empty_reply(connection, message);
+
+}
 
 static DBusHandlerResult
-request_set_add_remove_attr(DBusConnection *connection, DBusMessage *message, char *type, void *data, int (*func)(void *data, struct attr *attr))
-{
-    	struct attr attr;
-	int ret;
-
-	if (! data)
-		data = object_get_from_message(message, type);
-	if (! data)
-		return dbus_error_invalid_object_path(connection, message);
-
-	if (decode_attr(message, &attr)) {
-		ret=(*func)(data, &attr);
-		destroy_attr(&attr);
-		if (ret)
-			return empty_reply(connection, message);
-		dbg(lvl_error,"failed to set/add/remove attr");
-	} else {
-		dbg(lvl_error,"failed to decode attr");
-	}
-    	return dbus_error_invalid_parameter(connection, message);
+request_set_add_remove_attr(DBusConnection *connection, DBusMessage *message, char *type, void *data,
+                            int (*func)(void *data, struct attr *attr)) {
+    struct attr attr;
+    int ret;
+
+    if (! data)
+        data = object_get_from_message(message, type);
+    if (! data)
+        return dbus_error_invalid_object_path(connection, message);
+
+    if (decode_attr(message, &attr)) {
+        ret=(*func)(data, &attr);
+        destroy_attr(&attr);
+        if (ret)
+            return empty_reply(connection, message);
+        dbg(lvl_error,"failed to set/add/remove attr");
+    } else {
+        dbg(lvl_error,"failed to decode attr");
+    }
+    return dbus_error_invalid_parameter(connection, message);
 }
 
 /* callback */
 
 
 static void
-dbus_callback_emit_signal(struct dbus_callback *dbus_callback)
-{
-	DBusMessage* msg;
-	msg = dbus_message_new_signal(object_path, service_name, dbus_callback->signal);
-	if (msg) {
-		dbus_connection_send(connection, msg, &dbus_serial);
-		dbus_connection_flush(connection);
-		dbus_message_unref(msg);
-	}
+dbus_callback_emit_signal(struct dbus_callback *dbus_callback) {
+    DBusMessage* msg;
+    msg = dbus_message_new_signal(object_path, service_name, dbus_callback->signal);
+    if (msg) {
+        dbus_connection_send(connection, msg, &dbus_serial);
+        dbus_connection_flush(connection);
+        dbus_message_unref(msg);
+    }
 }
 
 static void
-request_callback_destroy_do(struct dbus_callback *data)
-{
-	callback_destroy(data->callback);
-	g_free(data->signal);
-	g_free(data);
+request_callback_destroy_do(struct dbus_callback *data) {
+    callback_destroy(data->callback);
+    g_free(data->signal);
+    g_free(data);
 }
 
 static DBusHandlerResult
-request_callback_destroy(DBusConnection *connection, DBusMessage *message)
-{
-	return request_destroy(connection, message, "callback", NULL, (void (*)(void *)) request_callback_destroy_do);
+request_callback_destroy(DBusConnection *connection, DBusMessage *message) {
+    return request_destroy(connection, message, "callback", NULL, (void (*)(void *)) request_callback_destroy_do);
 }
 
 static DBusHandlerResult
-request_callback_new(DBusConnection *connection, DBusMessage *message)
-{
-	DBusMessageIter iter;
-	DBusMessage *reply;
-	struct dbus_callback *callback;
-	char *signal,*opath;
-	enum attr_type type;
-
-	dbus_message_iter_init(message, &iter);
-	if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
-		return dbus_error_invalid_parameter(connection, message);
-	dbus_message_iter_get_basic(&iter, &signal);
-	dbus_message_iter_next(&iter);
-	callback=g_new0(struct dbus_callback, 1);
-	callback->signal=g_strdup(signal);
-
-	if (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_STRING) {
-		type=attr_type_get_from_message(&iter);
-		callback->callback=callback_new_attr_1(callback_cast(dbus_callback_emit_signal), type, callback);
-	} else
-		callback->callback=callback_new_1(callback_cast(dbus_callback_emit_signal), callback);
-	opath=object_new("callback", callback);
-	reply = dbus_message_new_method_return(message);
-	dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &opath, DBUS_TYPE_INVALID);
-	dbus_connection_send (connection, reply, NULL);
-	dbus_message_unref (reply);
-	return DBUS_HANDLER_RESULT_HANDLED;
+request_callback_new(DBusConnection *connection, DBusMessage *message) {
+    DBusMessageIter iter;
+    DBusMessage *reply;
+    struct dbus_callback *callback;
+    char *signal,*opath;
+    enum attr_type type;
+
+    dbus_message_iter_init(message, &iter);
+    if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
+        return dbus_error_invalid_parameter(connection, message);
+    dbus_message_iter_get_basic(&iter, &signal);
+    dbus_message_iter_next(&iter);
+    callback=g_new0(struct dbus_callback, 1);
+    callback->signal=g_strdup(signal);
+
+    if (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_STRING) {
+        type=attr_type_get_from_message(&iter);
+        callback->callback=callback_new_attr_1(callback_cast(dbus_callback_emit_signal), type, callback);
+    } else
+        callback->callback=callback_new_1(callback_cast(dbus_callback_emit_signal), callback);
+    opath=object_new("callback", callback);
+    reply = dbus_message_new_method_return(message);
+    dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &opath, DBUS_TYPE_INVALID);
+    dbus_connection_send (connection, reply, NULL);
+    dbus_message_unref (reply);
+    return DBUS_HANDLER_RESULT_HANDLED;
 }
 
 /* config */
 static DBusHandlerResult
-request_config_get_attr(DBusConnection *connection, DBusMessage *message)
-{
-	return request_get_attr(connection, message, "config", config, (int (*)(void *, enum attr_type, struct attr *, struct attr_iter *))config_get_attr);
+request_config_get_attr(DBusConnection *connection, DBusMessage *message) {
+    return request_get_attr(connection, message, "config", config, (int (*)(void *, enum attr_type, struct attr *,
+                            struct attr_iter *))config_get_attr);
 }
 
 static DBusHandlerResult
-request_config_attr_iter(DBusConnection *connection, DBusMessage *message)
-{
-	return request_attr_iter(connection, message, "config", (struct attr_iter * (*)(void))config_attr_iter_new);
+request_config_attr_iter(DBusConnection *connection, DBusMessage *message) {
+    return request_attr_iter(connection, message, "config", (struct attr_iter * (*)(void))config_attr_iter_new);
 }
 
 static DBusHandlerResult
-request_config_attr_iter_destroy(DBusConnection *connection, DBusMessage *message)
-{
-	return request_attr_iter_destroy(connection, message, "config", (void (*)(struct attr_iter *))config_attr_iter_destroy);
+request_config_attr_iter_destroy(DBusConnection *connection, DBusMessage *message) {
+    return request_attr_iter_destroy(connection, message, "config", (void (*)(struct attr_iter *))config_attr_iter_destroy);
 }
 
 
@@ -920,66 +886,65 @@ request_config_attr_iter_destroy(DBusConnection *connection, DBusMessage *messag
 /* graphics */
 
 static DBusHandlerResult
-request_graphics_get_data(DBusConnection *connection, DBusMessage *message)
-{
-	struct graphics *graphics;
-	char *data;
-	struct graphics_data_image *image;
-	DBusMessage *reply;
+request_graphics_get_data(DBusConnection *connection, DBusMessage *message) {
+    struct graphics *graphics;
+    char *data;
+    struct graphics_data_image *image;
+    DBusMessage *reply;
 
-	graphics = object_get_from_message(message, "graphics");
-	if (! graphics)
-		return dbus_error_invalid_object_path(connection, message);
+    graphics = object_get_from_message(message, "graphics");
+    if (! graphics)
+        return dbus_error_invalid_object_path(connection, message);
 
-        if (!dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &data, DBUS_TYPE_INVALID))
-    		return dbus_error_invalid_parameter(connection, message);
-	image=graphics_get_data(graphics, data);
-	if (image) {
-		DBusMessageIter iter1,iter2;
-		reply = dbus_message_new_method_return(message);
+    if (!dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &data, DBUS_TYPE_INVALID))
+        return dbus_error_invalid_parameter(connection, message);
+    image=graphics_get_data(graphics, data);
+    if (image) {
+        DBusMessageIter iter1,iter2;
+        reply = dbus_message_new_method_return(message);
 #if 0
-		dbus_message_append_args(reply, DBUS_TYPE_STRING, &result, DBUS_TYPE_INVALID);
+        dbus_message_append_args(reply, DBUS_TYPE_STRING, &result, DBUS_TYPE_INVALID);
 #endif
-		dbus_message_iter_init_append(reply, &iter1);
-		dbus_message_iter_open_container(&iter1, DBUS_TYPE_ARRAY, "y", &iter2);
-		if (image->data && image->size)
-			dbus_message_iter_append_fixed_array(&iter2, DBUS_TYPE_BYTE, &image->data, image->size);
-		dbus_message_iter_close_container(&iter1, &iter2);
-		dbus_connection_send (connection, reply, NULL);
-		dbus_message_unref (reply);
-		return DBUS_HANDLER_RESULT_HANDLED;
-	}
-	return dbus_error_no_data_available(connection, message);
+        dbus_message_iter_init_append(reply, &iter1);
+        dbus_message_iter_open_container(&iter1, DBUS_TYPE_ARRAY, "y", &iter2);
+        if (image->data && image->size)
+            dbus_message_iter_append_fixed_array(&iter2, DBUS_TYPE_BYTE, &image->data, image->size);
+        dbus_message_iter_close_container(&iter1, &iter2);
+        dbus_connection_send (connection, reply, NULL);
+        dbus_message_unref (reply);
+        return DBUS_HANDLER_RESULT_HANDLED;
+    }
+    return dbus_error_no_data_available(connection, message);
 }
 
 /* gui */
 
 static DBusHandlerResult
-request_gui_get_attr(DBusConnection *connection, DBusMessage *message)
-{
-	return request_get_attr(connection, message, "gui", NULL, (int (*)(void *, enum attr_type, struct attr *, struct attr_iter *))gui_get_attr);
+request_gui_get_attr(DBusConnection *connection, DBusMessage *message) {
+    return request_get_attr(connection, message, "gui", NULL, (int (*)(void *, enum attr_type, struct attr *,
+                            struct attr_iter *))gui_get_attr);
 }
 
 static DBusHandlerResult
-request_gui_command(DBusConnection *connection, DBusMessage *message)
-{
-	return request_command(connection, message, "gui", NULL, (int (*)(void *, enum attr_type, struct attr *, struct attr_iter *))gui_get_attr);
+request_gui_command(DBusConnection *connection, DBusMessage *message) {
+    return request_command(connection, message, "gui", NULL, (int (*)(void *, enum attr_type, struct attr *,
+                           struct attr_iter *))gui_get_attr);
 }
 
 
 
 static DBusHandlerResult
-request_graphics_set_attr(DBusConnection *connection, DBusMessage *message)
-{
-	return request_set_add_remove_attr(connection, message, "graphics", NULL, (int (*)(void *, struct attr *))graphics_set_attr);
+request_graphics_set_attr(DBusConnection *connection, DBusMessage *message) {
+    return request_set_add_remove_attr(connection, message, "graphics", NULL, (int (*)(void *,
+                                       struct attr *))graphics_set_attr);
 }
 
 /* layout */
 
 static DBusHandlerResult
-request_layout_get_attr(DBusConnection *connection, DBusMessage *message)
-{
-	return request_get_attr(connection, message, "layout", NULL, (int (*)(void *, enum attr_type, struct attr *, struct attr_iter *))layout_get_attr);
+request_layout_get_attr(DBusConnection *connection, DBusMessage *message) {
+    return request_get_attr(connection, message, "layout", NULL, (int (*)(void *, enum attr_type, struct attr *,
+                            struct attr_iter *))layout_get_attr);
 }
 
 
@@ -987,167 +952,156 @@ request_layout_get_attr(DBusConnection *connection, DBusMessage *message)
 /* map */
 
 static DBusHandlerResult
-request_map_get_attr(DBusConnection *connection, DBusMessage *message)
-{
-	return request_get_attr(connection, message, "map", NULL, (int (*)(void *, enum attr_type, struct attr *, struct attr_iter *))map_get_attr);
+request_map_get_attr(DBusConnection *connection, DBusMessage *message) {
+    return request_get_attr(connection, message, "map", NULL, (int (*)(void *, enum attr_type, struct attr *,
+                            struct attr_iter *))map_get_attr);
 }
 
 
 static DBusHandlerResult
-request_map_set_attr(DBusConnection *connection, DBusMessage *message)
-{
-	return request_set_add_remove_attr(connection, message, "map", NULL, (int (*)(void *, struct attr *))map_set_attr);
+request_map_set_attr(DBusConnection *connection, DBusMessage *message) {
+    return request_set_add_remove_attr(connection, message, "map", NULL, (int (*)(void *, struct attr *))map_set_attr);
 }
 
 static DBusHandlerResult
-request_map_dump(DBusConnection *connection, DBusMessage *message)
-{
-	DBusMessageIter iter;
-	struct map *map;
-
-	map=object_get_from_message(message, "map");
-	if (! map)
-		return dbus_error_invalid_object_path(connection, message);
-
-	dbus_message_iter_init(message, &iter);
-	if(!strcmp(dbus_message_iter_get_signature(&iter), "s")) {
-		char *file;
-		FILE *f;
-		dbus_message_iter_get_basic(&iter, &file);
-		/* dbg(0,"File '%s'",file); */
-		f=fopen(file,"w");
-		map_dump_filedesc(map,f);
-		fclose(f);
-		return empty_reply(connection, message);
-	}
-	return dbus_error_invalid_parameter(connection, message);
+request_map_dump(DBusConnection *connection, DBusMessage *message) {
+    DBusMessageIter iter;
+    struct map *map;
+
+    map=object_get_from_message(message, "map");
+    if (! map)
+        return dbus_error_invalid_object_path(connection, message);
+
+    dbus_message_iter_init(message, &iter);
+    if(!strcmp(dbus_message_iter_get_signature(&iter), "s")) {
+        char *file;
+        FILE *f;
+        dbus_message_iter_get_basic(&iter, &file);
+        /* dbg(0,"File '%s'",file); */
+        f=fopen(file,"w");
+        map_dump_filedesc(map,f);
+        fclose(f);
+        return empty_reply(connection, message);
+    }
+    return dbus_error_invalid_parameter(connection, message);
 }
 
 
 /* mapset */
 
 static DBusHandlerResult
-request_mapset_attr_iter(DBusConnection *connection, DBusMessage *message)
-{
-	return request_attr_iter(connection, message, "mapset", (struct attr_iter * (*)(void))mapset_attr_iter_new);
+request_mapset_attr_iter(DBusConnection *connection, DBusMessage *message) {
+    return request_attr_iter(connection, message, "mapset", (struct attr_iter * (*)(void))mapset_attr_iter_new);
 }
 
 static DBusHandlerResult
-request_mapset_attr_iter_destroy(DBusConnection *connection, DBusMessage *message)
-{
-	return request_attr_iter_destroy(connection, message, "mapset", (void (*)(struct attr_iter *))mapset_attr_iter_destroy);
+request_mapset_attr_iter_destroy(DBusConnection *connection, DBusMessage *message) {
+    return request_attr_iter_destroy(connection, message, "mapset", (void (*)(struct attr_iter *))mapset_attr_iter_destroy);
 }
 
 static DBusHandlerResult
-request_mapset_get_attr(DBusConnection *connection, DBusMessage *message)
-{
-	return request_get_attr(connection, message, "mapset", NULL, (int (*)(void *, enum attr_type, struct attr *, struct attr_iter *))mapset_get_attr);
+request_mapset_get_attr(DBusConnection *connection, DBusMessage *message) {
+    return request_get_attr(connection, message, "mapset", NULL, (int (*)(void *, enum attr_type, struct attr *,
+                            struct attr_iter *))mapset_get_attr);
 }
 
 /* navigation */
 
 static DBusHandlerResult
-request_navigation_get_attr(DBusConnection *connection, DBusMessage *message)
-{
-	return request_get_attr(connection, message, "navigation", NULL, (int (*)(void *, enum attr_type, struct attr *, struct attr_iter *))navigation_get_attr);
+request_navigation_get_attr(DBusConnection *connection, DBusMessage *message) {
+    return request_get_attr(connection, message, "navigation", NULL, (int (*)(void *, enum attr_type, struct attr *,
+                            struct attr_iter *))navigation_get_attr);
 }
 
 /* osd */
 
 static DBusHandlerResult
-request_osd_get_attr(DBusConnection *connection, DBusMessage *message)
-{
-	return request_get_attr(connection, message, "osd", NULL, (int (*)(void *, enum attr_type, struct attr *, struct attr_iter *))osd_get_attr);
+request_osd_get_attr(DBusConnection *connection, DBusMessage *message) {
+    return request_get_attr(connection, message, "osd", NULL, (int (*)(void *, enum attr_type, struct attr *,
+                            struct attr_iter *))osd_get_attr);
 }
 
 
 static DBusHandlerResult
-request_osd_set_attr(DBusConnection *connection, DBusMessage *message)
-{
-	return request_set_add_remove_attr(connection, message, "osd", NULL, (int (*)(void *, struct attr *))osd_set_attr);
+request_osd_set_attr(DBusConnection *connection, DBusMessage *message) {
+    return request_set_add_remove_attr(connection, message, "osd", NULL, (int (*)(void *, struct attr *))osd_set_attr);
 }
 
 /* roadprofile */
 
 static DBusHandlerResult
-request_roadprofile_get_attr(DBusConnection *connection, DBusMessage *message)
-{
-	return request_get_attr(connection, message, "roadprofile", NULL, (int (*)(void *, enum attr_type, struct attr *, struct attr_iter *))roadprofile_get_attr);
+request_roadprofile_get_attr(DBusConnection *connection, DBusMessage *message) {
+    return request_get_attr(connection, message, "roadprofile", NULL, (int (*)(void *, enum attr_type, struct attr *,
+                            struct attr_iter *))roadprofile_get_attr);
 }
 
 
 static DBusHandlerResult
-request_roadprofile_set_attr(DBusConnection *connection, DBusMessage *message)
-{
-	return request_set_add_remove_attr(connection, message, "roadprofile", NULL, (int (*)(void *, struct attr *))roadprofile_set_attr);
+request_roadprofile_set_attr(DBusConnection *connection, DBusMessage *message) {
+    return request_set_add_remove_attr(connection, message, "roadprofile", NULL, (int (*)(void *,
+                                       struct attr *))roadprofile_set_attr);
 }
 
 static DBusHandlerResult
-request_roadprofile_attr_iter(DBusConnection *connection, DBusMessage *message)
-{
-	return request_attr_iter(connection, message, "roadprofile", (struct attr_iter * (*)(void))roadprofile_attr_iter_new);
+request_roadprofile_attr_iter(DBusConnection *connection, DBusMessage *message) {
+    return request_attr_iter(connection, message, "roadprofile", (struct attr_iter * (*)(void))roadprofile_attr_iter_new);
 }
 
 static DBusHandlerResult
-request_roadprofile_attr_iter_destroy(DBusConnection *connection, DBusMessage *message)
-{
-	return request_attr_iter_destroy(connection, message, "roadprofile", (void (*)(struct attr_iter *))roadprofile_attr_iter_destroy);
+request_roadprofile_attr_iter_destroy(DBusConnection *connection, DBusMessage *message) {
+    return request_attr_iter_destroy(connection, message, "roadprofile",
+                                     (void (*)(struct attr_iter *))roadprofile_attr_iter_destroy);
 }
 
 /* route */
 
 static DBusHandlerResult
-request_route_get_attr(DBusConnection *connection, DBusMessage *message)
-{
-	return request_get_attr(connection, message, "route", NULL, (int (*)(void *, enum attr_type, struct attr *, struct attr_iter *))route_get_attr);
+request_route_get_attr(DBusConnection *connection, DBusMessage *message) {
+    return request_get_attr(connection, message, "route", NULL, (int (*)(void *, enum attr_type, struct attr *,
+                            struct attr_iter *))route_get_attr);
 }
 
 
 static DBusHandlerResult
-request_route_set_attr(DBusConnection *connection, DBusMessage *message)
-{
-	return request_set_add_remove_attr(connection, message, "route", NULL, (int (*)(void *, struct attr *))route_set_attr);
+request_route_set_attr(DBusConnection *connection, DBusMessage *message) {
+    return request_set_add_remove_attr(connection, message, "route", NULL, (int (*)(void *, struct attr *))route_set_attr);
 }
 
 static DBusHandlerResult
-request_route_add_attr(DBusConnection *connection, DBusMessage *message)
-{
-	return request_set_add_remove_attr(connection, message, "route", NULL, (int (*)(void *, struct attr *))route_add_attr);
+request_route_add_attr(DBusConnection *connection, DBusMessage *message) {
+    return request_set_add_remove_attr(connection, message, "route", NULL, (int (*)(void *, struct attr *))route_add_attr);
 }
 
 static DBusHandlerResult
-request_route_remove_attr(DBusConnection *connection, DBusMessage *message)
-{
-	return request_set_add_remove_attr(connection, message, "route", NULL, (int (*)(void *, struct attr *))route_remove_attr);
+request_route_remove_attr(DBusConnection *connection, DBusMessage *message) {
+    return request_set_add_remove_attr(connection, message, "route", NULL, (int (*)(void *,
+                                       struct attr *))route_remove_attr);
 }
 
 static DBusHandlerResult
-request_route_destroy(DBusConnection *connection, DBusMessage *message)
-{
-	return request_destroy(connection, message, "route", NULL, (void (*)(void *)) route_destroy);
+request_route_destroy(DBusConnection *connection, DBusMessage *message) {
+    return request_destroy(connection, message, "route", NULL, (void (*)(void *)) route_destroy);
 }
 
 static DBusHandlerResult
-request_route_dup(DBusConnection *connection, DBusMessage *message)
-{
-	return request_dup(connection, message, "route", NULL, (void *(*)(void *)) route_dup);
+request_route_dup(DBusConnection *connection, DBusMessage *message) {
+    return request_dup(connection, message, "route", NULL, (void *(*)(void *)) route_dup);
 }
 
 
 /* navit */
 
 static DBusHandlerResult
-request_navit_draw(DBusConnection *connection, DBusMessage *message)
-{
-	struct navit *navit;
+request_navit_draw(DBusConnection *connection, DBusMessage *message) {
+    struct navit *navit;
 
-	navit=object_get_from_message(message, "navit");
-	if (! navit)
-		return dbus_error_invalid_object_path(connection, message);
+    navit=object_get_from_message(message, "navit");
+    if (! navit)
+        return dbus_error_invalid_object_path(connection, message);
 
-	navit_draw(navit);
+    navit_draw(navit);
 
-	return empty_reply(connection, message);
+    return empty_reply(connection, message);
 }
 
 
@@ -1160,32 +1114,31 @@ request_navit_draw(DBusConnection *connection, DBusMessage *message)
  * @returns Returns 1 when everything went right, otherwise 0
  */
 static int
-point_get_from_message(DBusMessage *message, DBusMessageIter *iter, struct point *p)
-{
-	DBusMessageIter iter2;
+point_get_from_message(DBusMessage *message, DBusMessageIter *iter, struct point *p) {
+    DBusMessageIter iter2;
 
-	dbg(lvl_debug,"%s", dbus_message_iter_get_signature(iter));
+    dbg(lvl_debug,"%s", dbus_message_iter_get_signature(iter));
 
-	dbus_message_iter_recurse(iter, &iter2);
+    dbus_message_iter_recurse(iter, &iter2);
 
-	if (dbus_message_iter_get_arg_type(&iter2) != DBUS_TYPE_INT32)
-		return 0;
-	dbus_message_iter_get_basic(&iter2, &p->x);
+    if (dbus_message_iter_get_arg_type(&iter2) != DBUS_TYPE_INT32)
+        return 0;
+    dbus_message_iter_get_basic(&iter2, &p->x);
 
-	dbus_message_iter_next(&iter2);
+    dbus_message_iter_next(&iter2);
 
-	if (dbus_message_iter_get_arg_type(&iter2) != DBUS_TYPE_INT32)
-		return 0;
-	dbus_message_iter_get_basic(&iter2, &p->y);
+    if (dbus_message_iter_get_arg_type(&iter2) != DBUS_TYPE_INT32)
+        return 0;
+    dbus_message_iter_get_basic(&iter2, &p->y);
 
-	dbg(lvl_debug, " x -> %x  y -> %x", p->x, p->y);
+    dbg(lvl_debug, " x -> %x  y -> %x", p->x, p->y);
 
-	dbus_message_iter_next(&iter2);
+    dbus_message_iter_next(&iter2);
 
-	if (dbus_message_iter_get_arg_type(&iter2) != DBUS_TYPE_INVALID)
-		return 0;
+    if (dbus_message_iter_get_arg_type(&iter2) != DBUS_TYPE_INVALID)
+        return 0;
 
-	return 1;
+    return 1;
 }
 
 /**
@@ -1196,19 +1149,18 @@ point_get_from_message(DBusMessage *message, DBusMessageIter *iter, struct point
  */
 
 static DBusHandlerResult
-request_navit_add_message(DBusConnection *connection, DBusMessage *message)
-{
-	struct navit *navit;
-	char *usermessage;
+request_navit_add_message(DBusConnection *connection, DBusMessage *message) {
+    struct navit *navit;
+    char *usermessage;
 
     DBusMessageIter iter;
 
-	navit=object_get_from_message(message, "navit");
-	if (! navit)
-		return dbus_error_invalid_object_path(connection, message);
+    navit=object_get_from_message(message, "navit");
+    if (! navit)
+        return dbus_error_invalid_object_path(connection, message);
 
-	dbus_message_iter_init(message, &iter);
-	dbus_message_iter_get_basic(&iter, &usermessage);
+    dbus_message_iter_init(message, &iter);
+    dbus_message_iter_get_basic(&iter, &usermessage);
 
     navit_add_message(navit, usermessage);
 
@@ -1224,23 +1176,22 @@ request_navit_add_message(DBusConnection *connection, DBusMessage *message)
  */
 
 static DBusHandlerResult
-request_navit_set_center(DBusConnection *connection, DBusMessage *message)
-{
-	struct pcoord pc;
-	struct navit *navit;
-	DBusMessageIter iter;
+request_navit_set_center(DBusConnection *connection, DBusMessage *message) {
+    struct pcoord pc;
+    struct navit *navit;
+    DBusMessageIter iter;
 
-	navit=object_get_from_message(message, "navit");
-	if (! navit)
-		return dbus_error_invalid_object_path(connection, message);
+    navit=object_get_from_message(message, "navit");
+    if (! navit)
+        return dbus_error_invalid_object_path(connection, message);
 
-	dbus_message_iter_init(message, &iter);
+    dbus_message_iter_init(message, &iter);
 
-	if (!pcoord_get_from_message(message, &iter, &pc))
-		return dbus_error_invalid_parameter(connection, message);
+    if (!pcoord_get_from_message(message, &iter, &pc))
+        return dbus_error_invalid_parameter(connection, message);
 
-	navit_set_center(navit, &pc, 0);
-	return empty_reply(connection, message);
+    navit_set_center(navit, &pc, 0);
+    return empty_reply(connection, message);
 }
 
 /**
@@ -1250,22 +1201,21 @@ request_navit_set_center(DBusConnection *connection, DBusMessage *message)
  * @returns An empty reply if everything went right, otherwise DBUS_HANDLER_RESULT_NOT_YET_HANDLED
  */
 static DBusHandlerResult
-request_navit_set_center_screen(DBusConnection *connection, DBusMessage *message)
-{
-	struct point p;
-	struct navit *navit;
-	DBusMessageIter iter;
+request_navit_set_center_screen(DBusConnection *connection, DBusMessage *message) {
+    struct point p;
+    struct navit *navit;
+    DBusMessageIter iter;
 
-	navit=object_get_from_message(message, "navit");
-	if (! navit)
-		return dbus_error_invalid_object_path(connection, message);
+    navit=object_get_from_message(message, "navit");
+    if (! navit)
+        return dbus_error_invalid_object_path(connection, message);
 
-	dbus_message_iter_init(message, &iter);
+    dbus_message_iter_init(message, &iter);
 
-	if (!point_get_from_message(message, &iter, &p))
-		return dbus_error_invalid_parameter(connection, message);
-	navit_set_center_screen(navit, &p, 0);
-	return empty_reply(connection, message);
+    if (!point_get_from_message(message, &iter, &p))
+        return dbus_error_invalid_parameter(connection, message);
+    navit_set_center_screen(navit, &p, 0);
+    return empty_reply(connection, message);
 }
 
 /**
@@ -1275,27 +1225,26 @@ request_navit_set_center_screen(DBusConnection *connection, DBusMessage *message
  * @returns An empty reply if everything went right, otherwise DBUS_HANDLER_RESULT_NOT_YET_HANDLED
  */
 static DBusHandlerResult
-request_navit_set_layout(DBusConnection *connection, DBusMessage *message)
-{
-	char *new_layout_name;
-	struct navit *navit;
-	struct attr attr;
-	struct attr_iter *iter;
+request_navit_set_layout(DBusConnection *connection, DBusMessage *message) {
+    char *new_layout_name;
+    struct navit *navit;
+    struct attr attr;
+    struct attr_iter *iter;
 
-	navit=object_get_from_message(message, "navit");
-	if (! navit)
-		return dbus_error_invalid_object_path(connection, message);
+    navit=object_get_from_message(message, "navit");
+    if (! navit)
+        return dbus_error_invalid_object_path(connection, message);
 
-	if (!dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &new_layout_name, DBUS_TYPE_INVALID))
-		return dbus_error_invalid_parameter(connection, message);
+    if (!dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &new_layout_name, DBUS_TYPE_INVALID))
+        return dbus_error_invalid_parameter(connection, message);
 
-	iter=navit_attr_iter_new();
-	while(navit_get_attr(navit, attr_layout, &attr, iter)) {
-		if (strcmp(attr.u.layout->name, new_layout_name) == 0) {
-			navit_set_attr(navit, &attr);
-		}
-	}
-	return empty_reply(connection, message);
+    iter=navit_attr_iter_new();
+    while(navit_get_attr(navit, attr_layout, &attr, iter)) {
+        if (strcmp(attr.u.layout->name, new_layout_name) == 0) {
+            navit_set_attr(navit, &attr);
+        }
+    }
+    return empty_reply(connection, message);
 }
 
 /**
@@ -1305,22 +1254,21 @@ request_navit_set_layout(DBusConnection *connection, DBusMessage *message)
  * @returns An empty reply if everything went right, otherwise DBUS_HANDLER_RESULT_NOT_YET_HANDLED
  */
 static DBusHandlerResult
-request_navit_quit(DBusConnection *connection, DBusMessage *message)
-{
-        dbg(lvl_debug,"Got a quit request from DBUS");
-        struct attr navit;
-        navit.type=attr_navit;
-        struct navit *nav;
-        nav = object_get_from_message(message, "navit");
-        if (! nav)
-                return dbus_error_invalid_object_path(connection, message);
-        navit.u.navit=nav;
-        config_remove_attr(config, &navit);
-
-        struct callback *callback;
-        callback=callback_new_1(callback_cast(event_main_loop_quit), NULL);
-        event_add_timeout(1000, 1, callback);
-        return empty_reply(connection, message);
+request_navit_quit(DBusConnection *connection, DBusMessage *message) {
+    dbg(lvl_debug,"Got a quit request from DBUS");
+    struct attr navit;
+    navit.type=attr_navit;
+    struct navit *nav;
+    nav = object_get_from_message(message, "navit");
+    if (! nav)
+        return dbus_error_invalid_object_path(connection, message);
+    navit.u.navit=nav;
+    config_remove_attr(config, &navit);
+
+    struct callback *callback;
+    callback=callback_new_1(callback_cast(event_main_loop_quit), NULL);
+    event_add_timeout(1000, 1, callback);
+    return empty_reply(connection, message);
 }
 
 /**
@@ -1331,96 +1279,92 @@ request_navit_quit(DBusConnection *connection, DBusMessage *message)
  * @returns An empty reply if everything went right, otherwise `DBUS_HANDLER_RESULT_NOT_YET_HANDLED`
  */
 static DBusHandlerResult
-request_navit_traffic_inject(DBusConnection *connection, DBusMessage *message)
-{
-	char * filename;
-	struct navit *navit;
-	DBusMessageIter iter;
-	struct attr * attr;
-	struct attr_iter * a_iter;
-	struct traffic * traffic = NULL;
-	struct traffic_message ** messages;
+request_navit_traffic_inject(DBusConnection *connection, DBusMessage *message) {
+    char * filename;
+    struct navit *navit;
+    DBusMessageIter iter;
+    struct attr * attr;
+    struct attr_iter * a_iter;
+    struct traffic * traffic = NULL;
+    struct traffic_message ** messages;
 
-	navit = object_get_from_message(message, "navit");
-	if (! navit)
-		return dbus_error_invalid_object_path(connection, message);
+    navit = object_get_from_message(message, "navit");
+    if (! navit)
+        return dbus_error_invalid_object_path(connection, message);
 
-	dbus_message_iter_init(message, &iter);
+    dbus_message_iter_init(message, &iter);
 
-	dbus_message_iter_get_basic(&iter, &filename);
+    dbus_message_iter_get_basic(&iter, &filename);
 
-	attr = g_new0(struct attr, 1);
-	a_iter = navit_attr_iter_new();
-	if (navit_get_attr(navit, attr_traffic, attr, a_iter))
-		traffic = (struct traffic *) attr->u.navit_object;
-	navit_attr_iter_destroy(a_iter);
-	g_free(attr);
+    attr = g_new0(struct attr, 1);
+    a_iter = navit_attr_iter_new();
+    if (navit_get_attr(navit, attr_traffic, attr, a_iter))
+        traffic = (struct traffic *) attr->u.navit_object;
+    navit_attr_iter_destroy(a_iter);
+    g_free(attr);
 
-	if (!traffic)
-		return dbus_error_traffic_not_configured(connection, message);
+    if (!traffic)
+        return dbus_error_traffic_not_configured(connection, message);
 
-	dbg(lvl_debug, "Processing traffic feed from file %s\n", filename);
+    dbg(lvl_debug, "Processing traffic feed from file %s\n", filename);
 
-	messages = traffic_get_messages_from_xml(traffic, filename);
-	if (messages) {
-		dbg(lvl_debug, "got messages from file %s, processing\n", filename);
-		traffic_process_messages(traffic, messages);
-		g_free(messages);
-	}
+    messages = traffic_get_messages_from_xml(traffic, filename);
+    if (messages) {
+        dbg(lvl_debug, "got messages from file %s, processing\n", filename);
+        traffic_process_messages(traffic, messages);
+        g_free(messages);
+    }
 
-	return empty_reply(connection, message);
+    return empty_reply(connection, message);
 }
 
 static DBusHandlerResult
-request_navit_zoom(DBusConnection *connection, DBusMessage *message)
-{
-	int factor;
-	struct point p, *pp=NULL;
-	struct navit *navit;
-	DBusMessageIter iter;
+request_navit_zoom(DBusConnection *connection, DBusMessage *message) {
+    int factor;
+    struct point p, *pp=NULL;
+    struct navit *navit;
+    DBusMessageIter iter;
 
-	navit = object_get_from_message(message, "navit");
-	if (! navit)
-		return dbus_error_invalid_object_path(connection, message);
+    navit = object_get_from_message(message, "navit");
+    if (! navit)
+        return dbus_error_invalid_object_path(connection, message);
 
-	dbus_message_iter_init(message, &iter);
-	dbg(lvl_debug,"%s", dbus_message_iter_get_signature(&iter));
+    dbus_message_iter_init(message, &iter);
+    dbg(lvl_debug,"%s", dbus_message_iter_get_signature(&iter));
 
-	dbus_message_iter_get_basic(&iter, &factor);
+    dbus_message_iter_get_basic(&iter, &factor);
 
-	if (dbus_message_iter_has_next(&iter))
-	{
-		dbus_message_iter_next(&iter);
-		if (!point_get_from_message(message, &iter, &p))
-			return dbus_error_invalid_parameter(connection, message);
-		pp=&p;
-	}
+    if (dbus_message_iter_has_next(&iter)) {
+        dbus_message_iter_next(&iter);
+        if (!point_get_from_message(message, &iter, &p))
+            return dbus_error_invalid_parameter(connection, message);
+        pp=&p;
+    }
 
-	if (factor > 1)
-		navit_zoom_in(navit, factor, pp);
-	else if (factor < -1)
-		navit_zoom_out(navit, 0-factor, pp);
+    if (factor > 1)
+        navit_zoom_in(navit, factor, pp);
+    else if (factor < -1)
+        navit_zoom_out(navit, 0-factor, pp);
 
-	return empty_reply(connection, message);
+    return empty_reply(connection, message);
 
 }
 
 static DBusHandlerResult
-request_navit_zoom_to_route(DBusConnection *connection, DBusMessage *message)
-{
-	struct navit *navit;
-	DBusMessageIter iter;
+request_navit_zoom_to_route(DBusConnection *connection, DBusMessage *message) {
+    struct navit *navit;
+    DBusMessageIter iter;
 
-	navit = object_get_from_message(message, "navit");
-	if (! navit)
-		return dbus_error_invalid_object_path(connection, message);
+    navit = object_get_from_message(message, "navit");
+    if (! navit)
+        return dbus_error_invalid_object_path(connection, message);
 
-	dbus_message_iter_init(message, &iter);
-	dbg(lvl_debug,"%s", dbus_message_iter_get_signature(&iter));
+    dbus_message_iter_init(message, &iter);
+    dbg(lvl_debug,"%s", dbus_message_iter_get_signature(&iter));
 
-	navit_zoom_to_route(navit,0);
+    navit_zoom_to_route(navit,0);
 
-	return empty_reply(connection, message);
+    return empty_reply(connection, message);
 
 }
 
@@ -1432,65 +1376,65 @@ request_navit_zoom_to_route(DBusConnection *connection, DBusMessage *message)
  * @returns An empty reply if everything went right, otherwise `DBUS_HANDLER_RESULT_NOT_YET_HANDLED`
  */
 static DBusHandlerResult
-request_navit_route_export_gpx(DBusConnection *connection, DBusMessage *message)
-{
-	char * filename;
-	struct navit *navit;
-	DBusMessageIter iter;
+request_navit_route_export_gpx(DBusConnection *connection, DBusMessage *message) {
+    char * filename;
+    struct navit *navit;
+    DBusMessageIter iter;
+
+    navit = object_get_from_message(message, "navit");
+    if (! navit)
+        return dbus_error_invalid_object_path(connection, message);
 
-	navit = object_get_from_message(message, "navit");
-	if (! navit)
-		return dbus_error_invalid_object_path(connection, message);
+    dbus_message_iter_init(message, &iter);
 
-	dbus_message_iter_init(message, &iter);
+    dbus_message_iter_get_basic(&iter, &filename);
 
-	dbus_message_iter_get_basic(&iter, &filename);
+    struct navigation *nav = navit_get_navigation(navit);
+    if(!nav) {
+        return dbus_error_navigation_not_configured(connection, message);
+    }
 
-	struct navigation *nav = navit_get_navigation(navit);
-        if(!nav) {
-                return dbus_error_navigation_not_configured(connection, message);
+    dbg(lvl_debug,"Dumping route from dbus to %s", filename);
+
+    struct map * map=NULL;
+    struct map_rect * mr=NULL;
+    struct item *item = NULL;
+    struct attr attr;
+    struct coord c;
+    struct coord_geo g;
+
+    char *header = "<?xml version='1.0' encoding='UTF-8'?>\n"
+                   "<gpx version='1.1' creator='Navit http://navit.sourceforge.net'\n"
+                   "     xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'\n"
+                   "     xmlns:navit='http://www.navit-project.org/schema/navit'\n"
+                   "     xmlns='http://www.topografix.com/GPX/1/1'\n"
+                   "     xsi:schemaLocation='http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd'>\n"
+                   "<rte>\n";
+    char *trailer = "</rte>\n</gpx>\n";
+
+    map = navigation_get_map(nav);
+    if(map)
+        mr = map_rect_new(map,NULL);
+
+    FILE *fp;
+    fp = fopen(filename,"w");
+    fprintf(fp, "%s", header);
+
+    while((item = map_rect_get_item(mr))) {
+        if(item_attr_get(item,attr_navigation_long,&attr)) {
+            item_coord_get(item, &c, 1);
+            transform_to_geo (projection_mg, &c, &g);
+            fprintf(fp,"<rtept lon='%4.16f' lat='%4.16f'><type>%s</type><name>%s</name></rtept>\n",g.lng, g.lat,
+                    item_to_name(item->type), map_convert_string_tmp(item->map,attr.u.str));
         }
+    }
+    fprintf(fp,"%s",trailer);
+
+    fclose(fp);
 
-	dbg(lvl_debug,"Dumping route from dbus to %s", filename);
-
-	struct map * map=NULL;
-	struct map_rect * mr=NULL;
-	struct item *item = NULL;
-	struct attr attr;
-	struct coord c;
-	struct coord_geo g;
-	
-        char *header = "<?xml version='1.0' encoding='UTF-8'?>\n"
-                        "<gpx version='1.1' creator='Navit http://navit.sourceforge.net'\n"
-                        "     xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'\n"
-                        "     xmlns:navit='http://www.navit-project.org/schema/navit'\n"
-                        "     xmlns='http://www.topografix.com/GPX/1/1'\n"
-                        "     xsi:schemaLocation='http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd'>\n"
-                        "<rte>\n";
-        char *trailer = "</rte>\n</gpx>\n";
-
-        map = navigation_get_map(nav);
-        if(map)
-          mr = map_rect_new(map,NULL);
-
-        FILE *fp;
-        fp = fopen(filename,"w");
-        fprintf(fp, "%s", header);
-
-	while((item = map_rect_get_item(mr))) {
-		if(item_attr_get(item,attr_navigation_long,&attr)) {
-			item_coord_get(item, &c, 1);
-			transform_to_geo (projection_mg, &c, &g);
-			fprintf(fp,"<rtept lon='%4.16f' lat='%4.16f'><type>%s</type><name>%s</name></rtept>\n",g.lng, g.lat, item_to_name(item->type), map_convert_string_tmp(item->map,attr.u.str));
-		}
-	}
-	fprintf(fp,"%s",trailer);
-	
-         fclose(fp);
-
-         map_rect_destroy(mr);
-
-	return empty_reply(connection, message);
+    map_rect_destroy(mr);
+
+    return empty_reply(connection, message);
 }
 
 /**
@@ -1500,446 +1444,431 @@ request_navit_route_export_gpx(DBusConnection *connection, DBusMessage *message)
  * @returns An empty reply if everything went right, otherwise DBUS_HANDLER_RESULT_NOT_YET_HANDLED
  */
 static DBusHandlerResult
-request_navit_route_export_geojson(DBusConnection *connection, DBusMessage *message)
-{
-        char * filename;
-        struct point p;
-        struct navit *navit;
-        DBusMessageIter iter;
+request_navit_route_export_geojson(DBusConnection *connection, DBusMessage *message) {
+    char * filename;
+    struct point p;
+    struct navit *navit;
+    DBusMessageIter iter;
 
-        navit = object_get_from_message(message, "navit");
-        if (! navit)
-                return dbus_error_invalid_object_path(connection, message);
+    navit = object_get_from_message(message, "navit");
+    if (! navit)
+        return dbus_error_invalid_object_path(connection, message);
 
-        dbus_message_iter_init(message, &iter);
+    dbus_message_iter_init(message, &iter);
 
-        dbus_message_iter_get_basic(&iter, &filename);
+    dbus_message_iter_get_basic(&iter, &filename);
 
-        if (dbus_message_iter_has_next(&iter))
-        {
-                dbus_message_iter_next(&iter);
-                if (!point_get_from_message(message, &iter, &p))
-                        return dbus_error_invalid_parameter(connection, message);
-        }
+    if (dbus_message_iter_has_next(&iter)) {
+        dbus_message_iter_next(&iter);
+        if (!point_get_from_message(message, &iter, &p))
+            return dbus_error_invalid_parameter(connection, message);
+    }
 
-        dbg(lvl_debug,"Dumping route from dbus to %s", filename);
-
-        struct map * map=NULL;
-        struct navigation * nav = NULL;
-        struct map_rect * mr=NULL;
-        struct item *item = NULL;
-        struct attr attr;
-        struct coord c;
-        struct coord_geo g;
-
-        char *header = "{\n"
-"  \"type\": \"FeatureCollection\",\n"
-"  \"features\": [\n"
-"    {\n"
-"      \"type\": \"Feature\",\n"
-"      \"properties\": {\n"
-"        \"name\": \"Navit route export\",\n"
-"        \"stroke\": \"red\",\n"
-"        \"stroke-width\": \"5px\"\n"
-"      },\n"
-"      \"geometry\": {\n"
-"        \"type\": \"LineString\",\n"
-"        \"coordinates\": [\n";
-
-        nav = navit_get_navigation(navit);
-        if(!nav) {
-                return dbus_error_navigation_not_configured(connection, message);
-        }
-        map = navigation_get_map(nav);
-        if(map)
-          mr = map_rect_new(map,NULL);
-
-        FILE *fp;
-        fp = fopen(filename,"w");
-        fprintf(fp, "%s", header);
-        int is_first=1;
-        char * instructions;
-        instructions=g_strdup("");
-        while((item = map_rect_get_item(mr))) {
-                if(item_attr_get(item,attr_navigation_long,&attr)) {
-                        item_coord_get(item, &c, 1);
-                        transform_to_geo (projection_mg, &c, &g);
-                        if(!is_first){
-                                fprintf(fp,",\n");
-                                instructions=g_strconcat_printf(instructions,",\n");
-                        }
-                        fprintf(fp,"[ %4.16f, %4.16f ]",g.lng, g.lat);
-                         instructions=g_strconcat_printf(instructions, g_strdup_printf("    { \"type\": \"Feature\", \"properties\": { \"Instruction\": \"%s\", \"name\": \"\" }, \"geometry\": { \"type\": \"Point\", \"coordinates\": [ %4.16f, %4.16f ] } }", map_convert_string_tmp(item->map,attr.u.str), g.lng, g.lat));
-                        /* fprintf(fp,"<rtept lon='%4.16f' lat='%4.16f'><type>%s</type><name>%s</name></rtept>\n",g.lng, g.lat, item_to_name(item->type), map_convert_string_tmp(item->map,attr.u.str)); */
-                        is_first=0;
-                }
+    dbg(lvl_debug,"Dumping route from dbus to %s", filename);
+
+    struct map * map=NULL;
+    struct navigation * nav = NULL;
+    struct map_rect * mr=NULL;
+    struct item *item = NULL;
+    struct attr attr;
+    struct coord c;
+    struct coord_geo g;
+
+    char *header = "{\n"
+                   "  \"type\": \"FeatureCollection\",\n"
+                   "  \"features\": [\n"
+                   "    {\n"
+                   "      \"type\": \"Feature\",\n"
+                   "      \"properties\": {\n"
+                   "        \"name\": \"Navit route export\",\n"
+                   "        \"stroke\": \"red\",\n"
+                   "        \"stroke-width\": \"5px\"\n"
+                   "      },\n"
+                   "      \"geometry\": {\n"
+                   "        \"type\": \"LineString\",\n"
+                   "        \"coordinates\": [\n";
+
+    nav = navit_get_navigation(navit);
+    if(!nav) {
+        return dbus_error_navigation_not_configured(connection, message);
+    }
+    map = navigation_get_map(nav);
+    if(map)
+        mr = map_rect_new(map,NULL);
+
+    FILE *fp;
+    fp = fopen(filename,"w");
+    fprintf(fp, "%s", header);
+    int is_first=1;
+    char * instructions;
+    instructions=g_strdup("");
+    while((item = map_rect_get_item(mr))) {
+        if(item_attr_get(item,attr_navigation_long,&attr)) {
+            item_coord_get(item, &c, 1);
+            transform_to_geo (projection_mg, &c, &g);
+            if(!is_first) {
+                fprintf(fp,",\n");
+                instructions=g_strconcat_printf(instructions,",\n");
+            }
+            fprintf(fp,"[ %4.16f, %4.16f ]",g.lng, g.lat);
+            instructions=g_strconcat_printf(instructions,
+                                            g_strdup_printf("    { \"type\": \"Feature\", \"properties\": { \"Instruction\": \"%s\", \"name\": \"\" }, \"geometry\": { \"type\": \"Point\", \"coordinates\": [ %4.16f, %4.16f ] } }",
+                                                    map_convert_string_tmp(item->map,attr.u.str), g.lng, g.lat));
+            /* fprintf(fp,"<rtept lon='%4.16f' lat='%4.16f'><type>%s</type><name>%s</name></rtept>\n",g.lng, g.lat, item_to_name(item->type), map_convert_string_tmp(item->map,attr.u.str)); */
+            is_first=0;
         }
+    }
 
-        fprintf(fp," ]}\n },\n%s  ]\n }\n",instructions);
+    fprintf(fp," ]}\n },\n%s  ]\n }\n",instructions);
 
-        fclose(fp);
+    fclose(fp);
 
-        return empty_reply(connection, message);
+    return empty_reply(connection, message);
 }
 
 static DBusHandlerResult
-request_navit_block(DBusConnection *connection, DBusMessage *message)
-{
-	int mode;
-	struct navit *navit;
-	DBusMessageIter iter;
+request_navit_block(DBusConnection *connection, DBusMessage *message) {
+    int mode;
+    struct navit *navit;
+    DBusMessageIter iter;
 
-	navit = object_get_from_message(message, "navit");
-	if (! navit)
-		return dbus_error_invalid_object_path(connection, message);
+    navit = object_get_from_message(message, "navit");
+    if (! navit)
+        return dbus_error_invalid_object_path(connection, message);
 
-	dbus_message_iter_init(message, &iter);
+    dbus_message_iter_init(message, &iter);
 
-	dbus_message_iter_get_basic(&iter, &mode);
+    dbus_message_iter_get_basic(&iter, &mode);
 
-	navit_block(navit, mode);
-	return empty_reply(connection, message);
+    navit_block(navit, mode);
+    return empty_reply(connection, message);
 
 }
 
 static DBusHandlerResult
-request_navit_resize(DBusConnection *connection, DBusMessage *message)
-{
-	struct navit *navit;
-	int w, h;
-	DBusMessageIter iter;
+request_navit_resize(DBusConnection *connection, DBusMessage *message) {
+    struct navit *navit;
+    int w, h;
+    DBusMessageIter iter;
 
-	navit = object_get_from_message(message, "navit");
-	if (! navit)
-		return dbus_error_invalid_object_path(connection, message);
+    navit = object_get_from_message(message, "navit");
+    if (! navit)
+        return dbus_error_invalid_object_path(connection, message);
 
-	dbus_message_iter_init(message, &iter);
-	dbg(lvl_debug,"%s", dbus_message_iter_get_signature(&iter));
+    dbus_message_iter_init(message, &iter);
+    dbg(lvl_debug,"%s", dbus_message_iter_get_signature(&iter));
 
-	if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_INT32)
-		return dbus_error_invalid_parameter(connection, message);
-	dbus_message_iter_get_basic(&iter, &w);
+    if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_INT32)
+        return dbus_error_invalid_parameter(connection, message);
+    dbus_message_iter_get_basic(&iter, &w);
 
-	dbus_message_iter_next(&iter);
+    dbus_message_iter_next(&iter);
 
-	if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_INT32)
-		return dbus_error_invalid_parameter(connection, message);
-	dbus_message_iter_get_basic(&iter, &h);
+    if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_INT32)
+        return dbus_error_invalid_parameter(connection, message);
+    dbus_message_iter_get_basic(&iter, &h);
 
-	dbg(lvl_debug, " w -> %i  h -> %i", w, h);
+    dbg(lvl_debug, " w -> %i  h -> %i", w, h);
 
-	navit_handle_resize(navit, w, h);
+    navit_handle_resize(navit, w, h);
 
-	return empty_reply(connection, message);
+    return empty_reply(connection, message);
 
 }
 
 static DBusHandlerResult
-request_navit_get_attr(DBusConnection *connection, DBusMessage *message)
-{
-	return request_get_attr(connection, message, "navit", NULL, (int (*)(void *, enum attr_type, struct attr *, struct attr_iter *))navit_get_attr);
+request_navit_get_attr(DBusConnection *connection, DBusMessage *message) {
+    return request_get_attr(connection, message, "navit", NULL, (int (*)(void *, enum attr_type, struct attr *,
+                            struct attr_iter *))navit_get_attr);
 }
 
 static DBusHandlerResult
-request_navit_attr_iter(DBusConnection *connection, DBusMessage *message)
-{
-	DBusMessage *reply;
-	struct attr_iter *attr_iter=navit_attr_iter_new();
-	char *opath=object_new("navit_attr_iter",attr_iter);
-	reply = dbus_message_new_method_return(message);
-	dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &opath, DBUS_TYPE_INVALID);
-	dbus_connection_send (connection, reply, NULL);
-	dbus_message_unref (reply);
+request_navit_attr_iter(DBusConnection *connection, DBusMessage *message) {
+    DBusMessage *reply;
+    struct attr_iter *attr_iter=navit_attr_iter_new();
+    char *opath=object_new("navit_attr_iter",attr_iter);
+    reply = dbus_message_new_method_return(message);
+    dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &opath, DBUS_TYPE_INVALID);
+    dbus_connection_send (connection, reply, NULL);
+    dbus_message_unref (reply);
 
-	return DBUS_HANDLER_RESULT_HANDLED;
+    return DBUS_HANDLER_RESULT_HANDLED;
 }
 
 static DBusHandlerResult
-request_navit_attr_iter_destroy(DBusConnection *connection, DBusMessage *message)
-{
-	struct attr_iter *attr_iter;
-	DBusMessageIter iter;
+request_navit_attr_iter_destroy(DBusConnection *connection, DBusMessage *message) {
+    struct attr_iter *attr_iter;
+    DBusMessageIter iter;
 
-	dbus_message_iter_init(message, &iter);
-	attr_iter=object_get_from_message_arg(&iter, "navit_attr_iter");
-	if (! attr_iter)
-		return dbus_error_invalid_object_path_parameter(connection, message);
-	navit_attr_iter_destroy(attr_iter);
+    dbus_message_iter_init(message, &iter);
+    attr_iter=object_get_from_message_arg(&iter, "navit_attr_iter");
+    if (! attr_iter)
+        return dbus_error_invalid_object_path_parameter(connection, message);
+    navit_attr_iter_destroy(attr_iter);
 
-	return empty_reply(connection, message);
+    return empty_reply(connection, message);
 }
 
 
 static DBusHandlerResult
-request_navit_set_attr(DBusConnection *connection, DBusMessage *message)
-{
-	return request_set_add_remove_attr(connection, message, "navit", NULL, (int (*)(void *, struct attr *))navit_set_attr);
+request_navit_set_attr(DBusConnection *connection, DBusMessage *message) {
+    return request_set_add_remove_attr(connection, message, "navit", NULL, (int (*)(void *, struct attr *))navit_set_attr);
 }
 
 static DBusHandlerResult
-request_navit_add_attr(DBusConnection *connection, DBusMessage *message)
-{
-	return request_set_add_remove_attr(connection, message, "navit", NULL, (int (*)(void *, struct attr *))navit_add_attr);
+request_navit_add_attr(DBusConnection *connection, DBusMessage *message) {
+    return request_set_add_remove_attr(connection, message, "navit", NULL, (int (*)(void *, struct attr *))navit_add_attr);
 }
 
 static DBusHandlerResult
-request_navit_remove_attr(DBusConnection *connection, DBusMessage *message)
-{
-	return request_set_add_remove_attr(connection, message, "navit", NULL, (int (*)(void *, struct attr *))navit_remove_attr);
+request_navit_remove_attr(DBusConnection *connection, DBusMessage *message) {
+    return request_set_add_remove_attr(connection, message, "navit", NULL, (int (*)(void *,
+                                       struct attr *))navit_remove_attr);
 }
 
 static DBusHandlerResult
-request_navit_set_position(DBusConnection *connection, DBusMessage *message)
-{
-	struct pcoord pc;
-	struct navit *navit;
-	DBusMessageIter iter;
+request_navit_set_position(DBusConnection *connection, DBusMessage *message) {
+    struct pcoord pc;
+    struct navit *navit;
+    DBusMessageIter iter;
 
-	navit = object_get_from_message(message, "navit");
-	if (! navit)
-		return dbus_error_invalid_object_path(connection, message);
+    navit = object_get_from_message(message, "navit");
+    if (! navit)
+        return dbus_error_invalid_object_path(connection, message);
 
-	dbus_message_iter_init(message, &iter);
-	if (!pcoord_get_from_message(message, &iter, &pc))
-    		return dbus_error_invalid_parameter(connection, message);
+    dbus_message_iter_init(message, &iter);
+    if (!pcoord_get_from_message(message, &iter, &pc))
+        return dbus_error_invalid_parameter(connection, message);
 
-	navit_set_position(navit, &pc);
-	return empty_reply(connection, message);
+    navit_set_position(navit, &pc);
+    return empty_reply(connection, message);
 }
 
 static DBusHandlerResult
-request_navit_set_destination(DBusConnection *connection, DBusMessage *message)
-{
-	struct pcoord pc;
-	struct navit *navit;
-	DBusMessageIter iter;
-	char *description;
+request_navit_set_destination(DBusConnection *connection, DBusMessage *message) {
+    struct pcoord pc;
+    struct navit *navit;
+    DBusMessageIter iter;
+    char *description;
 
-	navit = object_get_from_message(message, "navit");
-	if (! navit)
-		return dbus_error_invalid_object_path(connection, message);
+    navit = object_get_from_message(message, "navit");
+    if (! navit)
+        return dbus_error_invalid_object_path(connection, message);
 
-	dbus_message_iter_init(message, &iter);
-	if (!pcoord_get_from_message(message, &iter, &pc))
-    		return dbus_error_invalid_parameter(connection, message);
+    dbus_message_iter_init(message, &iter);
+    if (!pcoord_get_from_message(message, &iter, &pc))
+        return dbus_error_invalid_parameter(connection, message);
 
-	dbus_message_iter_next(&iter);
-	dbus_message_iter_get_basic(&iter, &description);
-	dbg(lvl_debug, " destination -> %s", description);
+    dbus_message_iter_next(&iter);
+    dbus_message_iter_get_basic(&iter, &description);
+    dbg(lvl_debug, " destination -> %s", description);
 
-	navit_set_destination(navit, &pc, description, 1);
-	return empty_reply(connection, message);
+    navit_set_destination(navit, &pc, description, 1);
+    return empty_reply(connection, message);
 }
 
 static DBusHandlerResult
-request_navit_clear_destination(DBusConnection *connection, DBusMessage *message)
-{
-	struct navit *navit;
+request_navit_clear_destination(DBusConnection *connection, DBusMessage *message) {
+    struct navit *navit;
 
-	navit = object_get_from_message(message, "navit");
-	if (! navit)
-		return dbus_error_invalid_object_path(connection, message);
-	navit_set_destination(navit, NULL, NULL, 0);
-	return empty_reply(connection, message);
+    navit = object_get_from_message(message, "navit");
+    if (! navit)
+        return dbus_error_invalid_object_path(connection, message);
+    navit_set_destination(navit, NULL, NULL, 0);
+    return empty_reply(connection, message);
 }
 
 static DBusHandlerResult
-request_navit_evaluate(DBusConnection *connection, DBusMessage *message)
-{
-	struct navit *navit;
-	char *command;
-	char *result;
-	struct attr attr;
-	DBusMessage *reply;
-	int error;
+request_navit_evaluate(DBusConnection *connection, DBusMessage *message) {
+    struct navit *navit;
+    char *command;
+    char *result;
+    struct attr attr;
+    DBusMessage *reply;
+    int error;
 
-	navit = object_get_from_message(message, "navit");
-	if (! navit)
-		return dbus_error_invalid_object_path(connection, message);
+    navit = object_get_from_message(message, "navit");
+    if (! navit)
+        return dbus_error_invalid_object_path(connection, message);
 
-	attr.type=attr_navit;
-	attr.u.navit=navit;
-        if (!dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &command, DBUS_TYPE_INVALID))
-    		return dbus_error_invalid_parameter(connection, message);
-	result=command_evaluate_to_string(&attr, command, &error);
-	reply = dbus_message_new_method_return(message);
-	if (error)
-		dbus_message_append_args(reply, DBUS_TYPE_INT32, &error, DBUS_TYPE_INVALID);
-	else if (result)
-		dbus_message_append_args(reply, DBUS_TYPE_STRING, &result, DBUS_TYPE_INVALID);
-	dbus_connection_send (connection, reply, NULL);
-	dbus_message_unref (reply);
-	return DBUS_HANDLER_RESULT_HANDLED;
+    attr.type=attr_navit;
+    attr.u.navit=navit;
+    if (!dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &command, DBUS_TYPE_INVALID))
+        return dbus_error_invalid_parameter(connection, message);
+    result=command_evaluate_to_string(&attr, command, &error);
+    reply = dbus_message_new_method_return(message);
+    if (error)
+        dbus_message_append_args(reply, DBUS_TYPE_INT32, &error, DBUS_TYPE_INVALID);
+    else if (result)
+        dbus_message_append_args(reply, DBUS_TYPE_STRING, &result, DBUS_TYPE_INVALID);
+    dbus_connection_send (connection, reply, NULL);
+    dbus_message_unref (reply);
+    return DBUS_HANDLER_RESULT_HANDLED;
 }
 
 /* search_list */
 
 static DBusHandlerResult
-request_search_list_destroy(DBusConnection *connection, DBusMessage *message)
-{
-	return request_destroy(connection, message, "search_list", NULL, (void (*)(void *)) search_list_destroy);
+request_search_list_destroy(DBusConnection *connection, DBusMessage *message) {
+    return request_destroy(connection, message, "search_list", NULL, (void (*)(void *)) search_list_destroy);
 }
 
 static void
-request_search_list_common(struct search_list_common *slc, DBusMessageIter *iter4)
-{
-	if (slc->postal)
-		encode_dict_string_variant_string(iter4, "postal", slc->postal);
-	if (slc->postal_mask)
-		encode_dict_string_variant_string(iter4, "postal_mask", slc->postal_mask);
-}
-
-static DBusHandlerResult
-request_search_list_get_result(DBusConnection *connection, DBusMessage *message)
-{
-	struct search_list *search_list;
-	struct search_list_result *result;
-	DBusMessage *reply;
-	DBusMessageIter iter,iter2,iter3,iter4;
-	char *country="country";
-	char *town="town";
-	char *street="street";
-	char *house_number="housenumber";
-
-	search_list = object_get_from_message(message, "search_list");
-	if (! search_list)
-		return dbus_error_invalid_object_path(connection, message);
-	result=search_list_get_result(search_list);
-	if (!result)
-		return dbus_error_no_data_available(connection, message);
-	reply = dbus_message_new_method_return(message);
-	dbus_message_iter_init_append(reply, &iter);
-	dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &result->id);
-	pcoord_encode(&iter, result->c);
-	dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "{sa{sv}}", &iter2);
-	if (result->country && (result->country->car || result->country->iso2 || result->country->iso3 || result->country->name)) {
-		dbus_message_iter_open_container(&iter2, DBUS_TYPE_DICT_ENTRY, NULL, &iter3);
-		dbus_message_iter_append_basic(&iter3, DBUS_TYPE_STRING, &country);
-		dbus_message_iter_open_container(&iter3, DBUS_TYPE_ARRAY, "{sv}", &iter4);
-		if (result->country->car)
-			encode_dict_string_variant_string(&iter4, "car", result->country->car);
-		if (result->country->iso2)
-			encode_dict_string_variant_string(&iter4, "iso2", result->country->iso2);
-		if (result->country->iso3)
-			encode_dict_string_variant_string(&iter4, "iso3", result->country->iso3);
-		if (result->country->name)
-			encode_dict_string_variant_string(&iter4, "name", result->country->name);
-		dbus_message_iter_close_container(&iter3, &iter4);
-		dbus_message_iter_close_container(&iter2, &iter3);
-	}
-	if (result->town && (result->town->common.district_name || result->town->common.town_name)) {
-		dbus_message_iter_open_container(&iter2, DBUS_TYPE_DICT_ENTRY, NULL, &iter3);
-		dbus_message_iter_append_basic(&iter3, DBUS_TYPE_STRING, &town);
-		dbus_message_iter_open_container(&iter3, DBUS_TYPE_ARRAY, "{sv}", &iter4);
-		request_search_list_common(&result->town->common,&iter4);
-		if (result->town->common.district_name)
-			encode_dict_string_variant_string(&iter4, "district", result->town->common.district_name);
-		if (result->town->common.town_name)
-			encode_dict_string_variant_string(&iter4, "name", result->town->common.town_name);
-		dbus_message_iter_close_container(&iter3, &iter4);
-		dbus_message_iter_close_container(&iter2, &iter3);
-	}
-	if (result->street && result->street->name) {
-		dbus_message_iter_open_container(&iter2, DBUS_TYPE_DICT_ENTRY, NULL, &iter3);
-		dbus_message_iter_append_basic(&iter3, DBUS_TYPE_STRING, &street);
-		dbus_message_iter_open_container(&iter3, DBUS_TYPE_ARRAY, "{sv}", &iter4);
-		request_search_list_common(&result->street->common,&iter4);
-		if (result->street->name)
-			encode_dict_string_variant_string(&iter4, "name", result->street->name);
-		dbus_message_iter_close_container(&iter3, &iter4);
-		dbus_message_iter_close_container(&iter2, &iter3);
-	}
-	if (result->house_number && result->house_number->house_number) {
-		dbus_message_iter_open_container(&iter2, DBUS_TYPE_DICT_ENTRY, NULL, &iter3);
-		dbus_message_iter_append_basic(&iter3, DBUS_TYPE_STRING, &house_number);
-		dbus_message_iter_open_container(&iter3, DBUS_TYPE_ARRAY, "{sv}", &iter4);
-		request_search_list_common(&result->house_number->common,&iter4);
-		encode_dict_string_variant_string(&iter4, "name", result->house_number->house_number);
-		dbus_message_iter_close_container(&iter3, &iter4);
-		dbus_message_iter_close_container(&iter2, &iter3);
-	}
-	dbus_message_iter_close_container(&iter, &iter2);
-	dbus_connection_send (connection, reply, NULL);
-	dbus_message_unref (reply);
-	return DBUS_HANDLER_RESULT_HANDLED;
-}
-
-static DBusHandlerResult
-request_search_list_new(DBusConnection *connection, DBusMessage *message)
-{
-	DBusMessageIter iter;
-	DBusMessage *reply;
-	struct mapset *mapset;
-	struct search_list *search_list;
-	char *opath;
-
-	dbus_message_iter_init(message, &iter);
-	mapset=object_get_from_message_arg(&iter, "mapset");
-	if (! mapset)
-		return dbus_error_invalid_object_path_parameter(connection, message);
-	search_list=search_list_new(mapset);
-	opath=object_new("search_list", search_list);
-	reply = dbus_message_new_method_return(message);
-	dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &opath, DBUS_TYPE_INVALID);
-	dbus_connection_send (connection, reply, NULL);
-	dbus_message_unref (reply);
-	return DBUS_HANDLER_RESULT_HANDLED;
-}
-
-static DBusHandlerResult
-request_search_list_search(DBusConnection *connection, DBusMessage *message)
-{
-	DBusMessageIter iter;
-	struct search_list *search_list;
-	struct attr attr;
-	int partial;
-
-	search_list = object_get_from_message(message, "search_list");
-	if (! search_list)
-		return dbus_error_invalid_object_path(connection, message);
-
-	dbus_message_iter_init(message, &iter);
-	if (!decode_attr_from_iter(&iter, &attr))
-    		return dbus_error_invalid_parameter(connection, message);
-	if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_INT32)
-    		return dbus_error_invalid_parameter(connection, message);
-	dbus_message_iter_get_basic(&iter, &partial);
-	search_list_search(search_list, &attr, partial);
-	return empty_reply(connection, message);
-}
-
-static DBusHandlerResult
-request_search_list_select(DBusConnection *connection, DBusMessage *message)
-{
-	DBusMessageIter iter;
-	struct search_list *search_list;
-	int id, mode;
-	enum attr_type attr_type;
-
-	search_list = object_get_from_message(message, "search_list");
-	if (! search_list)
-		return dbus_error_invalid_object_path(connection, message);
-
-	dbus_message_iter_init(message, &iter);
-	attr_type=decode_attr_type_from_iter(&iter);
-	if (attr_type == attr_none)
-    		return dbus_error_invalid_parameter(connection, message);
-	if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_INT32)
-    		return dbus_error_invalid_parameter(connection, message);
-	dbus_message_iter_get_basic(&iter, &id);
-	if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_INT32)
-    		return dbus_error_invalid_parameter(connection, message);
-	dbus_message_iter_get_basic(&iter, &mode);
-	search_list_select(search_list, attr_type, id, mode);
-	return empty_reply(connection, message);
+request_search_list_common(struct search_list_common *slc, DBusMessageIter *iter4) {
+    if (slc->postal)
+        encode_dict_string_variant_string(iter4, "postal", slc->postal);
+    if (slc->postal_mask)
+        encode_dict_string_variant_string(iter4, "postal_mask", slc->postal_mask);
+}
+
+static DBusHandlerResult
+request_search_list_get_result(DBusConnection *connection, DBusMessage *message) {
+    struct search_list *search_list;
+    struct search_list_result *result;
+    DBusMessage *reply;
+    DBusMessageIter iter,iter2,iter3,iter4;
+    char *country="country";
+    char *town="town";
+    char *street="street";
+    char *house_number="housenumber";
+
+    search_list = object_get_from_message(message, "search_list");
+    if (! search_list)
+        return dbus_error_invalid_object_path(connection, message);
+    result=search_list_get_result(search_list);
+    if (!result)
+        return dbus_error_no_data_available(connection, message);
+    reply = dbus_message_new_method_return(message);
+    dbus_message_iter_init_append(reply, &iter);
+    dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &result->id);
+    pcoord_encode(&iter, result->c);
+    dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "{sa{sv}}", &iter2);
+    if (result->country && (result->country->car || result->country->iso2 || result->country->iso3
+                            || result->country->name)) {
+        dbus_message_iter_open_container(&iter2, DBUS_TYPE_DICT_ENTRY, NULL, &iter3);
+        dbus_message_iter_append_basic(&iter3, DBUS_TYPE_STRING, &country);
+        dbus_message_iter_open_container(&iter3, DBUS_TYPE_ARRAY, "{sv}", &iter4);
+        if (result->country->car)
+            encode_dict_string_variant_string(&iter4, "car", result->country->car);
+        if (result->country->iso2)
+            encode_dict_string_variant_string(&iter4, "iso2", result->country->iso2);
+        if (result->country->iso3)
+            encode_dict_string_variant_string(&iter4, "iso3", result->country->iso3);
+        if (result->country->name)
+            encode_dict_string_variant_string(&iter4, "name", result->country->name);
+        dbus_message_iter_close_container(&iter3, &iter4);
+        dbus_message_iter_close_container(&iter2, &iter3);
+    }
+    if (result->town && (result->town->common.district_name || result->town->common.town_name)) {
+        dbus_message_iter_open_container(&iter2, DBUS_TYPE_DICT_ENTRY, NULL, &iter3);
+        dbus_message_iter_append_basic(&iter3, DBUS_TYPE_STRING, &town);
+        dbus_message_iter_open_container(&iter3, DBUS_TYPE_ARRAY, "{sv}", &iter4);
+        request_search_list_common(&result->town->common,&iter4);
+        if (result->town->common.district_name)
+            encode_dict_string_variant_string(&iter4, "district", result->town->common.district_name);
+        if (result->town->common.town_name)
+            encode_dict_string_variant_string(&iter4, "name", result->town->common.town_name);
+        dbus_message_iter_close_container(&iter3, &iter4);
+        dbus_message_iter_close_container(&iter2, &iter3);
+    }
+    if (result->street && result->street->name) {
+        dbus_message_iter_open_container(&iter2, DBUS_TYPE_DICT_ENTRY, NULL, &iter3);
+        dbus_message_iter_append_basic(&iter3, DBUS_TYPE_STRING, &street);
+        dbus_message_iter_open_container(&iter3, DBUS_TYPE_ARRAY, "{sv}", &iter4);
+        request_search_list_common(&result->street->common,&iter4);
+        if (result->street->name)
+            encode_dict_string_variant_string(&iter4, "name", result->street->name);
+        dbus_message_iter_close_container(&iter3, &iter4);
+        dbus_message_iter_close_container(&iter2, &iter3);
+    }
+    if (result->house_number && result->house_number->house_number) {
+        dbus_message_iter_open_container(&iter2, DBUS_TYPE_DICT_ENTRY, NULL, &iter3);
+        dbus_message_iter_append_basic(&iter3, DBUS_TYPE_STRING, &house_number);
+        dbus_message_iter_open_container(&iter3, DBUS_TYPE_ARRAY, "{sv}", &iter4);
+        request_search_list_common(&result->house_number->common,&iter4);
+        encode_dict_string_variant_string(&iter4, "name", result->house_number->house_number);
+        dbus_message_iter_close_container(&iter3, &iter4);
+        dbus_message_iter_close_container(&iter2, &iter3);
+    }
+    dbus_message_iter_close_container(&iter, &iter2);
+    dbus_connection_send (connection, reply, NULL);
+    dbus_message_unref (reply);
+    return DBUS_HANDLER_RESULT_HANDLED;
+}
+
+static DBusHandlerResult
+request_search_list_new(DBusConnection *connection, DBusMessage *message) {
+    DBusMessageIter iter;
+    DBusMessage *reply;
+    struct mapset *mapset;
+    struct search_list *search_list;
+    char *opath;
+
+    dbus_message_iter_init(message, &iter);
+    mapset=object_get_from_message_arg(&iter, "mapset");
+    if (! mapset)
+        return dbus_error_invalid_object_path_parameter(connection, message);
+    search_list=search_list_new(mapset);
+    opath=object_new("search_list", search_list);
+    reply = dbus_message_new_method_return(message);
+    dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &opath, DBUS_TYPE_INVALID);
+    dbus_connection_send (connection, reply, NULL);
+    dbus_message_unref (reply);
+    return DBUS_HANDLER_RESULT_HANDLED;
+}
+
+static DBusHandlerResult
+request_search_list_search(DBusConnection *connection, DBusMessage *message) {
+    DBusMessageIter iter;
+    struct search_list *search_list;
+    struct attr attr;
+    int partial;
+
+    search_list = object_get_from_message(message, "search_list");
+    if (! search_list)
+        return dbus_error_invalid_object_path(connection, message);
+
+    dbus_message_iter_init(message, &iter);
+    if (!decode_attr_from_iter(&iter, &attr))
+        return dbus_error_invalid_parameter(connection, message);
+    if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_INT32)
+        return dbus_error_invalid_parameter(connection, message);
+    dbus_message_iter_get_basic(&iter, &partial);
+    search_list_search(search_list, &attr, partial);
+    return empty_reply(connection, message);
+}
+
+static DBusHandlerResult
+request_search_list_select(DBusConnection *connection, DBusMessage *message) {
+    DBusMessageIter iter;
+    struct search_list *search_list;
+    int id, mode;
+    enum attr_type attr_type;
+
+    search_list = object_get_from_message(message, "search_list");
+    if (! search_list)
+        return dbus_error_invalid_object_path(connection, message);
+
+    dbus_message_iter_init(message, &iter);
+    attr_type=decode_attr_type_from_iter(&iter);
+    if (attr_type == attr_none)
+        return dbus_error_invalid_parameter(connection, message);
+    if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_INT32)
+        return dbus_error_invalid_parameter(connection, message);
+    dbus_message_iter_get_basic(&iter, &id);
+    if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_INT32)
+        return dbus_error_invalid_parameter(connection, message);
+    dbus_message_iter_get_basic(&iter, &mode);
+    search_list_select(search_list, attr_type, id, mode);
+    return empty_reply(connection, message);
 }
 
 /* tracking */
 
 static DBusHandlerResult
-request_tracking_get_attr(DBusConnection *connection, DBusMessage *message)
-{
-	return request_get_attr(connection, message, "tracking", NULL, (int (*)(void *, enum attr_type, struct attr *, struct attr_iter *))tracking_get_attr);
+request_tracking_get_attr(DBusConnection *connection, DBusMessage *message) {
+    return request_get_attr(connection, message, "tracking", NULL, (int (*)(void *, enum attr_type, struct attr *,
+                            struct attr_iter *))tracking_get_attr);
 }
 
 
@@ -1947,179 +1876,176 @@ request_tracking_get_attr(DBusConnection *connection, DBusMessage *message)
 /* vehicle */
 
 static DBusHandlerResult
-request_vehicle_set_attr(DBusConnection *connection, DBusMessage *message)
-{
-	struct vehicle *vehicle;
-    	struct attr attr;
-	int ret;
+request_vehicle_set_attr(DBusConnection *connection, DBusMessage *message) {
+    struct vehicle *vehicle;
+    struct attr attr;
+    int ret;
 
-	vehicle = object_get_from_message(message, "vehicle");
-	if (! vehicle)
-		return dbus_error_invalid_object_path(connection, message);
-	if (decode_attr(message, &attr)) {
-		ret=vehicle_set_attr(vehicle, &attr);
-		destroy_attr(&attr);
-		if (ret)
-			return empty_reply(connection, message);
-	}
-    	return dbus_error_invalid_parameter(connection, message);
+    vehicle = object_get_from_message(message, "vehicle");
+    if (! vehicle)
+        return dbus_error_invalid_object_path(connection, message);
+    if (decode_attr(message, &attr)) {
+        ret=vehicle_set_attr(vehicle, &attr);
+        destroy_attr(&attr);
+        if (ret)
+            return empty_reply(connection, message);
+    }
+    return dbus_error_invalid_parameter(connection, message);
 }
 
 /* vehicleprofile */
 
 static DBusHandlerResult
-request_vehicleprofile_get_attr(DBusConnection *connection, DBusMessage *message)
-{
-	return request_get_attr(connection, message, "vehicleprofile", NULL, (int (*)(void *, enum attr_type, struct attr *, struct attr_iter *))vehicleprofile_get_attr);
+request_vehicleprofile_get_attr(DBusConnection *connection, DBusMessage *message) {
+    return request_get_attr(connection, message, "vehicleprofile", NULL, (int (*)(void *, enum attr_type, struct attr *,
+                            struct attr_iter *))vehicleprofile_get_attr);
 }
 
 
 static DBusHandlerResult
-request_vehicleprofile_set_attr(DBusConnection *connection, DBusMessage *message)
-{
-	return request_set_add_remove_attr(connection, message, "vehicleprofile", NULL, (int (*)(void *, struct attr *))vehicleprofile_set_attr);
+request_vehicleprofile_set_attr(DBusConnection *connection, DBusMessage *message) {
+    return request_set_add_remove_attr(connection, message, "vehicleprofile", NULL, (int (*)(void *,
+                                       struct attr *))vehicleprofile_set_attr);
 }
 
 static DBusHandlerResult
-request_vehicleprofile_attr_iter(DBusConnection *connection, DBusMessage *message)
-{
-	return request_attr_iter(connection, message, "vehicleprofile", (struct attr_iter * (*)(void))vehicleprofile_attr_iter_new);
+request_vehicleprofile_attr_iter(DBusConnection *connection, DBusMessage *message) {
+    return request_attr_iter(connection, message, "vehicleprofile",
+                             (struct attr_iter * (*)(void))vehicleprofile_attr_iter_new);
 }
 
 static DBusHandlerResult
-request_vehicleprofile_attr_iter_destroy(DBusConnection *connection, DBusMessage *message)
-{
-	return request_attr_iter_destroy(connection, message, "vehicleprofile", (void (*)(struct attr_iter *))vehicleprofile_attr_iter_destroy);
+request_vehicleprofile_attr_iter_destroy(DBusConnection *connection, DBusMessage *message) {
+    return request_attr_iter_destroy(connection, message, "vehicleprofile",
+                                     (void (*)(struct attr_iter *))vehicleprofile_attr_iter_destroy);
 }
 
 struct dbus_method {
-	char *path;
-	char *method;
-	char *signature;
+    char *path;
+    char *method;
+    char *signature;
     char *signature_name;
     char *response;
     char *response_name;
-	DBusHandlerResult(*func)(DBusConnection *connection, DBusMessage *message);
+    DBusHandlerResult(*func)(DBusConnection *connection, DBusMessage *message);
 } dbus_methods[] = {
-	{"",        "attr_iter",           "",        "",                                        "o",  "attr_iter",  request_config_attr_iter},
-	{"",        "attr_iter_destroy",   "o",       "attr_iter",                               "",   "",      request_config_attr_iter_destroy},
-	{"",        "get_attr",            "s",       "attrname",                                "sv", "attrname,value",request_config_get_attr},
-	{"",        "get_attr_wi",         "so",      "attrname,attr_iter",                      "sv", "attrname,value",request_config_get_attr},
-	{"",	    "callback_new",	   "s",       "signalname",                              "o",  "callback",request_callback_new},
-	{"",	    "callback_attr_new",   "ss",       "signalname,attribute",                   "o",  "callback",request_callback_new},
-	{"",	    "search_list_new",	   "o",       "mapset",                                  "o",  "search",request_search_list_new},
-	{".callback","destroy",            "",        "",                                        "",   "",      request_callback_destroy},
-	{".graphics","get_data", 	   "s",	      "type",				 	 "ay",  "data", request_graphics_get_data},
-	{".graphics","set_attr",           "sv",      "attribute,value",                         "",   "",      request_graphics_set_attr},
-	{".gui",     "get_attr",           "s",       "attribute",                               "sv",  "attrname,value", request_gui_get_attr},
-	{".gui",     "command_parameter",  "sa{sa{sv}}","command,parameter",                     "a{sa{sv}}",  "return", request_gui_command},
-	{".gui",     "command",            "s",       "command",                                 "a{sa{sv}}",  "return", request_gui_command},
-	{".navit",  "draw",                "",        "",                                        "",   "",      request_navit_draw},
-	{".navit",  "add_message",         "s",       "message",                                 "",   "",      request_navit_add_message},
-	{".navit",  "set_center_by_string","s",       "(coordinates)",                           "",   "",      request_navit_set_center},
-	{".navit",  "set_center",          "(is)",    "(projection,coordinates)",                "",   "",      request_navit_set_center},
-	{".navit",  "set_center",          "(iii)",   "(projection,longitude,latitude)",         "",   "",      request_navit_set_center},
-	{".navit",  "set_center_screen",   "(ii)",    "(pixel_x,pixel_y)",                       "",   "",      request_navit_set_center_screen},
-	{".navit",  "set_layout",          "s",       "layoutname",                              "",   "",      request_navit_set_layout},
-	{".navit",  "traffic_inject",      "s",       "filename",                                "",   "",      request_navit_traffic_inject},
-	{".navit",  "zoom",                "i(ii)",   "factor(pixel_x,pixel_y)",                 "",   "",      request_navit_zoom},
-	{".navit",  "zoom",                "i",       "factor",                                  "",   "",      request_navit_zoom},
-	{".navit",  "zoom_to_route",       "",        "",                                        "",   "",      request_navit_zoom_to_route},
-        {".navit",  "quit",                "",        "",                                        "",   "",      request_navit_quit},
-	{".navit",  "export_as_gpx",       "s",       "filename",                                "",   "",      request_navit_route_export_gpx},
-        {".navit",  "export_as_geojson",   "s",       "filename",                                "",   "",      request_navit_route_export_geojson},
-	{".navit",  "block",               "i",       "mode",                                    "",   "",      request_navit_block},
-	{".navit",  "resize",              "ii",      "upperleft,lowerright",                    "",   "",      request_navit_resize},
-	{".navit",  "attr_iter",           "",        "",                                        "o",  "attr_iter",  request_navit_attr_iter},
-	{".navit",  "attr_iter_destroy",   "o",       "attr_iter",                               "",   "",      request_navit_attr_iter_destroy},
-	{".navit",  "get_attr",            "s",       "attribute",                               "sv",  "attrname,value", request_navit_get_attr},
-	{".navit",  "get_attr_wi",         "so",      "attribute,attr_iter",                     "sv",  "attrname,value", request_navit_get_attr},
-	{".navit",  "set_attr",            "sv",      "attribute,value",                         "",   "",      request_navit_set_attr},
-	{".navit",  "add_attr",            "sv",      "attribute,value",                         "",   "",      request_navit_add_attr},
-	{".navit",  "remove_attr",         "sv",      "attribute,value",                         "",   "",      request_navit_remove_attr},
-	{".navit",  "set_position",        "s",       "(coordinates)",                           "",   "",      request_navit_set_position},
-	{".navit",  "set_position",        "(is)",    "(projection,coordinated)",                "",   "",      request_navit_set_position},
-	{".navit",  "set_position",        "(iii)",   "(projection,longitude,latitude)",         "",   "",      request_navit_set_position},
-	{".navit",  "set_destination",     "ss",      "coordinates,comment",                     "",   "",      request_navit_set_destination},
-	{".navit",  "set_destination",     "(is)s",   "(projection,coordinates)comment",         "",   "",      request_navit_set_destination},
-	{".navit",  "set_destination",     "(iii)s",  "(projection,longitude,latitude)comment",  "",   "",      request_navit_set_destination},
-	{".navit",  "clear_destination",   "",        "",                                        "",   "",      request_navit_clear_destination},
-	{".navit",  "evaluate", 	   "s",	      "command",				 "s",  "",      request_navit_evaluate},
-	{".layout", "get_attr",		   "s",	      "attribute",                               "sv",  "attrname,value", request_layout_get_attr},
-	{".map",    "get_attr",            "s",       "attribute",                               "sv",  "attrname,value", request_map_get_attr},
-	{".map",    "set_attr",            "sv",      "attribute,value",                         "",   "",      request_map_set_attr},
-	{".map",    "dump",                "s",       "file",                                    "",   "",  request_map_dump},
-	{".mapset", "attr_iter",           "",        "",                                        "o",  "attr_iter",  request_mapset_attr_iter},
-	{".mapset", "attr_iter_destroy",   "o",       "attr_iter",                               "",   "",      request_mapset_attr_iter_destroy},
-	{".mapset", "get_attr",            "s",       "attribute",                               "sv",  "attrname,value", request_mapset_get_attr},
-	{".mapset", "get_attr_wi",         "so",      "attribute,attr_iter",                     "sv",  "attrname,value", request_mapset_get_attr},
-	{".navigation","get_attr",         "s",       "attribute",                               "",   "",      request_navigation_get_attr},
-	{".osd",    "get_attr",          "s",       "attribute",                               "sv",  "attrname,value", request_osd_get_attr},
-	{".osd",    "set_attr",          "sv",      "attribute,value",                         "",    "",  request_osd_set_attr},
-	{".roadprofile", "get_attr",       "s",       "attribute",                               "sv",  "attrname,value", request_roadprofile_get_attr},
-	{".roadprofile", "get_attr_wi",    "so",      "attribute,attr_iter",                     "",   "",      request_roadprofile_get_attr},
-	{".roadprofile", "set_attr",       "sv",      "attribute,value",                         "",    "",  request_roadprofile_set_attr},
-	{".roadprofile", "attr_iter",      "",        "",                                        "o",  "attr_iter",  request_roadprofile_attr_iter},
-	{".roadprofile", "attr_iter_destroy","o",     "attr_iter",                               "",   "",      request_roadprofile_attr_iter_destroy},
-	{".route",    "get_attr",          "s",       "attribute",                               "sv",  "attrname,value", request_route_get_attr},
-	{".route",    "set_attr",          "sv",      "attribute,value",                         "",    "",  request_route_set_attr},
-	{".route",    "add_attr",          "sv",      "attribute,value",                         "",    "",  request_route_add_attr},
-	{".route",    "remove_attr",       "sv",      "attribute,value",                         "",    "",  request_route_remove_attr},
-	{".route",    "destroy",           "",        "",                                        "",    "",  request_route_destroy},
-	{".route",    "dup",               "",        "",                                        "",    "",  request_route_dup},
-	{".search_list","destroy",         "",        "",                                        "",   "",      request_search_list_destroy},
-	{".search_list","destroy",         "",        "",                                        "",   "",      request_search_list_destroy},
-	{".search_list","destroy",         "",        "",                                        "",   "",      request_search_list_destroy},
-	{".search_list","get_result",      "",        "",                                        "i(iii)a{sa{sv}}",   "id,coord,dict",      request_search_list_get_result},
-	{".search_list","search",          "svi",     "attribute,value,partial",                 "",   "",      request_search_list_search},
-	{".search_list","select",          "sii",     "attribute_type,id,mode",                  "",   "",      request_search_list_select},
-	{".tracking","get_attr",           "s",       "attribute",                               "",   "",      request_tracking_get_attr},
-	{".vehicle","set_attr",            "sv",      "attribute,value",                         "",   "",      request_vehicle_set_attr},
-	{".vehicleprofile","get_attr",     "s",       "attribute",                               "",   "",      request_vehicleprofile_get_attr},
-	{".vehicleprofile","get_attr_wi",  "so",      "attribute,attr_iter",                     "",   "",      request_vehicleprofile_get_attr},
-	{".vehicleprofile","set_attr",     "sv",      "attribute,value",                         "",   "",      request_vehicleprofile_set_attr},
-	{".vehicleprofile","attr_iter",     "",       "",                                        "o",  "attr_iter",  request_vehicleprofile_attr_iter},
-	{".vehicleprofile","attr_iter_destroy","o",   "attr_iter",                               "",   "",      request_vehicleprofile_attr_iter_destroy},
+    {"",        "attr_iter",           "",        "",                                        "o",  "attr_iter",  request_config_attr_iter},
+    {"",        "attr_iter_destroy",   "o",       "attr_iter",                               "",   "",      request_config_attr_iter_destroy},
+    {"",        "get_attr",            "s",       "attrname",                                "sv", "attrname,value",request_config_get_attr},
+    {"",        "get_attr_wi",         "so",      "attrname,attr_iter",                      "sv", "attrname,value",request_config_get_attr},
+    {"",	    "callback_new",	   "s",       "signalname",                              "o",  "callback",request_callback_new},
+    {"",	    "callback_attr_new",   "ss",       "signalname,attribute",                   "o",  "callback",request_callback_new},
+    {"",	    "search_list_new",	   "o",       "mapset",                                  "o",  "search",request_search_list_new},
+    {".callback","destroy",            "",        "",                                        "",   "",      request_callback_destroy},
+    {".graphics","get_data", 	   "s",	      "type",				 	 "ay",  "data", request_graphics_get_data},
+    {".graphics","set_attr",           "sv",      "attribute,value",                         "",   "",      request_graphics_set_attr},
+    {".gui",     "get_attr",           "s",       "attribute",                               "sv",  "attrname,value", request_gui_get_attr},
+    {".gui",     "command_parameter",  "sa{sa{sv}}","command,parameter",                     "a{sa{sv}}",  "return", request_gui_command},
+    {".gui",     "command",            "s",       "command",                                 "a{sa{sv}}",  "return", request_gui_command},
+    {".navit",  "draw",                "",        "",                                        "",   "",      request_navit_draw},
+    {".navit",  "add_message",         "s",       "message",                                 "",   "",      request_navit_add_message},
+    {".navit",  "set_center_by_string","s",       "(coordinates)",                           "",   "",      request_navit_set_center},
+    {".navit",  "set_center",          "(is)",    "(projection,coordinates)",                "",   "",      request_navit_set_center},
+    {".navit",  "set_center",          "(iii)",   "(projection,longitude,latitude)",         "",   "",      request_navit_set_center},
+    {".navit",  "set_center_screen",   "(ii)",    "(pixel_x,pixel_y)",                       "",   "",      request_navit_set_center_screen},
+    {".navit",  "set_layout",          "s",       "layoutname",                              "",   "",      request_navit_set_layout},
+    {".navit",  "traffic_inject",      "s",       "filename",                                "",   "",      request_navit_traffic_inject},
+    {".navit",  "zoom",                "i(ii)",   "factor(pixel_x,pixel_y)",                 "",   "",      request_navit_zoom},
+    {".navit",  "zoom",                "i",       "factor",                                  "",   "",      request_navit_zoom},
+    {".navit",  "zoom_to_route",       "",        "",                                        "",   "",      request_navit_zoom_to_route},
+    {".navit",  "quit",                "",        "",                                        "",   "",      request_navit_quit},
+    {".navit",  "export_as_gpx",       "s",       "filename",                                "",   "",      request_navit_route_export_gpx},
+    {".navit",  "export_as_geojson",   "s",       "filename",                                "",   "",      request_navit_route_export_geojson},
+    {".navit",  "block",               "i",       "mode",                                    "",   "",      request_navit_block},
+    {".navit",  "resize",              "ii",      "upperleft,lowerright",                    "",   "",      request_navit_resize},
+    {".navit",  "attr_iter",           "",        "",                                        "o",  "attr_iter",  request_navit_attr_iter},
+    {".navit",  "attr_iter_destroy",   "o",       "attr_iter",                               "",   "",      request_navit_attr_iter_destroy},
+    {".navit",  "get_attr",            "s",       "attribute",                               "sv",  "attrname,value", request_navit_get_attr},
+    {".navit",  "get_attr_wi",         "so",      "attribute,attr_iter",                     "sv",  "attrname,value", request_navit_get_attr},
+    {".navit",  "set_attr",            "sv",      "attribute,value",                         "",   "",      request_navit_set_attr},
+    {".navit",  "add_attr",            "sv",      "attribute,value",                         "",   "",      request_navit_add_attr},
+    {".navit",  "remove_attr",         "sv",      "attribute,value",                         "",   "",      request_navit_remove_attr},
+    {".navit",  "set_position",        "s",       "(coordinates)",                           "",   "",      request_navit_set_position},
+    {".navit",  "set_position",        "(is)",    "(projection,coordinated)",                "",   "",      request_navit_set_position},
+    {".navit",  "set_position",        "(iii)",   "(projection,longitude,latitude)",         "",   "",      request_navit_set_position},
+    {".navit",  "set_destination",     "ss",      "coordinates,comment",                     "",   "",      request_navit_set_destination},
+    {".navit",  "set_destination",     "(is)s",   "(projection,coordinates)comment",         "",   "",      request_navit_set_destination},
+    {".navit",  "set_destination",     "(iii)s",  "(projection,longitude,latitude)comment",  "",   "",      request_navit_set_destination},
+    {".navit",  "clear_destination",   "",        "",                                        "",   "",      request_navit_clear_destination},
+    {".navit",  "evaluate", 	   "s",	      "command",				 "s",  "",      request_navit_evaluate},
+    {".layout", "get_attr",		   "s",	      "attribute",                               "sv",  "attrname,value", request_layout_get_attr},
+    {".map",    "get_attr",            "s",       "attribute",                               "sv",  "attrname,value", request_map_get_attr},
+    {".map",    "set_attr",            "sv",      "attribute,value",                         "",   "",      request_map_set_attr},
+    {".map",    "dump",                "s",       "file",                                    "",   "",  request_map_dump},
+    {".mapset", "attr_iter",           "",        "",                                        "o",  "attr_iter",  request_mapset_attr_iter},
+    {".mapset", "attr_iter_destroy",   "o",       "attr_iter",                               "",   "",      request_mapset_attr_iter_destroy},
+    {".mapset", "get_attr",            "s",       "attribute",                               "sv",  "attrname,value", request_mapset_get_attr},
+    {".mapset", "get_attr_wi",         "so",      "attribute,attr_iter",                     "sv",  "attrname,value", request_mapset_get_attr},
+    {".navigation","get_attr",         "s",       "attribute",                               "",   "",      request_navigation_get_attr},
+    {".osd",    "get_attr",          "s",       "attribute",                               "sv",  "attrname,value", request_osd_get_attr},
+    {".osd",    "set_attr",          "sv",      "attribute,value",                         "",    "",  request_osd_set_attr},
+    {".roadprofile", "get_attr",       "s",       "attribute",                               "sv",  "attrname,value", request_roadprofile_get_attr},
+    {".roadprofile", "get_attr_wi",    "so",      "attribute,attr_iter",                     "",   "",      request_roadprofile_get_attr},
+    {".roadprofile", "set_attr",       "sv",      "attribute,value",                         "",    "",  request_roadprofile_set_attr},
+    {".roadprofile", "attr_iter",      "",        "",                                        "o",  "attr_iter",  request_roadprofile_attr_iter},
+    {".roadprofile", "attr_iter_destroy","o",     "attr_iter",                               "",   "",      request_roadprofile_attr_iter_destroy},
+    {".route",    "get_attr",          "s",       "attribute",                               "sv",  "attrname,value", request_route_get_attr},
+    {".route",    "set_attr",          "sv",      "attribute,value",                         "",    "",  request_route_set_attr},
+    {".route",    "add_attr",          "sv",      "attribute,value",                         "",    "",  request_route_add_attr},
+    {".route",    "remove_attr",       "sv",      "attribute,value",                         "",    "",  request_route_remove_attr},
+    {".route",    "destroy",           "",        "",                                        "",    "",  request_route_destroy},
+    {".route",    "dup",               "",        "",                                        "",    "",  request_route_dup},
+    {".search_list","destroy",         "",        "",                                        "",   "",      request_search_list_destroy},
+    {".search_list","destroy",         "",        "",                                        "",   "",      request_search_list_destroy},
+    {".search_list","destroy",         "",        "",                                        "",   "",      request_search_list_destroy},
+    {".search_list","get_result",      "",        "",                                        "i(iii)a{sa{sv}}",   "id,coord,dict",      request_search_list_get_result},
+    {".search_list","search",          "svi",     "attribute,value,partial",                 "",   "",      request_search_list_search},
+    {".search_list","select",          "sii",     "attribute_type,id,mode",                  "",   "",      request_search_list_select},
+    {".tracking","get_attr",           "s",       "attribute",                               "",   "",      request_tracking_get_attr},
+    {".vehicle","set_attr",            "sv",      "attribute,value",                         "",   "",      request_vehicle_set_attr},
+    {".vehicleprofile","get_attr",     "s",       "attribute",                               "",   "",      request_vehicleprofile_get_attr},
+    {".vehicleprofile","get_attr_wi",  "so",      "attribute,attr_iter",                     "",   "",      request_vehicleprofile_get_attr},
+    {".vehicleprofile","set_attr",     "sv",      "attribute,value",                         "",   "",      request_vehicleprofile_set_attr},
+    {".vehicleprofile","attr_iter",     "",       "",                                        "o",  "attr_iter",  request_vehicleprofile_attr_iter},
+    {".vehicleprofile","attr_iter_destroy","o",   "attr_iter",                               "",   "",      request_vehicleprofile_attr_iter_destroy},
 };
 
 static char *
-introspect_path(const char *object)
-{
-	char *ret;
-	int i;
-	char *def=".default_";
-	int def_len=strlen(def);
-	if (strncmp(object, object_path, strlen(object_path)))
-		return NULL;
-	ret=g_strdup(object+strlen(object_path));
-	dbg(lvl_debug,"path=%s",ret);
-	for (i = strlen(ret)-1 ; i >= 0 ; i--) {
-		if (ret[i] == '/' || (ret[i] >= '0' && ret[i] <= '9'))
-			ret[i]='\0';
-		else
-			break;
-	}
-	for (i = 0 ; i < strlen(ret); i++)
-		if (ret[i] == '/')
-			ret[i]='.';
-
-	for (i = strlen(ret)-1 ; i >= 0 ; i--) {
-		if (!strncmp(ret+i, def, def_len)) {
-			memmove(ret+1,ret+i+def_len,strlen(ret+i+def_len)+1);
-			break;
-		}
-	}
-	return ret;
+introspect_path(const char *object) {
+    char *ret;
+    int i;
+    char *def=".default_";
+    int def_len=strlen(def);
+    if (strncmp(object, object_path, strlen(object_path)))
+        return NULL;
+    ret=g_strdup(object+strlen(object_path));
+    dbg(lvl_debug,"path=%s",ret);
+    for (i = strlen(ret)-1 ; i >= 0 ; i--) {
+        if (ret[i] == '/' || (ret[i] >= '0' && ret[i] <= '9'))
+            ret[i]='\0';
+        else
+            break;
+    }
+    for (i = 0 ; i < strlen(ret); i++)
+        if (ret[i] == '/')
+            ret[i]='.';
+
+    for (i = strlen(ret)-1 ; i >= 0 ; i--) {
+        if (!strncmp(ret+i, def, def_len)) {
+            memmove(ret+1,ret+i+def_len,strlen(ret+i+def_len)+1);
+            break;
+        }
+    }
+    return ret;
 }
 
 static char *
-generate_navitintrospectxml(const char *object)
-{
+generate_navitintrospectxml(const char *object) {
     int i,methods_size,n=0;
     char *navitintrospectxml;
     char *path=introspect_path(object);
     if (!path)
-	return NULL;
+        return NULL;
     dbg(lvl_debug,"path=%s",path);
 
     // write header and make navit introspectable
@@ -2128,22 +2054,25 @@ generate_navitintrospectxml(const char *object)
     methods_size=sizeof(dbus_methods)/sizeof(struct dbus_method);
     for (i = 0 ; i < methods_size ; i++) {
         // start new interface if it's the first method or it changed
-	if (strcmp(dbus_methods[i].path, path))
-		continue;
+        if (strcmp(dbus_methods[i].path, path))
+            continue;
         if ((n == 0) || strcmp(dbus_methods[i-1].path, dbus_methods[i].path))
-            navitintrospectxml = g_strconcat_printf(navitintrospectxml, "  <interface name=\"%s%s\">\n", service_name, dbus_methods[i].path);
-	n++;
+            navitintrospectxml = g_strconcat_printf(navitintrospectxml, "  <interface name=\"%s%s\">\n", service_name,
+                                                    dbus_methods[i].path);
+        n++;
 
         // start the new method
         navitintrospectxml = g_strconcat_printf(navitintrospectxml, "    <method name=\"%s\">\n", dbus_methods[i].method);
 
         // set input signature if existent
         if (strcmp(dbus_methods[i].signature, ""))
-            navitintrospectxml = g_strconcat_printf(navitintrospectxml, "      <arg direction=\"in\" name=\"%s\" type=\"%s\" />\n", dbus_methods[i].signature_name, dbus_methods[i].signature);
+            navitintrospectxml = g_strconcat_printf(navitintrospectxml, "      <arg direction=\"in\" name=\"%s\" type=\"%s\" />\n",
+                                                    dbus_methods[i].signature_name, dbus_methods[i].signature);
 
         // set response signature if existent
         if (strcmp(dbus_methods[i].response, ""))
-            navitintrospectxml = g_strconcat_printf(navitintrospectxml, "      <arg direction=\"out\" name=\"%s\" type=\"%s\" />\n", dbus_methods[i].response_name, dbus_methods[i].response);
+            navitintrospectxml = g_strconcat_printf(navitintrospectxml, "      <arg direction=\"out\" name=\"%s\" type=\"%s\" />\n",
+                                                    dbus_methods[i].response_name, dbus_methods[i].response);
 
         // close the method
         navitintrospectxml = g_strconcat_printf(navitintrospectxml, "    </method>\n");
@@ -2159,140 +2088,139 @@ generate_navitintrospectxml(const char *object)
 }
 
 static DBusHandlerResult
-navit_handler_func(DBusConnection *connection, DBusMessage *message, void *user_data)
-{
-	int i;
-	char *path;
-	dbg(lvl_debug,"type=%s interface=%s path=%s member=%s signature=%s", dbus_message_type_to_string(dbus_message_get_type(message)), dbus_message_get_interface(message), dbus_message_get_path(message), dbus_message_get_member(message), dbus_message_get_signature(message));
-	if (dbus_message_is_method_call (message, "org.freedesktop.DBus.Introspectable", "Introspect")) {
-		DBusMessage *reply;
-            	char *navitintrospectxml = generate_navitintrospectxml(dbus_message_get_path(message));
-		dbg(lvl_debug,"Introspect %s:Result:%s",dbus_message_get_path(message), navitintrospectxml);
-		if (navitintrospectxml) {
-			reply = dbus_message_new_method_return(message);
-			dbus_message_append_args(reply, DBUS_TYPE_STRING, &navitintrospectxml, DBUS_TYPE_INVALID);
-			dbus_connection_send (connection, reply, NULL);
-			dbus_message_unref (reply);
-			g_free(navitintrospectxml);
-			return DBUS_HANDLER_RESULT_HANDLED;
-		}
-		return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
-	}
+navit_handler_func(DBusConnection *connection, DBusMessage *message, void *user_data) {
+    int i;
+    char *path;
+    dbg(lvl_debug,"type=%s interface=%s path=%s member=%s signature=%s",
+        dbus_message_type_to_string(dbus_message_get_type(message)), dbus_message_get_interface(message),
+        dbus_message_get_path(message), dbus_message_get_member(message), dbus_message_get_signature(message));
+    if (dbus_message_is_method_call (message, "org.freedesktop.DBus.Introspectable", "Introspect")) {
+        DBusMessage *reply;
+        char *navitintrospectxml = generate_navitintrospectxml(dbus_message_get_path(message));
+        dbg(lvl_debug,"Introspect %s:Result:%s",dbus_message_get_path(message), navitintrospectxml);
+        if (navitintrospectxml) {
+            reply = dbus_message_new_method_return(message);
+            dbus_message_append_args(reply, DBUS_TYPE_STRING, &navitintrospectxml, DBUS_TYPE_INVALID);
+            dbus_connection_send (connection, reply, NULL);
+            dbus_message_unref (reply);
+            g_free(navitintrospectxml);
+            return DBUS_HANDLER_RESULT_HANDLED;
+        }
+        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+    }
 
     for (i = 0 ; i < sizeof(dbus_methods)/sizeof(struct dbus_method) ; i++) {
-		path=g_strdup_printf("%s%s", service_name, dbus_methods[i].path);
-		if (dbus_message_is_method_call(message, path, dbus_methods[i].method) &&
-		    dbus_message_has_signature(message, dbus_methods[i].signature)) {
-			g_free(path);
-			return dbus_methods[i].func(connection, message);
-		}
-		g_free(path);
-	}
-	return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+        path=g_strdup_printf("%s%s", service_name, dbus_methods[i].path);
+        if (dbus_message_is_method_call(message, path, dbus_methods[i].method) &&
+                dbus_message_has_signature(message, dbus_methods[i].signature)) {
+            g_free(path);
+            return dbus_methods[i].func(connection, message);
+        }
+        g_free(path);
+    }
+    return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 }
 
 static DBusObjectPathVTable dbus_navit_vtable = {
-	NULL,
-	navit_handler_func,
-	NULL
+    NULL,
+    navit_handler_func,
+    NULL
 };
 
 #if 0
 DBusHandlerResult
-filter(DBusConnection *connection, DBusMessage *message, void *user_data)
-{
-	dbg(lvl_debug,"type=%s interface=%s path=%s member=%s signature=%s", dbus_message_type_to_string(dbus_message_get_type(message)), dbus_message_get_interface(message), dbus_message_get_path(message), dbus_message_get_member(message), dbus_message_get_signature(message));
-	if (dbus_message_is_signal(message, DBUS_INTERFACE_DBUS, "NameOwnerChanged")) {
-	}
-	return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+filter(DBusConnection *connection, DBusMessage *message, void *user_data) {
+    dbg(lvl_debug,"type=%s interface=%s path=%s member=%s signature=%s",
+        dbus_message_type_to_string(dbus_message_get_type(message)), dbus_message_get_interface(message),
+        dbus_message_get_path(message), dbus_message_get_member(message), dbus_message_get_signature(message));
+    if (dbus_message_is_signal(message, DBUS_INTERFACE_DBUS, "NameOwnerChanged")) {
+    }
+    return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 }
 #endif
 
 static int
-dbus_cmd_send_signal(struct navit *navit, char *command, struct attr **in, struct attr ***out)
-{
-	DBusMessage* msg;
-	char *opath=object_new("navit",navit);
-	char *interface=g_strdup_printf("%s%s", service_name, ".navit");
-	dbg(lvl_debug,"enter %s %s %s",opath,command,interface);
-	msg = dbus_message_new_signal(opath, interface, "signal");
-	if (msg) {
-		DBusMessageIter iter1,iter2,iter3;
-		dbus_message_iter_init_append(msg, &iter1);
-		dbus_message_iter_open_container(&iter1, DBUS_TYPE_ARRAY, "{sv}", &iter2);
-		if (in) {
-			while (*in) {
-				dbus_message_iter_open_container(&iter2, DBUS_TYPE_DICT_ENTRY, NULL, &iter3);
-				encode_attr(&iter3, *in);
-				dbus_message_iter_close_container(&iter2, &iter3);
-				in++;
-			}
-		}
-		dbus_message_iter_close_container(&iter1, &iter2);
-		dbus_connection_send(connection, msg, &dbus_serial);
-		dbus_connection_flush(connection);
-		dbus_message_unref(msg);
-	}
-	g_free(interface);
-	return 0;
+dbus_cmd_send_signal(struct navit *navit, char *command, struct attr **in, struct attr ***out) {
+    DBusMessage* msg;
+    char *opath=object_new("navit",navit);
+    char *interface=g_strdup_printf("%s%s", service_name, ".navit");
+    dbg(lvl_debug,"enter %s %s %s",opath,command,interface);
+    msg = dbus_message_new_signal(opath, interface, "signal");
+    if (msg) {
+        DBusMessageIter iter1,iter2,iter3;
+        dbus_message_iter_init_append(msg, &iter1);
+        dbus_message_iter_open_container(&iter1, DBUS_TYPE_ARRAY, "{sv}", &iter2);
+        if (in) {
+            while (*in) {
+                dbus_message_iter_open_container(&iter2, DBUS_TYPE_DICT_ENTRY, NULL, &iter3);
+                encode_attr(&iter3, *in);
+                dbus_message_iter_close_container(&iter2, &iter3);
+                in++;
+            }
+        }
+        dbus_message_iter_close_container(&iter1, &iter2);
+        dbus_connection_send(connection, msg, &dbus_serial);
+        dbus_connection_flush(connection);
+        dbus_message_unref(msg);
+    }
+    g_free(interface);
+    return 0;
 }
 
 
 static struct command_table commands[] = {
-        {"dbus_send_signal",command_cast(dbus_cmd_send_signal)},
+    {"dbus_send_signal",command_cast(dbus_cmd_send_signal)},
 };
 
 
 static void
-dbus_main_navit(struct navit *navit, int added)
-{
-	struct attr attr;
-	if (added==1) {
-		DBusMessage* msg;
-		char *opath=object_new("navit",navit);
-		char *interface=g_strdup_printf("%s%s", service_name, ".navit");
-		command_add_table_attr(commands, sizeof(commands)/sizeof(struct command_table), navit, &attr);
-		navit_add_attr(navit, &attr);
-		msg = dbus_message_new_signal(opath, interface, "startup");
-		dbus_connection_send(connection, msg, &dbus_serial);
-		dbus_connection_flush(connection);
-		dbus_message_unref(msg);
-		g_free(interface);
-	}
-}
-
-void plugin_init(void)
-{
-	DBusError error;
-
-	struct attr callback;
-	object_hash=g_hash_table_new(g_str_hash, g_str_equal);
-	object_hash_rev=g_hash_table_new(NULL, NULL);
-	object_count=g_hash_table_new(g_str_hash, g_str_equal);
-	dbg(lvl_debug,"enter");
-	dbus_error_init(&error);
+dbus_main_navit(struct navit *navit, int added) {
+    struct attr attr;
+    if (added==1) {
+        DBusMessage* msg;
+        char *opath=object_new("navit",navit);
+        char *interface=g_strdup_printf("%s%s", service_name, ".navit");
+        command_add_table_attr(commands, sizeof(commands)/sizeof(struct command_table), navit, &attr);
+        navit_add_attr(navit, &attr);
+        msg = dbus_message_new_signal(opath, interface, "startup");
+        dbus_connection_send(connection, msg, &dbus_serial);
+        dbus_connection_flush(connection);
+        dbus_message_unref(msg);
+        g_free(interface);
+    }
+}
+
+void plugin_init(void) {
+    DBusError error;
+
+    struct attr callback;
+    object_hash=g_hash_table_new(g_str_hash, g_str_equal);
+    object_hash_rev=g_hash_table_new(NULL, NULL);
+    object_count=g_hash_table_new(g_str_hash, g_str_equal);
+    dbg(lvl_debug,"enter");
+    dbus_error_init(&error);
 #ifdef DBUS_USE_SYSTEM_BUS
-	connection = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
+    connection = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
 #else
-	connection = dbus_bus_get(DBUS_BUS_SESSION, &error);
+    connection = dbus_bus_get(DBUS_BUS_SESSION, &error);
 #endif
-	if (!connection) {
-		dbg(lvl_error,"Failed to open connection to session message bus: %s", error.message);
-		dbus_error_free(&error);
-		return;
-	}
-	dbus_connection_setup_with_g_main(connection, NULL);
+    if (!connection) {
+        dbg(lvl_error,"Failed to open connection to session message bus: %s", error.message);
+        dbus_error_free(&error);
+        return;
+    }
+    dbus_connection_setup_with_g_main(connection, NULL);
 #if 0
-	dbus_connection_add_filter(connection, filter, NULL, NULL);
-	dbus_bus_add_match(connection, "type='signal',""interface='" DBUS_INTERFACE_DBUS  "'", &error);
+    dbus_connection_add_filter(connection, filter, NULL, NULL);
+    dbus_bus_add_match(connection, "type='signal',""interface='" DBUS_INTERFACE_DBUS  "'", &error);
 #endif
-	dbus_connection_register_fallback(connection, object_path, &dbus_navit_vtable, NULL);
-	dbus_bus_request_name(connection, service_name, 0, &error);
-	if (dbus_error_is_set(&error)) {
-		dbg(lvl_error,"Failed to request name: %s", error.message);
-		dbus_error_free (&error);
-	}
-	callback.type=attr_callback;
-	callback.u.callback=callback_new_attr_0(callback_cast(dbus_main_navit),attr_navit);
-	config_add_attr(config, &callback);
+    dbus_connection_register_fallback(connection, object_path, &dbus_navit_vtable, NULL);
+    dbus_bus_request_name(connection, service_name, 0, &error);
+    if (dbus_error_is_set(&error)) {
+        dbg(lvl_error,"Failed to request name: %s", error.message);
+        dbus_error_free (&error);
+    }
+    callback.type=attr_callback;
+    callback.u.callback=callback_new_attr_0(callback_cast(dbus_main_navit),attr_navit);
+    config_add_attr(config, &callback);
 }
diff --git a/navit/binding/dbus/navit.introspect b/navit/binding/dbus/navit.introspect
index 9366c0cb3..9530a7b27 100644
--- a/navit/binding/dbus/navit.introspect
+++ b/navit/binding/dbus/navit.introspect
@@ -6,7 +6,7 @@
       <arg direction="out" type="s" />
     </method>
   </interface>
-  
+
   <interface name="org.navit_project.navit">
     <method name="get_navit">
       <arg name="iter" type="o" direction="in"/>
@@ -19,7 +19,7 @@
       <arg name="iter" type="o" direction="in"/>
     </method>
   </interface>
-  
+
   <interface name="org.navit_project.navit.navit">
     <method name="zoom">
       <arg type="i" direction="in" />
diff --git a/navit/binding/python/attr.c b/navit/binding/python/attr.c
index 2d5ed92b6..e9365c3d3 100644
--- a/navit/binding/python/attr.c
+++ b/navit/binding/python/attr.c
@@ -22,78 +22,72 @@
 #include "attr.h"
 
 typedef struct {
-	PyObject_HEAD
-	int ref;
-	struct attr *attr;
+    PyObject_HEAD
+    int ref;
+    struct attr *attr;
 } attrObject;
 
 static PyObject *
-attr_func(attrObject *self, PyObject *args)
-{
-	const char *file;
-	int ret;
-	if (!PyArg_ParseTuple(args, "s", &file))
-		return NULL;
-	ret=0;
-	return Py_BuildValue("i",ret);
+attr_func(attrObject *self, PyObject *args) {
+    const char *file;
+    int ret;
+    if (!PyArg_ParseTuple(args, "s", &file))
+        return NULL;
+    ret=0;
+    return Py_BuildValue("i",ret);
 }
 
 
 
 static PyMethodDef attr_methods[] = {
-	{"func",	(PyCFunction) attr_func, METH_VARARGS },
-	{NULL, NULL },
+    {"func",	(PyCFunction) attr_func, METH_VARARGS },
+    {NULL, NULL },
 };
 
 
 static PyObject *
-attr_getattr_py(PyObject *self, char *name)
-{
-	return Py_FindMethod(attr_methods, self, name);
+attr_getattr_py(PyObject *self, char *name) {
+    return Py_FindMethod(attr_methods, self, name);
 }
 
 static void
-attr_destroy_py(attrObject *self)
-{
-	if (! self->ref)
-		attr_free(self->attr);
+attr_destroy_py(attrObject *self) {
+    if (! self->ref)
+        attr_free(self->attr);
 }
 
 PyTypeObject attr_Type = {
-	Obj_HEAD
-	.tp_name="attr",
-	.tp_basicsize=sizeof(attrObject),
-	.tp_dealloc=(destructor)attr_destroy_py,
-	.tp_getattr=attr_getattr_py,
+    Obj_HEAD
+    .tp_name="attr",
+    .tp_basicsize=sizeof(attrObject),
+    .tp_dealloc=(destructor)attr_destroy_py,
+    .tp_getattr=attr_getattr_py,
 };
 
 struct attr *
-attr_py_get(PyObject *self)
-{
-	return ((attrObject *)self)->attr;
+attr_py_get(PyObject *self) {
+    return ((attrObject *)self)->attr;
 }
 
 PyObject *
-attr_new_py(PyObject *self, PyObject *args)
-{
-	attrObject *ret;
-	const char *name,*value;
-        if (!PyArg_ParseTuple(args, "ss", &name, &value))
-                return NULL;
-	ret=PyObject_NEW(attrObject, &attr_Type);
-	ret->attr=attr_new_from_text(name, value);
-	ret->ref=0;
-	return (PyObject *)ret;
+attr_new_py(PyObject *self, PyObject *args) {
+    attrObject *ret;
+    const char *name,*value;
+    if (!PyArg_ParseTuple(args, "ss", &name, &value))
+        return NULL;
+    ret=PyObject_NEW(attrObject, &attr_Type);
+    ret->attr=attr_new_from_text(name, value);
+    ret->ref=0;
+    return (PyObject *)ret;
 }
 
 PyObject *
-attr_new_py_ref(struct attr *attr)
-{
-	attrObject *ret;
+attr_new_py_ref(struct attr *attr) {
+    attrObject *ret;
 
-	ret=PyObject_NEW(attrObject, &attr_Type);
-	ret->ref=1;
-	ret->attr=attr;
-	return (PyObject *)ret;
+    ret=PyObject_NEW(attrObject, &attr_Type);
+    ret->ref=1;
+    ret->attr=attr;
+    return (PyObject *)ret;
 }
 
diff --git a/navit/binding/python/binding_python.c b/navit/binding/python/binding_python.c
index 51d84fe10..df90371cf 100644
--- a/navit/binding/python/binding_python.c
+++ b/navit/binding/python/binding_python.c
@@ -42,37 +42,37 @@
 /* *** coord *** */
 
 typedef struct {
-	PyObject_HEAD
-	struct coord *c;
+    PyObject_HEAD
+    struct coord *c;
 } coordObject;
 
 static void coord_destroy_py(coordObject *self);
 
 PyTypeObject coord_Type = {
-	Obj_HEAD
-	.tp_name="coord",
-	.tp_basicsize=sizeof(coordObject),
-	.tp_dealloc=(destructor)coord_destroy_py,
+    Obj_HEAD
+    .tp_name="coord",
+    .tp_basicsize=sizeof(coordObject),
+    .tp_dealloc=(destructor)coord_destroy_py,
 };
 
 
 /* *** map *** */
 
 typedef struct {
-	PyObject_HEAD
-	int ref;
-	struct map *m;
+    PyObject_HEAD
+    int ref;
+    struct map *m;
 } mapObject;
 
 static void map_destroy_py(mapObject *self);
 static PyObject *map_getattr_py(PyObject *self, char *name);
 
 PyTypeObject map_Type = {
-	Obj_HEAD
-	.tp_name="map",
-	.tp_basicsize=sizeof(mapObject),
-	.tp_dealloc=(destructor)map_destroy_py,
-	.tp_getattr=map_getattr_py,
+    Obj_HEAD
+    .tp_name="map",
+    .tp_basicsize=sizeof(mapObject),
+    .tp_dealloc=(destructor)map_destroy_py,
+    .tp_getattr=map_getattr_py,
 };
 
 /* *** IMPLEMENTATIONS *** */
@@ -80,28 +80,26 @@ PyTypeObject map_Type = {
 /* *** coord *** */
 
 static PyObject *
-coord_new_py(PyObject *self, PyObject *args)
-{
-	coordObject *ret;
-	int x,y;
-	if (!PyArg_ParseTuple(args, "ii:navit.coord",&x,&y))
-		return NULL;
-	ret=PyObject_NEW(coordObject, &coord_Type);
-	ret->c=coord_new(x,y);
-	return (PyObject *)ret;
+coord_new_py(PyObject *self, PyObject *args) {
+    coordObject *ret;
+    int x,y;
+    if (!PyArg_ParseTuple(args, "ii:navit.coord",&x,&y))
+        return NULL;
+    ret=PyObject_NEW(coordObject, &coord_Type);
+    ret->c=coord_new(x,y);
+    return (PyObject *)ret;
 }
 
 static void
-coord_destroy_py(coordObject *self)
-{
-		coord_destroy(self->c);
+coord_destroy_py(coordObject *self) {
+    coord_destroy(self->c);
 }
 
 /* *** coord_rect *** */
 
 typedef struct {
-	PyObject_HEAD
-	struct coord_rect *r;
+    PyObject_HEAD
+    struct coord_rect *r;
 } coord_rectObject;
 
 
@@ -109,38 +107,36 @@ static void coord_rect_destroy_py(coord_rectObject *self);
 
 PyTypeObject coord_rect_Type = {
 #if defined(MS_WINDOWS) || defined(__CYGWIN__)
-	PyObject_HEAD_INIT(NULL);
+    PyObject_HEAD_INIT(NULL);
 #else
-	PyObject_HEAD_INIT(&PyType_Type)
+    PyObject_HEAD_INIT(&PyType_Type)
 #endif
-	.tp_name="coord_rect",
-	.tp_basicsize=sizeof(coord_rectObject),
-	.tp_dealloc=(destructor)coord_rect_destroy_py,
+    .tp_name="coord_rect",
+    .tp_basicsize=sizeof(coord_rectObject),
+    .tp_dealloc=(destructor)coord_rect_destroy_py,
 };
 
 static PyObject *
-coord_rect_new_py(PyObject *self, PyObject *args)
-{
-	coord_rectObject *ret;
-	coordObject *lu,*rd;
-	if (!PyArg_ParseTuple(args, "O!O!:navit.coord_rect_rect",&coord_Type,&lu,&coord_Type,&rd))
-		return NULL;
-	ret=PyObject_NEW(coord_rectObject, &coord_rect_Type);
-	ret->r=coord_rect_new(lu->c,rd->c);
-	return (PyObject *)ret;
+coord_rect_new_py(PyObject *self, PyObject *args) {
+    coord_rectObject *ret;
+    coordObject *lu,*rd;
+    if (!PyArg_ParseTuple(args, "O!O!:navit.coord_rect_rect",&coord_Type,&lu,&coord_Type,&rd))
+        return NULL;
+    ret=PyObject_NEW(coord_rectObject, &coord_rect_Type);
+    ret->r=coord_rect_new(lu->c,rd->c);
+    return (PyObject *)ret;
 }
 
 static void
-coord_rect_destroy_py(coord_rectObject *self)
-{
-	coord_rect_destroy(self->r);
+coord_rect_destroy_py(coord_rectObject *self) {
+    coord_rect_destroy(self->r);
 }
 
 /* *** map_rect *** */
 
 typedef struct {
-	PyObject_HEAD
-	struct map_rect *mr;
+    PyObject_HEAD
+    struct map_rect *mr;
 } map_rectObject;
 
 
@@ -148,110 +144,102 @@ static void map_rect_destroy_py(map_rectObject *self);
 
 PyTypeObject map_rect_Type = {
 #if defined(MS_WINDOWS) || defined(__CYGWIN__)
-	PyObject_HEAD_INIT(NULL);
+    PyObject_HEAD_INIT(NULL);
 #else
-	PyObject_HEAD_INIT(&PyType_Type)
+    PyObject_HEAD_INIT(&PyType_Type)
 #endif
-	.tp_name="map_rect",
-	.tp_basicsize=sizeof(map_rectObject),
-	.tp_dealloc=(destructor)map_rect_destroy_py,
+    .tp_name="map_rect",
+    .tp_basicsize=sizeof(map_rectObject),
+    .tp_dealloc=(destructor)map_rect_destroy_py,
 };
 
 static PyObject *
-map_rect_new_py(mapObject *self, PyObject *args)
-{
-	map_rectObject *ret;
-	coord_rectObject *r;
-	if (!PyArg_ParseTuple(args, "O!:navit.map_rect_rect",&coord_rect_Type,&r))
-		return NULL;
-	ret=PyObject_NEW(map_rectObject, &map_rect_Type);
-	ret->mr=map_rect_new(self->m, NULL);
-	return (PyObject *)ret;
+map_rect_new_py(mapObject *self, PyObject *args) {
+    map_rectObject *ret;
+    coord_rectObject *r;
+    if (!PyArg_ParseTuple(args, "O!:navit.map_rect_rect",&coord_rect_Type,&r))
+        return NULL;
+    ret=PyObject_NEW(map_rectObject, &map_rect_Type);
+    ret->mr=map_rect_new(self->m, NULL);
+    return (PyObject *)ret;
 }
 
 static void
-map_rect_destroy_py(map_rectObject *self)
-{
-	map_rect_destroy(self->mr);
+map_rect_destroy_py(map_rectObject *self) {
+    map_rect_destroy(self->mr);
 }
 
 
 /* *** map *** */
 
 static PyObject *
-map_dump_file_py(mapObject *self, PyObject *args)
-{
-	const char *s;
-	if (!PyArg_ParseTuple(args, "s",&s))
-		return NULL;
-	map_dump_file(self->m, s);
-	Py_RETURN_NONE;
+map_dump_file_py(mapObject *self, PyObject *args) {
+    const char *s;
+    if (!PyArg_ParseTuple(args, "s",&s))
+        return NULL;
+    map_dump_file(self->m, s);
+    Py_RETURN_NONE;
 }
 
 
 static PyObject *
-map_set_attr_py(mapObject *self, PyObject *args)
-{
-	PyObject *attr;
-	if (!PyArg_ParseTuple(args, "O!", &attr_Type, &attr))
-		return NULL;
-	map_set_attr(self->m, attr_py_get(attr));
-	Py_RETURN_NONE;
+map_set_attr_py(mapObject *self, PyObject *args) {
+    PyObject *attr;
+    if (!PyArg_ParseTuple(args, "O!", &attr_Type, &attr))
+        return NULL;
+    map_set_attr(self->m, attr_py_get(attr));
+    Py_RETURN_NONE;
 }
 
 
 
 static PyMethodDef map_methods[] = {
-	{"dump_file",		(PyCFunction) map_dump_file_py, METH_VARARGS },
-	{"map_rect_new",	(PyCFunction) map_rect_new_py, METH_VARARGS },
-	{"set_attr",		(PyCFunction) map_set_attr_py, METH_VARARGS },
-	{NULL, NULL },
+    {"dump_file",		(PyCFunction) map_dump_file_py, METH_VARARGS },
+    {"map_rect_new",	(PyCFunction) map_rect_new_py, METH_VARARGS },
+    {"set_attr",		(PyCFunction) map_set_attr_py, METH_VARARGS },
+    {NULL, NULL },
 };
 
 static PyObject *
-map_getattr_py(PyObject *self, char *name)
-{
-	return Py_FindMethod(map_methods, self, name);
+map_getattr_py(PyObject *self, char *name) {
+    return Py_FindMethod(map_methods, self, name);
 }
 
 
 static PyObject *
-map_new_py(PyObject *self, PyObject *args)
-{
-	mapObject *ret;
-	char *type, *filename;
-	
-	if (!PyArg_ParseTuple(args, "ss:navit.map", &type, &filename))
-		return NULL;
-	ret=PyObject_NEW(mapObject, &map_Type);
-	ret->m=map_new(NULL,NULL);
-	ret->ref=0;
-	return (PyObject *)ret;
+map_new_py(PyObject *self, PyObject *args) {
+    mapObject *ret;
+    char *type, *filename;
+
+    if (!PyArg_ParseTuple(args, "ss:navit.map", &type, &filename))
+        return NULL;
+    ret=PyObject_NEW(mapObject, &map_Type);
+    ret->m=map_new(NULL,NULL);
+    ret->ref=0;
+    return (PyObject *)ret;
 }
 
 PyObject *
-map_py_ref(struct map *map)
-{
-	mapObject *ret;
-	ret=PyObject_NEW(mapObject, &map_Type);
-	ret->m=map;
-	ret->ref=1;
-	return (PyObject *)ret;
+map_py_ref(struct map *map) {
+    mapObject *ret;
+    ret=PyObject_NEW(mapObject, &map_Type);
+    ret->m=map;
+    ret->ref=1;
+    return (PyObject *)ret;
 }
 
 static void
-map_destroy_py(mapObject *self)
-{
-	if (!self->ref)
-		map_destroy(self->m);
+map_destroy_py(mapObject *self) {
+    if (!self->ref)
+        map_destroy(self->m);
 }
 
 /* *** mapset *** */
 
 
 typedef struct {
-	PyObject_HEAD
-	struct mapset *ms;
+    PyObject_HEAD
+    struct mapset *ms;
 } mapsetObject;
 
 
@@ -260,111 +248,106 @@ static PyObject *mapset_getattr_py(PyObject *self, char *name);
 
 PyTypeObject mapset_Type = {
 #if defined(MS_WINDOWS) || defined(__CYGWIN__)
-	PyObject_HEAD_INIT(NULL);
+    PyObject_HEAD_INIT(NULL);
 #else
-	PyObject_HEAD_INIT(&PyType_Type)
+    PyObject_HEAD_INIT(&PyType_Type)
 #endif
-	.tp_name="mapset",
-	.tp_basicsize=sizeof(mapsetObject),
-	.tp_dealloc=(destructor)mapset_destroy_py,
-	.tp_getattr=mapset_getattr_py,
+    .tp_name="mapset",
+    .tp_basicsize=sizeof(mapsetObject),
+    .tp_dealloc=(destructor)mapset_destroy_py,
+    .tp_getattr=mapset_getattr_py,
 };
 
 static PyObject *
-mapset_add_py(mapsetObject *self, PyObject *args)
-{
-	mapObject *map;
-	if (!PyArg_ParseTuple(args, "O:navit.mapset", &map))
-		return NULL;
-	Py_INCREF(map);
-	mapset_add_attr(self->ms, &(struct attr){attr_map,.u.map=map->m});
-	return Py_BuildValue("");
+mapset_add_py(mapsetObject *self, PyObject *args) {
+    mapObject *map;
+    if (!PyArg_ParseTuple(args, "O:navit.mapset", &map))
+        return NULL;
+    Py_INCREF(map);
+    mapset_add_attr(self->ms, &(struct attr) {
+        attr_map,.u.map=map->m
+    });
+    return Py_BuildValue("");
 }
 
 static PyMethodDef mapset_methods[] = {
-	{"add",	(PyCFunction) mapset_add_py, METH_VARARGS },
-	{NULL, NULL },
+    {"add",	(PyCFunction) mapset_add_py, METH_VARARGS },
+    {NULL, NULL },
 };
 
 static PyObject *
-mapset_getattr_py(PyObject *self, char *name)
-{
-	return Py_FindMethod(mapset_methods, self, name);
+mapset_getattr_py(PyObject *self, char *name) {
+    return Py_FindMethod(mapset_methods, self, name);
 }
 
 static PyObject *
-mapset_new_py(PyObject *self, PyObject *args)
-{
-	mapsetObject *ret;
-	if (!PyArg_ParseTuple(args, ":navit.mapset"))
-		return NULL;
-	ret=PyObject_NEW(mapsetObject, &mapset_Type);
-	ret->ms=mapset_new(NULL,NULL);
-	return (PyObject *)ret;
+mapset_new_py(PyObject *self, PyObject *args) {
+    mapsetObject *ret;
+    if (!PyArg_ParseTuple(args, ":navit.mapset"))
+        return NULL;
+    ret=PyObject_NEW(mapsetObject, &mapset_Type);
+    ret->ms=mapset_new(NULL,NULL);
+    return (PyObject *)ret;
 }
 
 static void
-mapset_destroy_py(mapsetObject *self)
-{
-	mapset_destroy(self->ms);
+mapset_destroy_py(mapsetObject *self) {
+    mapset_destroy(self->ms);
 }
 
 static PyObject *
-config_load_py(PyObject *self, PyObject *args)
-{
-	const char *file;
-	int ret;
-	xmlerror *error;
-	if (!PyArg_ParseTuple(args, "s", &file))
-		return NULL;
-	ret=config_load(file, &error);
-	return Py_BuildValue("i",ret);
+config_load_py(PyObject *self, PyObject *args) {
+    const char *file;
+    int ret;
+    xmlerror *error;
+    if (!PyArg_ParseTuple(args, "s", &file))
+        return NULL;
+    ret=config_load(file, &error);
+    return Py_BuildValue("i",ret);
 }
 
-static PyMethodDef navitMethods[]={
-	{"attr", attr_new_py, METH_VARARGS},
-	{"coord", coord_new_py, METH_VARARGS, "Create a new coordinate point."},
-	{"coord_rect", coord_rect_new_py, METH_VARARGS, "Create a new coordinate rectangle."},
-	{"map", map_new_py, METH_VARARGS, "Create a new map."},
-	{"mapset", mapset_new_py, METH_VARARGS, "Create a new mapset."},
-	{"config_load", config_load_py, METH_VARARGS, "Load a config"},
-	{"config", config_py, METH_VARARGS, "Get Config Object"},
-	{"pcoord", pcoord_py, METH_VARARGS},
-	{NULL, NULL, 0, NULL}
+static PyMethodDef navitMethods[]= {
+    {"attr", attr_new_py, METH_VARARGS},
+    {"coord", coord_new_py, METH_VARARGS, "Create a new coordinate point."},
+    {"coord_rect", coord_rect_new_py, METH_VARARGS, "Create a new coordinate rectangle."},
+    {"map", map_new_py, METH_VARARGS, "Create a new map."},
+    {"mapset", mapset_new_py, METH_VARARGS, "Create a new mapset."},
+    {"config_load", config_load_py, METH_VARARGS, "Load a config"},
+    {"config", config_py, METH_VARARGS, "Get Config Object"},
+    {"pcoord", pcoord_py, METH_VARARGS},
+    {NULL, NULL, 0, NULL}
 };
 
 
 PyObject *
-python_object_from_attr(struct attr *attr)
-{
-	switch (attr->type) {
-	case attr_navigation:
-		return navigation_py_ref(attr->u.navigation);
-	case attr_route:
-		return route_py_ref(attr->u.route);
-	default:
-		return NULL;
-	}
-	return NULL;
+python_object_from_attr(struct attr *attr) {
+    switch (attr->type) {
+    case attr_navigation:
+        return navigation_py_ref(attr->u.navigation);
+    case attr_route:
+        return route_py_ref(attr->u.route);
+    default:
+        return NULL;
+    }
+    return NULL;
 }
 
 
 void
-plugin_init(void)
-{
-	int fd,size;
-	char buffer[65536];
-
-	Py_Initialize();
-	Py_InitModule("navit", navitMethods);
-	fd=open("startup.py",O_RDONLY);
-	if (fd >= 0) {
-		size=read(fd, buffer, 65535);
-		if (size > 0) {
-			buffer[size]='\0';
-			PyRun_SimpleString(buffer);
-		}
-	}
-	
-	Py_Finalize();
+plugin_init(void) {
+    int fd,size;
+    char buffer[65536];
+
+    Py_Initialize();
+    Py_InitModule("navit", navitMethods);
+    fd=open("startup.py",O_RDONLY);
+    if (fd >= 0) {
+        size=read(fd, buffer, 65535);
+        if (size > 0) {
+            buffer[size]='\0';
+            PyRun_SimpleString(buffer);
+        }
+    }
+
+    Py_Finalize();
 }
diff --git a/navit/binding/python/config.c b/navit/binding/python/config.c
index 9d5b1ae87..d8d91ead7 100644
--- a/navit/binding/python/config.c
+++ b/navit/binding/python/config.c
@@ -22,52 +22,48 @@
 #include "config_.h"
 
 typedef struct {
-	PyObject_HEAD
+    PyObject_HEAD
 } configObject;
 
 static PyObject *
-config_navit(PyObject *self, PyObject *args)
-{
-	struct attr navit;
-	if (config_get_attr(config, attr_navit, &navit, NULL)) 
-		return navit_py_ref(navit.u.navit);
-	return NULL;
+config_navit(PyObject *self, PyObject *args) {
+    struct attr navit;
+    if (config_get_attr(config, attr_navit, &navit, NULL))
+        return navit_py_ref(navit.u.navit);
+    return NULL;
 }
 
 
 
 static PyMethodDef config_methods[] = {
-	{"navit",	(PyCFunction) config_navit, METH_VARARGS },
-	{NULL, NULL },
+    {"navit",	(PyCFunction) config_navit, METH_VARARGS },
+    {NULL, NULL },
 };
 
 
 static PyObject *
-config_getattr_py(PyObject *self, char *name)
-{
-	return Py_FindMethod(config_methods, self, name);
+config_getattr_py(PyObject *self, char *name) {
+    return Py_FindMethod(config_methods, self, name);
 }
 
 static void
-config_destroy_py(configObject *self)
-{
+config_destroy_py(configObject *self) {
 }
 
 PyTypeObject config_Type = {
-	Obj_HEAD
-	.tp_name="config",
-	.tp_basicsize=sizeof(configObject),
-	.tp_dealloc=(destructor)config_destroy_py,
-	.tp_getattr=config_getattr_py,
+    Obj_HEAD
+    .tp_name="config",
+    .tp_basicsize=sizeof(configObject),
+    .tp_dealloc=(destructor)config_destroy_py,
+    .tp_getattr=config_getattr_py,
 };
 
 PyObject *
-config_py(PyObject *self, PyObject *args)
-{
-	configObject *ret;
+config_py(PyObject *self, PyObject *args) {
+    configObject *ret;
 
-	dbg(lvl_debug,"enter");	
-	ret=PyObject_NEW(configObject, &config_Type);
-	return (PyObject *)ret;
+    dbg(lvl_debug,"enter");
+    ret=PyObject_NEW(configObject, &config_Type);
+    return (PyObject *)ret;
 }
 
diff --git a/navit/binding/python/navigation.c b/navit/binding/python/navigation.c
index 75a421d52..3e027cef3 100644
--- a/navit/binding/python/navigation.c
+++ b/navit/binding/python/navigation.c
@@ -21,62 +21,57 @@
 #include "navigation.h"
 
 typedef struct {
-	PyObject_HEAD
-	struct navigation *navigation;
+    PyObject_HEAD
+    struct navigation *navigation;
 } navigationObject;
 
 static PyObject *
-navigation_get_map_py(navigationObject *self, PyObject *args)
-{
-	if (!PyArg_ParseTuple(args, ""))
-		return NULL;
-	return map_py_ref(navigation_get_map(self->navigation));
+navigation_get_map_py(navigationObject *self, PyObject *args) {
+    if (!PyArg_ParseTuple(args, ""))
+        return NULL;
+    return map_py_ref(navigation_get_map(self->navigation));
 }
 
 
 
 static PyMethodDef navigation_methods[] = {
-	{"get_map",	(PyCFunction) navigation_get_map_py, METH_VARARGS },
-	{NULL, NULL },
+    {"get_map",	(PyCFunction) navigation_get_map_py, METH_VARARGS },
+    {NULL, NULL },
 };
 
 
 static PyObject *
-navigation_getattr_py(PyObject *self, char *name)
-{
-	return Py_FindMethod(navigation_methods, self, name);
+navigation_getattr_py(PyObject *self, char *name) {
+    return Py_FindMethod(navigation_methods, self, name);
 }
 
 static void
-navigation_destroy_py(navigationObject *self)
-{
+navigation_destroy_py(navigationObject *self) {
 }
 
 PyTypeObject navigation_Type = {
-	Obj_HEAD
-	.tp_name="navigation",
-	.tp_basicsize=sizeof(navigationObject),
-	.tp_dealloc=(destructor)navigation_destroy_py,
-	.tp_getattr=navigation_getattr_py,
+    Obj_HEAD
+    .tp_name="navigation",
+    .tp_basicsize=sizeof(navigationObject),
+    .tp_dealloc=(destructor)navigation_destroy_py,
+    .tp_getattr=navigation_getattr_py,
 };
 
 PyObject *
-navigation_py(PyObject *self, PyObject *args)
-{
-	navigationObject *ret;
+navigation_py(PyObject *self, PyObject *args) {
+    navigationObject *ret;
 
-	ret=PyObject_NEW(navigationObject, &navigation_Type);
-	return (PyObject *)ret;
+    ret=PyObject_NEW(navigationObject, &navigation_Type);
+    return (PyObject *)ret;
 }
 
 PyObject *
-navigation_py_ref(struct navigation *navigation)
-{
-	navigationObject *ret;
+navigation_py_ref(struct navigation *navigation) {
+    navigationObject *ret;
 
-	ret=PyObject_NEW(navigationObject, &navigation_Type);
-	ret->navigation=navigation;
-	return (PyObject *)ret;
+    ret=PyObject_NEW(navigationObject, &navigation_Type);
+    ret->navigation=navigation;
+    return (PyObject *)ret;
 }
 
 
diff --git a/navit/binding/python/navit.c b/navit/binding/python/navit.c
index 2ee7c3126..6991e30d7 100644
--- a/navit/binding/python/navit.c
+++ b/navit/binding/python/navit.c
@@ -22,125 +22,115 @@
 #include "navit.h"
 
 typedef struct {
-	PyObject_HEAD
-	struct navit *navit;
+    PyObject_HEAD
+    struct navit *navit;
 } navitObject;
 
 static PyObject *
-navit_set_attr_py(navitObject *self, PyObject *args)
-{
-	PyObject *attr;
-	if (!PyArg_ParseTuple(args, "O!", &attr_Type, &attr))
-		return NULL;
-	navit_set_attr(self->navit, attr_py_get(attr));
-	Py_RETURN_NONE;
+navit_set_attr_py(navitObject *self, PyObject *args) {
+    PyObject *attr;
+    if (!PyArg_ParseTuple(args, "O!", &attr_Type, &attr))
+        return NULL;
+    navit_set_attr(self->navit, attr_py_get(attr));
+    Py_RETURN_NONE;
 }
 
 static PyObject *
-navit_get_attr_py(navitObject *self, PyObject *args)
-{
-	char *name;
-	struct attr attr;
-	if (!PyArg_ParseTuple(args, "s", &name))
-		return NULL;
-	if (!navit_get_attr(self->navit, attr_from_name(name), &attr, NULL)) {
-		dbg(lvl_error,"get_attr not ok");
-		Py_RETURN_NONE;
-	}
-	dbg(lvl_debug,"get_attr ok");
-	return python_object_from_attr(&attr);
+navit_get_attr_py(navitObject *self, PyObject *args) {
+    char *name;
+    struct attr attr;
+    if (!PyArg_ParseTuple(args, "s", &name))
+        return NULL;
+    if (!navit_get_attr(self->navit, attr_from_name(name), &attr, NULL)) {
+        dbg(lvl_error,"get_attr not ok");
+        Py_RETURN_NONE;
+    }
+    dbg(lvl_debug,"get_attr ok");
+    return python_object_from_attr(&attr);
 }
 
 static PyObject *
-navit_set_center_py(navitObject *self, PyObject *args)
-{
-	PyObject *pcoord;
-	if (!PyArg_ParseTuple(args, "O!", &pcoord_Type, &pcoord))
-		return NULL;
-	navit_set_center(self->navit, pcoord_py_get(pcoord), 0);
-	Py_RETURN_NONE;
+navit_set_center_py(navitObject *self, PyObject *args) {
+    PyObject *pcoord;
+    if (!PyArg_ParseTuple(args, "O!", &pcoord_Type, &pcoord))
+        return NULL;
+    navit_set_center(self->navit, pcoord_py_get(pcoord), 0);
+    Py_RETURN_NONE;
 }
 
 static PyObject *
-navit_set_destination_py(navitObject *self, PyObject *args)
-{
-	PyObject *pcoord;
-	const char *description;
-	int async;
-	if (!PyArg_ParseTuple(args, "O!si", &pcoord_Type, &pcoord, &description, &async))
-		return NULL;
-	navit_set_destination(self->navit, pcoord_py_get(pcoord), description, async);
-	Py_RETURN_NONE;
+navit_set_destination_py(navitObject *self, PyObject *args) {
+    PyObject *pcoord;
+    const char *description;
+    int async;
+    if (!PyArg_ParseTuple(args, "O!si", &pcoord_Type, &pcoord, &description, &async))
+        return NULL;
+    navit_set_destination(self->navit, pcoord_py_get(pcoord), description, async);
+    Py_RETURN_NONE;
 }
 
 static PyObject *
-navit_set_position_py(navitObject *self, PyObject *args)
-{
-	PyObject *pcoord;
-	if (!PyArg_ParseTuple(args, "O!", &pcoord_Type, &pcoord))
-		return NULL;
-	navit_set_position(self->navit, pcoord_py_get(pcoord));
-	Py_RETURN_NONE;
+navit_set_position_py(navitObject *self, PyObject *args) {
+    PyObject *pcoord;
+    if (!PyArg_ParseTuple(args, "O!", &pcoord_Type, &pcoord))
+        return NULL;
+    navit_set_position(self->navit, pcoord_py_get(pcoord));
+    Py_RETURN_NONE;
 }
 
 
 static PyObject *
-navit_zoom_to_route_py(navitObject *self, PyObject *args)
-{
-	if (!PyArg_ParseTuple(args, ""))
-		return NULL;
-	navit_zoom_to_route(self->navit,0);
-	Py_RETURN_NONE;
+navit_zoom_to_route_py(navitObject *self, PyObject *args) {
+    if (!PyArg_ParseTuple(args, ""))
+        return NULL;
+    navit_zoom_to_route(self->navit,0);
+    Py_RETURN_NONE;
 }
 
 
 
 
 static PyMethodDef navit_methods[] = {
-	{"set_attr",		(PyCFunction) navit_set_attr_py, METH_VARARGS },
-	{"get_attr",		(PyCFunction) navit_get_attr_py, METH_VARARGS },
-	{"set_center",		(PyCFunction) navit_set_center_py, METH_VARARGS },
-	{"set_destination",	(PyCFunction) navit_set_destination_py, METH_VARARGS },
-	{"set_position",	(PyCFunction) navit_set_position_py, METH_VARARGS },
-	{"zoom_to_route",	(PyCFunction) navit_zoom_to_route_py, METH_VARARGS },
-	{NULL, NULL },
+    {"set_attr",		(PyCFunction) navit_set_attr_py, METH_VARARGS },
+    {"get_attr",		(PyCFunction) navit_get_attr_py, METH_VARARGS },
+    {"set_center",		(PyCFunction) navit_set_center_py, METH_VARARGS },
+    {"set_destination",	(PyCFunction) navit_set_destination_py, METH_VARARGS },
+    {"set_position",	(PyCFunction) navit_set_position_py, METH_VARARGS },
+    {"zoom_to_route",	(PyCFunction) navit_zoom_to_route_py, METH_VARARGS },
+    {NULL, NULL },
 };
 
 
 static PyObject *
-navit_getattr_py(PyObject *self, char *name)
-{
-	return Py_FindMethod(navit_methods, self, name);
+navit_getattr_py(PyObject *self, char *name) {
+    return Py_FindMethod(navit_methods, self, name);
 }
 
 static void
-navit_destroy_py(navitObject *self)
-{
+navit_destroy_py(navitObject *self) {
 }
 
 PyTypeObject navit_Type = {
-	Obj_HEAD
-	.tp_name="navit",
-	.tp_basicsize=sizeof(navitObject),
-	.tp_dealloc=(destructor)navit_destroy_py,
-	.tp_getattr=navit_getattr_py,
+    Obj_HEAD
+    .tp_name="navit",
+    .tp_basicsize=sizeof(navitObject),
+    .tp_dealloc=(destructor)navit_destroy_py,
+    .tp_getattr=navit_getattr_py,
 };
 
 PyObject *
-navit_py(PyObject *self, PyObject *args)
-{
-	navitObject *ret;
+navit_py(PyObject *self, PyObject *args) {
+    navitObject *ret;
 
-	dbg(lvl_debug,"enter");	
-	ret=PyObject_NEW(navitObject, &navit_Type);
-	return (PyObject *)ret;
+    dbg(lvl_debug,"enter");
+    ret=PyObject_NEW(navitObject, &navit_Type);
+    return (PyObject *)ret;
 }
 
 PyObject *
-navit_py_ref(struct navit *navit)
-{
-	dbg(lvl_debug,"navit=%p", navit);
-	navitObject *ret=PyObject_NEW(navitObject, &navit_Type);
-	ret->navit=navit;
-	return (PyObject *)ret;
+navit_py_ref(struct navit *navit) {
+    dbg(lvl_debug,"navit=%p", navit);
+    navitObject *ret=PyObject_NEW(navitObject, &navit_Type);
+    ret->navit=navit;
+    return (PyObject *)ret;
 }
diff --git a/navit/binding/python/pcoord.c b/navit/binding/python/pcoord.c
index 1588067bd..e27c44a75 100644
--- a/navit/binding/python/pcoord.c
+++ b/navit/binding/python/pcoord.c
@@ -21,68 +21,63 @@
 #include "coord.h"
 
 typedef struct {
-	PyObject_HEAD
-	struct pcoord pc;
+    PyObject_HEAD
+    struct pcoord pc;
 } pcoordObject;
 
 static PyObject *
-pcoord_func(pcoordObject *self, PyObject *args)
-{
-	const char *file;
-	int ret=0;
-	if (!PyArg_ParseTuple(args, "s", &file))
-		return NULL;
-	return Py_BuildValue("i",ret);
+pcoord_func(pcoordObject *self, PyObject *args) {
+    const char *file;
+    int ret=0;
+    if (!PyArg_ParseTuple(args, "s", &file))
+        return NULL;
+    return Py_BuildValue("i",ret);
 }
 
 
 
 static PyMethodDef pcoord_methods[] = {
-	{"func",	(PyCFunction) pcoord_func, METH_VARARGS },
-	{NULL, NULL },
+    {"func",	(PyCFunction) pcoord_func, METH_VARARGS },
+    {NULL, NULL },
 };
 
 
 static PyObject *
-pcoord_getattr_py(PyObject *self, char *name)
-{
-	return Py_FindMethod(pcoord_methods, self, name);
+pcoord_getattr_py(PyObject *self, char *name) {
+    return Py_FindMethod(pcoord_methods, self, name);
 }
 
 static void
-pcoord_destroy_py(pcoordObject *self)
-{
+pcoord_destroy_py(pcoordObject *self) {
 }
 
 PyTypeObject pcoord_Type = {
-	Obj_HEAD
-	.tp_name="pcoord",
-	.tp_basicsize=sizeof(pcoordObject),
-	.tp_dealloc=(destructor)pcoord_destroy_py,
-	.tp_getattr=pcoord_getattr_py,
+    Obj_HEAD
+    .tp_name="pcoord",
+    .tp_basicsize=sizeof(pcoordObject),
+    .tp_dealloc=(destructor)pcoord_destroy_py,
+    .tp_getattr=pcoord_getattr_py,
 };
 
 PyObject *
-pcoord_py(PyObject *self, PyObject *args)
-{
-	pcoordObject *ret;
-	const char *str;
-	enum projection pro;
-	struct coord c;
-	if (!PyArg_ParseTuple(args, "si", &str, &pro))
-		return NULL;
-	ret=PyObject_NEW(pcoordObject, &pcoord_Type);
-	coord_parse(str, pro, &c);
-	ret->pc.pro=pro;
-	ret->pc.x=c.x;
-	ret->pc.y=c.y;
-	dbg(lvl_debug,"0x%x,0x%x", c.x, c.y);
-	return (PyObject *)ret;
+pcoord_py(PyObject *self, PyObject *args) {
+    pcoordObject *ret;
+    const char *str;
+    enum projection pro;
+    struct coord c;
+    if (!PyArg_ParseTuple(args, "si", &str, &pro))
+        return NULL;
+    ret=PyObject_NEW(pcoordObject, &pcoord_Type);
+    coord_parse(str, pro, &c);
+    ret->pc.pro=pro;
+    ret->pc.x=c.x;
+    ret->pc.y=c.y;
+    dbg(lvl_debug,"0x%x,0x%x", c.x, c.y);
+    return (PyObject *)ret;
 }
 
 struct pcoord *
-pcoord_py_get(PyObject *self)
-{
-	return &((pcoordObject *)self)->pc;
+pcoord_py_get(PyObject *self) {
+    return &((pcoordObject *)self)->pc;
 }
 
diff --git a/navit/binding/python/route.c b/navit/binding/python/route.c
index dfbd08cf9..8010b416f 100644
--- a/navit/binding/python/route.c
+++ b/navit/binding/python/route.c
@@ -23,62 +23,57 @@
 #include "route.h"
 
 typedef struct {
-	PyObject_HEAD
-	struct route *route;
+    PyObject_HEAD
+    struct route *route;
 } routeObject;
 
 static PyObject *
-route_get_map_py(routeObject *self, PyObject *args)
-{
-	if (!PyArg_ParseTuple(args, ""))
-		return NULL;
-	return map_py_ref(route_get_map(self->route));
+route_get_map_py(routeObject *self, PyObject *args) {
+    if (!PyArg_ParseTuple(args, ""))
+        return NULL;
+    return map_py_ref(route_get_map(self->route));
 }
 
 
 
 static PyMethodDef route_methods[] = {
-	{"get_map",	(PyCFunction) route_get_map_py, METH_VARARGS },
-	{NULL, NULL },
+    {"get_map",	(PyCFunction) route_get_map_py, METH_VARARGS },
+    {NULL, NULL },
 };
 
 
 static PyObject *
-route_getattr_py(PyObject *self, char *name)
-{
-	return Py_FindMethod(route_methods, self, name);
+route_getattr_py(PyObject *self, char *name) {
+    return Py_FindMethod(route_methods, self, name);
 }
 
 static void
-route_destroy_py(routeObject *self)
-{
+route_destroy_py(routeObject *self) {
 }
 
 PyTypeObject route_Type = {
-	Obj_HEAD
-	.tp_name="route",
-	.tp_basicsize=sizeof(routeObject),
-	.tp_dealloc=(destructor)route_destroy_py,
-	.tp_getattr=route_getattr_py,
+    Obj_HEAD
+    .tp_name="route",
+    .tp_basicsize=sizeof(routeObject),
+    .tp_dealloc=(destructor)route_destroy_py,
+    .tp_getattr=route_getattr_py,
 };
 
 PyObject *
-route_py(PyObject *self, PyObject *args)
-{
-	routeObject *ret;
+route_py(PyObject *self, PyObject *args) {
+    routeObject *ret;
 
-	ret=PyObject_NEW(routeObject, &route_Type);
-	return (PyObject *)ret;
+    ret=PyObject_NEW(routeObject, &route_Type);
+    return (PyObject *)ret;
 }
 
 PyObject *
-route_py_ref(struct route *route)
-{
-	routeObject *ret;
+route_py_ref(struct route *route) {
+    routeObject *ret;
 
-	ret=PyObject_NEW(routeObject, &route_Type);
-	ret->route=route;
-	return (PyObject *)ret;
+    ret=PyObject_NEW(routeObject, &route_Type);
+    ret->route=route;
+    return (PyObject *)ret;
 }
 
 
diff --git a/navit/binding/python/template.c b/navit/binding/python/template.c
index 088cb5ee3..2019173a3 100644
--- a/navit/binding/python/template.c
+++ b/navit/binding/python/template.c
@@ -21,76 +21,70 @@
 #include "template.h"
 
 typedef struct {
-	PyObject_HEAD
-	int ref;
-	struct template *template;
+    PyObject_HEAD
+    int ref;
+    struct template *template;
 } templateObject;
 
 static PyObject *
-template_func(templateObject *self, PyObject *args)
-{
-	const char *file;
-	int ret;
-	if (!PyArg_ParseTuple(args, "s", &file))
-		return NULL;
-	ret=0;
-	return Py_BuildValue("i",ret);
+template_func(templateObject *self, PyObject *args) {
+    const char *file;
+    int ret;
+    if (!PyArg_ParseTuple(args, "s", &file))
+        return NULL;
+    ret=0;
+    return Py_BuildValue("i",ret);
 }
 
 
 
 static PyMethodDef template_methods[] = {
-	{"func",	(PyCFunction) template_func, METH_VARARGS },
-	{NULL, NULL },
+    {"func",	(PyCFunction) template_func, METH_VARARGS },
+    {NULL, NULL },
 };
 
 
 static PyObject *
-template_getattr_py(PyObject *self, char *name)
-{
-	return Py_FindMethod(template_methods, self, name);
+template_getattr_py(PyObject *self, char *name) {
+    return Py_FindMethod(template_methods, self, name);
 }
 
 static void
-template_destroy_py(templateObject *self)
-{
-	if (! self->ref)
-		template_destroy(self->template);
+template_destroy_py(templateObject *self) {
+    if (! self->ref)
+        template_destroy(self->template);
 }
 
 PyTypeObject template_Type = {
-	Obj_HEAD
-	.tp_name="template",
-	.tp_basicsize=sizeof(templateObject),
-	.tp_dealloc=(destructor)template_destroy_py,
-	.tp_getattr=template_getattr_py,
+    Obj_HEAD
+    .tp_name="template",
+    .tp_basicsize=sizeof(templateObject),
+    .tp_dealloc=(destructor)template_destroy_py,
+    .tp_getattr=template_getattr_py,
 };
 
 struct template *
-template_py_get(PyObject *self)
-{
-	return ((templateObject *)self)->template;
+template_py_get(PyObject *self) {
+    return ((templateObject *)self)->template;
 }
 
 PyObject *
-template_new_py(PyObject *self, PyObject *args)
-{
-	templateObject *ret;
-
-	ret=PyObject_NEW(templateObject, &template_Type);
-	ret->template=template_new();
-	ret->ref=0;
-	return (PyObject *)ret;
+template_new_py(PyObject *self, PyObject *args) {
+    templateObject *ret;
+
+    ret=PyObject_NEW(templateObject, &template_Type);
+    ret->template=template_new();
+    ret->ref=0;
+    return (PyObject *)ret;
 }
 
 PyObject *
-template_new_py_ref(struct template *template)
-{
-	templateObject *ret;
-
-	ret=PyObject_NEW(templateObject, &template_Type);
-	ret->ref=1;
-	ret->template=template;
-	return (PyObject *)ret;
+template_new_py_ref(struct template *template) {
+    templateObject *ret;
+
+    ret=PyObject_NEW(templateObject, &template_Type);
+    ret->ref=1;
+    ret->template=template;
+    return (PyObject *)ret;
 }
 
diff --git a/navit/binding/win32/CMakeLists.txt b/navit/binding/win32/CMakeLists.txt
index 792a8ff43..710a4dcf6 100644
--- a/navit/binding/win32/CMakeLists.txt
+++ b/navit/binding/win32/CMakeLists.txt
@@ -2,8 +2,8 @@ if (USE_LIBGNUINTL AND NOT HAVE_GLIB)
    ADD_DEPENDENCIES(support_glib intl_cmake)
 endif()
 
-module_add_library(binding_win32 binding_win32.c) 
+module_add_library(binding_win32 binding_win32.c)
 
 add_executable(tell_navit tell_navit.c)
-target_link_libraries(tell_navit  ${MODULES_NAME} ${NAVIT_SUPPORT_LIBS} fib ${NAVIT_LIBS} ) 
+target_link_libraries(tell_navit  ${MODULES_NAME} ${NAVIT_SUPPORT_LIBS} fib ${NAVIT_LIBS} )
 install(TARGETS tell_navit DESTINATION ${BIN_DIR} PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE)
diff --git a/navit/binding/win32/binding_win32.c b/navit/binding/win32/binding_win32.c
index e44aff66b..c50bb959e 100644
--- a/navit/binding/win32/binding_win32.c
+++ b/navit/binding/win32/binding_win32.c
@@ -49,97 +49,94 @@
 #include "binding_win32.h"
 
 struct win32_binding_private {
-	struct navit* navit;
+    struct navit* navit;
 };
 
 
 
 /* TODO: do something meaningful here
- * 
+ *
  */
 static int
-win32_cmd_send_signal(struct navit *navit, char *command, struct attr **in, struct attr ***out)
-{
-	dbg(lvl_error,"this function is a stub");
-	if (in) {
-		while (*in) {
-			dbg(lvl_debug,"another attribute to be sent");
-			in++;
-		}
-	}
-	return 0;
+win32_cmd_send_signal(struct navit *navit, char *command, struct attr **in, struct attr ***out) {
+    dbg(lvl_error,"this function is a stub");
+    if (in) {
+        while (*in) {
+            dbg(lvl_debug,"another attribute to be sent");
+            in++;
+        }
+    }
+    return 0;
 }
 
 
 static struct command_table commands[] = {
-        {"win32_send",command_cast(win32_cmd_send_signal)},
+    {"win32_send",command_cast(win32_cmd_send_signal)},
 };
 
 
 static void
-win32_wm_copydata(struct win32_binding_private *this, int *hwndSender, COPYDATASTRUCT *cpd)
-{
-        struct attr navit;
-        struct navit_binding_w32_msg *msg;
-        navit.type=attr_navit;
-        navit.u.navit=this->navit;
-        if(cpd->dwData!=NAVIT_BINDING_W32_DWDATA) {
-        	dbg(lvl_error,"COPYDATA message came with wrong DWDATA value, expected %d, got %d.",NAVIT_BINDING_W32_DWDATA,cpd->dwData);
-        	return;
-        }
-        if(cpd->cbData<sizeof(*msg)) {
-        	dbg(lvl_error,"COPYDATA message too short, expected >=%d, got %d.",sizeof(*msg),cpd->cbData);
-        	return;
-        }
-        msg=cpd->lpData;
-        if(cpd->dwData!=NAVIT_BINDING_W32_VERSION) {
-        	dbg(lvl_error,"Got request with wrong version number, expected %d, got %d.",NAVIT_BINDING_W32_VERSION,msg->version);
-        	return;
-        }
-        if(strcmp(NAVIT_BINDING_W32_MAGIC,msg->magic)) {
-        	dbg(lvl_error,"Got request with wrong MAGIC, expected %s, got %*s.",NAVIT_BINDING_W32_MAGIC, msg->magic,sizeof(msg->magic));
-        	return;
-        }
-	dbg(lvl_debug,"Running command %s", msg->text);
-        command_evaluate(&navit, msg->text);
+win32_wm_copydata(struct win32_binding_private *this, int *hwndSender, COPYDATASTRUCT *cpd) {
+    struct attr navit;
+    struct navit_binding_w32_msg *msg;
+    navit.type=attr_navit;
+    navit.u.navit=this->navit;
+    if(cpd->dwData!=NAVIT_BINDING_W32_DWDATA) {
+        dbg(lvl_error,"COPYDATA message came with wrong DWDATA value, expected %d, got %d.",NAVIT_BINDING_W32_DWDATA,
+            cpd->dwData);
+        return;
+    }
+    if(cpd->cbData<sizeof(*msg)) {
+        dbg(lvl_error,"COPYDATA message too short, expected >=%d, got %d.",sizeof(*msg),cpd->cbData);
+        return;
+    }
+    msg=cpd->lpData;
+    if(cpd->dwData!=NAVIT_BINDING_W32_VERSION) {
+        dbg(lvl_error,"Got request with wrong version number, expected %d, got %d.",NAVIT_BINDING_W32_VERSION,msg->version);
+        return;
+    }
+    if(strcmp(NAVIT_BINDING_W32_MAGIC,msg->magic)) {
+        dbg(lvl_error,"Got request with wrong MAGIC, expected %s, got %*s.",NAVIT_BINDING_W32_MAGIC, msg->magic,
+            sizeof(msg->magic));
+        return;
+    }
+    dbg(lvl_debug,"Running command %s", msg->text);
+    command_evaluate(&navit, msg->text);
 }
 
 static void
-win32_cb_graphics_ready(struct win32_binding_private *this, struct navit *navit)
-{
-	struct graphics *gra;
-	struct callback *gcb;
-
-	gcb=callback_new_attr_1(callback_cast(win32_wm_copydata),attr_wm_copydata, this);
-	gra=navit_get_graphics(navit);
-	dbg_assert(gra);
-	graphics_add_callback(gra, gcb);
+win32_cb_graphics_ready(struct win32_binding_private *this, struct navit *navit) {
+    struct graphics *gra;
+    struct callback *gcb;
+
+    gcb=callback_new_attr_1(callback_cast(win32_wm_copydata),attr_wm_copydata, this);
+    gra=navit_get_graphics(navit);
+    dbg_assert(gra);
+    graphics_add_callback(gra, gcb);
 }
 
 static void
-win32_main_navit(struct win32_binding_private *this, struct navit *navit, int added)
-{
-	struct attr attr;
-	dbg(lvl_debug,"enter");
-	if (added==1) {
-		dbg(lvl_debug,"enter2");
-		this->navit=navit;
-		command_add_table_attr(commands, sizeof(commands)/sizeof(struct command_table), navit, &attr);
-		navit_add_attr(navit, &attr);
-		navit_add_callback(navit,callback_new_attr_1(callback_cast(win32_cb_graphics_ready),attr_graphics_ready, this));
-	}
+win32_main_navit(struct win32_binding_private *this, struct navit *navit, int added) {
+    struct attr attr;
+    dbg(lvl_debug,"enter");
+    if (added==1) {
+        dbg(lvl_debug,"enter2");
+        this->navit=navit;
+        command_add_table_attr(commands, sizeof(commands)/sizeof(struct command_table), navit, &attr);
+        navit_add_attr(navit, &attr);
+        navit_add_callback(navit,callback_new_attr_1(callback_cast(win32_cb_graphics_ready),attr_graphics_ready, this));
+    }
 
 }
 
 
 
-void plugin_init(void)
-{
-	struct attr callback;
-	struct win32_binding_private *this=g_new0(struct win32_binding_private,1);
-	dbg(lvl_debug,"enter");
-	callback.type=attr_callback;
-	callback.u.callback=callback_new_attr_1(callback_cast(win32_main_navit),attr_navit,this);
-	config_add_attr(config, &callback);
+void plugin_init(void) {
+    struct attr callback;
+    struct win32_binding_private *this=g_new0(struct win32_binding_private,1);
+    dbg(lvl_debug,"enter");
+    callback.type=attr_callback;
+    callback.u.callback=callback_new_attr_1(callback_cast(win32_main_navit),attr_navit,this);
+    config_add_attr(config, &callback);
 }
 
diff --git a/navit/binding/win32/tell_navit.c b/navit/binding/win32/tell_navit.c
index e06f73258..f99319f92 100644
--- a/navit/binding/win32/tell_navit.c
+++ b/navit/binding/win32/tell_navit.c
@@ -29,151 +29,146 @@
 #include <glib.h>
 #include "binding_win32.h"
 
-static LRESULT CALLBACK message_handler( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
-{
-	switch(uMsg) {
-		case WM_CREATE: 
-			return 0;
-	}
-	return TRUE;
+static LRESULT CALLBACK message_handler( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam ) {
+    switch(uMsg) {
+    case WM_CREATE:
+        return 0;
+    }
+    return TRUE;
 }
 
 int errormode=1;
 
-void err(char *fmt, ...)
-{
-	va_list ap;
-	char buf[1024];
+void err(char *fmt, ...) {
+    va_list ap;
+    char buf[1024];
 #if defined HAVE_API_WIN32_CE
 #define vsnprintf _vsnprintf
 #endif
-	va_start(ap, fmt);
-	vsnprintf(buf, sizeof(buf), fmt, ap);
-	va_end(ap);
-	switch(errormode) {
-		case 0: /* be silent */
-			break;
-		case 1: 
-			MessageBox(NULL, buf, "tell_navit", MB_ICONERROR|MB_OK);
-			break;
-		case 2:
-			fprintf(stderr,"%s",buf);
-			break;
-	}
+    va_start(ap, fmt);
+    vsnprintf(buf, sizeof(buf), fmt, ap);
+    va_end(ap);
+    switch(errormode) {
+    case 0: /* be silent */
+        break;
+    case 1:
+        MessageBox(NULL, buf, "tell_navit", MB_ICONERROR|MB_OK);
+        break;
+    case 2:
+        fprintf(stderr,"%s",buf);
+        break;
+    }
 }
 
-void print_usage(void)
-{
-	err(
-	"tell_navit usage:\n"
-	"tell_navit [options] navit_command\n"
-	"\t-h this help\n"
-	"\t-e <way>: set way to report error messages:\n"
-	"\t\t0 - suppress messages\n"
-	"\t\t1 - use messagebox (default)\n"
-	"\t\t2 - print to stderr\n"
-  );
+void print_usage(void) {
+    err(
+        "tell_navit usage:\n"
+        "tell_navit [options] navit_command\n"
+        "\t-h this help\n"
+        "\t-e <way>: set way to report error messages:\n"
+        "\t\t0 - suppress messages\n"
+        "\t\t1 - use messagebox (default)\n"
+        "\t\t2 - print to stderr\n"
+    );
 }
 
-int main(int argc, char **argv)
-{
-	HWND navitWindow;
-	COPYDATASTRUCT cd;
-	char opt;
-
-	TCHAR *g_szClassName  = TEXT("TellNavitWND");
-	WNDCLASS wc;
-	HWND hwnd;
-	HWND hWndParent=NULL;
-
-
-	if(argc>0) {
-		while((opt = getopt(argc, argv, ":hvc:d:e:s:")) != -1) {
-			switch(opt){
-			case 'h':
-				print_usage();
-				exit(0);
-				break;
-			case 'e':
-				errormode=atoi(optarg);
-				break;
-			default:
-				err("Unknown option %c\n", opt);
-				exit(1);
-				break;
-			}
-		}
-	} else {
-	print_usage();
-	exit(1);
-	}
-	if(optind==argc) {
-		err("Navit command to execute is needed.");
-		exit(1);
-	}
-
-
-	memset(&wc, 0 , sizeof(WNDCLASS));
-	wc.lpfnWndProc	= message_handler;
-	wc.hInstance	= GetModuleHandle(NULL);
-	wc.lpszClassName = g_szClassName;
-
-	if (!RegisterClass(&wc))
-	{
-		err(TEXT("Window class registration failed\n"));
-		return 1;
-	} else {
-		hwnd = CreateWindow(
-				g_szClassName,
-				TEXT("Tell Navit"),
-				0,
-				0,
-				0,
-				0,
-				0,
-				hWndParent,
-				NULL,
-				GetModuleHandle(NULL),
-				NULL);
-		if(!hwnd) {
-			err(TEXT("Can't create hidden window\n"));
-			UnregisterClass(g_szClassName,NULL);
-			return 1;
-		}
-	}
-    
-	navitWindow=FindWindow( TEXT("NAVGRA"), NULL );
-	if(!navitWindow) {
-		err(TEXT("Navit window not found\n"));
-		DestroyWindow(hwnd);
-		UnregisterClass(g_szClassName,NULL);
-		return 1;
-	} else {
-		int rv;
-		char *command=g_strjoinv(" ",argv+optind);
-		struct navit_binding_w32_msg *msg;
-		int sz=sizeof(*msg)+strlen(command);
-
-		cd.dwData=NAVIT_BINDING_W32_DWDATA;
-		msg=g_malloc0(sz);
-		msg->version=NAVIT_BINDING_W32_VERSION;
-		g_strlcpy(msg->magic,NAVIT_BINDING_W32_MAGIC,sizeof(msg->magic));
-		g_strlcpy(msg->text,command,sz-sizeof(*msg)+1);
-		cd.cbData=sz;
-		cd.lpData=msg;
-		rv=SendMessage( navitWindow, WM_COPYDATA, (WPARAM)hwnd, (LPARAM) (LPVOID) &cd );
-		g_free(command);
-		g_free(msg);
-		if(rv!=0) {
-			err(TEXT("Error %d sending message, SendMessage return value is %d\n"), GetLastError(), rv);
-			DestroyWindow(hwnd);
-			UnregisterClass(g_szClassName,NULL);
-			return 1;
-		}
-	}
-	DestroyWindow(hwnd);
-	UnregisterClass(g_szClassName,NULL);
-	return 0;
+int main(int argc, char **argv) {
+    HWND navitWindow;
+    COPYDATASTRUCT cd;
+    char opt;
+
+    TCHAR *g_szClassName  = TEXT("TellNavitWND");
+    WNDCLASS wc;
+    HWND hwnd;
+    HWND hWndParent=NULL;
+
+
+    if(argc>0) {
+        while((opt = getopt(argc, argv, ":hvc:d:e:s:")) != -1) {
+            switch(opt) {
+            case 'h':
+                print_usage();
+                exit(0);
+                break;
+            case 'e':
+                errormode=atoi(optarg);
+                break;
+            default:
+                err("Unknown option %c\n", opt);
+                exit(1);
+                break;
+            }
+        }
+    } else {
+        print_usage();
+        exit(1);
+    }
+    if(optind==argc) {
+        err("Navit command to execute is needed.");
+        exit(1);
+    }
+
+
+    memset(&wc, 0, sizeof(WNDCLASS));
+    wc.lpfnWndProc	= message_handler;
+    wc.hInstance	= GetModuleHandle(NULL);
+    wc.lpszClassName = g_szClassName;
+
+    if (!RegisterClass(&wc)) {
+        err(TEXT("Window class registration failed\n"));
+        return 1;
+    } else {
+        hwnd = CreateWindow(
+                   g_szClassName,
+                   TEXT("Tell Navit"),
+                   0,
+                   0,
+                   0,
+                   0,
+                   0,
+                   hWndParent,
+                   NULL,
+                   GetModuleHandle(NULL),
+                   NULL);
+        if(!hwnd) {
+            err(TEXT("Can't create hidden window\n"));
+            UnregisterClass(g_szClassName,NULL);
+            return 1;
+        }
+    }
+
+    navitWindow=FindWindow( TEXT("NAVGRA"), NULL );
+    if(!navitWindow) {
+        err(TEXT("Navit window not found\n"));
+        DestroyWindow(hwnd);
+        UnregisterClass(g_szClassName,NULL);
+        return 1;
+    } else {
+        int rv;
+        char *command=g_strjoinv(" ",argv+optind);
+        struct navit_binding_w32_msg *msg;
+        int sz=sizeof(*msg)+strlen(command);
+
+        cd.dwData=NAVIT_BINDING_W32_DWDATA;
+        msg=g_malloc0(sz);
+        msg->version=NAVIT_BINDING_W32_VERSION;
+        g_strlcpy(msg->magic,NAVIT_BINDING_W32_MAGIC,sizeof(msg->magic));
+        g_strlcpy(msg->text,command,sz-sizeof(*msg)+1);
+        cd.cbData=sz;
+        cd.lpData=msg;
+        rv=SendMessage( navitWindow, WM_COPYDATA, (WPARAM)hwnd, (LPARAM) (LPVOID) &cd );
+        g_free(command);
+        g_free(msg);
+        if(rv!=0) {
+            err(TEXT("Error %d sending message, SendMessage return value is %d\n"), GetLastError(), rv);
+            DestroyWindow(hwnd);
+            UnregisterClass(g_szClassName,NULL);
+            return 1;
+        }
+    }
+    DestroyWindow(hwnd);
+    UnregisterClass(g_szClassName,NULL);
+    return 0;
 }