Merge branch 'trunk' into traffic

# Conflicts:
#	navit/binding/dbus/binding_dbus.c
#	navit/gui/internal/gui_internal_html.c
#	navit/route.c
#	navit/util.c
#	navit/xmlconfig.c

13 files changed, 193 insertions, 358 deletions

diff --git a/navit/binding/dbus/binding_dbus.c b/navit/binding/dbus/binding_dbus.c
index a0009f3b5..cac1cb339 100644
--- a/navit/binding/dbus/binding_dbus.c
+++ b/navit/binding/dbus/binding_dbus.c
@@ -81,8 +81,7 @@ struct dbus_callback {
     char *signal;
 };
 
-static char *
-object_new(char *type, void *object) {
+static char *object_new(char *type, void *object) {
     int id;
     char *ret;
     dbg(lvl_debug,"enter %s", type);
@@ -97,13 +96,11 @@ object_new(char *type, void *object) {
     return (ret);
 }
 
-static void *
-object_get(const char *path) {
+static void *object_get(const char *path) {
     return g_hash_table_lookup(object_hash, path);
 }
 
-static void
-object_destroy(const char *path, void *object) {
+static void object_destroy(const char *path, void *object) {
     if (!path && !object)
         return;
     if (!object)
@@ -114,8 +111,7 @@ object_destroy(const char *path, void *object) {
     g_hash_table_remove(object_hash_rev, object);
 }
 
-static void *
-resolve_object(const char *opath, char *type) {
+static void *resolve_object(const char *opath, char *type) {
     char *prefix;
     const char *oprefix;
     void *ret=NULL;
@@ -214,8 +210,7 @@ resolve_object(const char *opath, char *type) {
     return NULL;
 }
 
-static void *
-object_get_from_message_arg(DBusMessageIter *iter, char *type) {
+static void *object_get_from_message_arg(DBusMessageIter *iter, char *type) {
     char *opath;
 
     if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_OBJECT_PATH)
@@ -225,13 +220,11 @@ object_get_from_message_arg(DBusMessageIter *iter, char *type) {
     return resolve_object(opath, type);
 }
 
-static void *
-object_get_from_message(DBusMessage *message, char *type) {
+static void *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) {
+static enum attr_type attr_type_get_from_message(DBusMessageIter *iter) {
     char *attr_type;
 
     if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_STRING)
@@ -241,16 +234,14 @@ attr_type_get_from_message(DBusMessageIter *iter) {
     return attr_from_name(attr_type);
 }
 
-static void
-encode_variant_string(DBusMessageIter *iter, char *str) {
+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);
 }
 
-static void
-encode_dict_string_variant_string(DBusMessageIter *iter, char *key, char *value) {
+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);
@@ -258,8 +249,7 @@ encode_dict_string_variant_string(DBusMessageIter *iter, char *key, char *value)
     dbus_message_iter_close_container(iter, &dict);
 }
 
-static int
-encode_attr(DBusMessageIter *iter1, struct attr *attr) {
+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);
@@ -306,8 +296,7 @@ encode_attr(DBusMessageIter *iter1, struct attr *attr) {
 }
 
 
-static DBusHandlerResult
-empty_reply(DBusConnection *connection, DBusMessage *message) {
+static DBusHandlerResult empty_reply(DBusConnection *connection, DBusMessage *message) {
     DBusMessage *reply;
 
     reply = dbus_message_new_method_return(message);
@@ -318,8 +307,7 @@ empty_reply(DBusConnection *connection, DBusMessage *message) {
 }
 
 
-static DBusHandlerResult
-dbus_error(DBusConnection *connection, DBusMessage *message, char *error, char *msg) {
+static DBusHandlerResult dbus_error(DBusConnection *connection, DBusMessage *message, char *error, char *msg) {
     DBusMessage *reply;
 
     reply = dbus_message_new_error(message, error, msg);
@@ -328,40 +316,33 @@ dbus_error(DBusConnection *connection, DBusMessage *message, char *error, char *
     return DBUS_HANDLER_RESULT_HANDLED;
 }
 
-static DBusHandlerResult
-dbus_error_invalid_attr_type(DBusConnection *connection, DBusMessage *message) {
+static DBusHandlerResult 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) {
+static DBusHandlerResult 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) {
+static DBusHandlerResult 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) {
+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");
 }
 
-static DBusHandlerResult
-dbus_error_navigation_not_configured(DBusConnection *connection, DBusMessage *message) {
+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?)");
 }
 
-static DBusHandlerResult
-dbus_error_traffic_not_configured(DBusConnection *connection, DBusMessage *message) {
+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?)");
 }
 
-static DBusHandlerResult
-dbus_error_no_data_available(DBusConnection *connection, DBusMessage *message) {
+static DBusHandlerResult dbus_error_no_data_available(DBusConnection *connection, DBusMessage *message) {
 #if 1
     return dbus_error(connection, message, DBUS_ERROR_FILE_NOT_FOUND, "no data available");
 #else
@@ -370,8 +351,7 @@ dbus_error_no_data_available(DBusConnection *connection, DBusMessage *message) {
 }
 
 #if 0
-static void
-dbus_dump_iter(char *prefix, DBusMessageIter *iter) {
+static void dbus_dump_iter(char *prefix, DBusMessageIter *iter) {
     char *prefixr,*vals;
     int arg,vali;
     DBusMessageIter iterr;
@@ -420,8 +400,7 @@ dbus_dump_iter(char *prefix, DBusMessageIter *iter) {
     }
 }
 
-static void
-dbus_dump(DBusMessage *message) {
+static void dbus_dump(DBusMessage *message) {
     DBusMessageIter iter;
 
     dbus_message_iter_init(message, &iter);
@@ -438,8 +417,7 @@ dbus_dump(DBusMessage *message) {
  * @param pc Pointer where the data should get stored
  * @returns Returns 1 when everything went right, otherwise 0
  */
-static int
-pcoord_get_from_message(DBusMessage *message, DBusMessageIter *iter, struct pcoord *pc) {
+static int pcoord_get_from_message(DBusMessage *message, DBusMessageIter *iter, struct pcoord *pc) {
 
     if(!strcmp(dbus_message_iter_get_signature(iter), "s")) {
         char *coordstring;
@@ -483,8 +461,7 @@ pcoord_get_from_message(DBusMessage *message, DBusMessageIter *iter, struct pcoo
 
 }
 
-static void
-pcoord_encode(DBusMessageIter *iter, struct pcoord *pc) {
+static void pcoord_encode(DBusMessageIter *iter, struct pcoord *pc) {
     DBusMessageIter iter2;
     dbus_message_iter_open_container(iter,DBUS_TYPE_STRUCT,NULL,&iter2);
     if (pc) {
@@ -500,8 +477,7 @@ pcoord_encode(DBusMessageIter *iter, struct pcoord *pc) {
     dbus_message_iter_close_container(iter, &iter2);
 }
 
-static enum attr_type
-decode_attr_type_from_iter(DBusMessageIter *iter) {
+static enum attr_type decode_attr_type_from_iter(DBusMessageIter *iter) {
     char *attr_type;
     enum attr_type ret;
 
@@ -514,8 +490,7 @@ decode_attr_type_from_iter(DBusMessageIter *iter) {
     return ret;
 }
 
-static int
-decode_attr_from_iter(DBusMessageIter *iter, struct attr *attr) {
+static int decode_attr_from_iter(DBusMessageIter *iter, struct attr *attr) {
     DBusMessageIter iterattr, iterstruct;
     int ret=1;
     double d;
@@ -635,28 +610,25 @@ decode_attr_from_iter(DBusMessageIter *iter, struct attr *attr) {
     return 0;
 }
 
-static int
-decode_attr(DBusMessage *message, struct attr *attr) {
+static int decode_attr(DBusMessage *message, struct attr *attr) {
     DBusMessageIter iter;
 
     dbus_message_iter_init(message, &iter);
     return decode_attr_from_iter(&iter, attr);
 }
 
-static void
-destroy_attr(struct attr *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);
     }
 }
 
-static char *
-get_iter_name(char *type) {
+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)) {
+static DBusHandlerResult request_attr_iter(DBusConnection *connection, DBusMessage *message, char *type,
+        struct attr_iter *(*func)(void)) {
     DBusMessage *reply;
     char *iter_name;
     char *opath;
@@ -674,9 +646,8 @@ request_attr_iter(DBusConnection *connection, DBusMessage *message, char *type,
     return DBUS_HANDLER_RESULT_HANDLED;
 }
 
-static DBusHandlerResult
-request_attr_iter_destroy(DBusConnection *connection, DBusMessage *message, char *type,
-                          void (*func)(struct attr_iter *)) {
+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;
@@ -693,8 +664,8 @@ request_attr_iter_destroy(DBusConnection *connection, DBusMessage *message, char
     return empty_reply(connection, message);
 }
 
-static DBusHandlerResult
-request_destroy(DBusConnection *connection, DBusMessage *message, char *type, void *data, void (*func)(void *)) {
+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)
@@ -706,8 +677,8 @@ request_destroy(DBusConnection *connection, DBusMessage *message, char *type, vo
 }
 
 
-static DBusHandlerResult
-request_dup(DBusConnection *connection, DBusMessage *message, char *type, void *data, void *(*func)(void *)) {
+static DBusHandlerResult request_dup(DBusConnection *connection, DBusMessage *message, char *type, void *data,
+                                     void *(*func)(void *)) {
     DBusMessage *reply;
     char *opath;
     void *obj;
@@ -726,9 +697,8 @@ request_dup(DBusConnection *connection, DBusMessage *message, char *type, void *
 }
 
 
-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)) {
+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;
@@ -761,9 +731,8 @@ request_get_attr(DBusConnection *connection, DBusMessage *message, char *type, v
 
 }
 
-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)) {
+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;
@@ -786,9 +755,8 @@ request_command(DBusConnection *connection, DBusMessage *message, char *type, vo
 
 }
 
-static DBusHandlerResult
-request_set_add_remove_attr(DBusConnection *connection, DBusMessage *message, char *type, void *data,
-                            int (*func)(void *data, struct attr *attr)) {
+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;
 
@@ -812,8 +780,7 @@ request_set_add_remove_attr(DBusConnection *connection, DBusMessage *message, ch
 /* callback */
 
 
-static void
-dbus_callback_emit_signal(struct dbus_callback *dbus_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) {
@@ -823,20 +790,17 @@ dbus_callback_emit_signal(struct dbus_callback *dbus_callback) {
     }
 }
 
-static void
-request_callback_destroy_do(struct dbus_callback *data) {
+static void 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) {
+static DBusHandlerResult 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) {
+static DBusHandlerResult request_callback_new(DBusConnection *connection, DBusMessage *message) {
     DBusMessageIter iter;
     DBusMessage *reply;
     struct dbus_callback *callback;
@@ -865,19 +829,16 @@ request_callback_new(DBusConnection *connection, DBusMessage *message) {
 }
 
 /* config */
-static DBusHandlerResult
-request_config_get_attr(DBusConnection *connection, DBusMessage *message) {
+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);
 }
 
-static DBusHandlerResult
-request_config_attr_iter(DBusConnection *connection, DBusMessage *message) {
+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);
 }
 
-static DBusHandlerResult
-request_config_attr_iter_destroy(DBusConnection *connection, DBusMessage *message) {
+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);
 }
 
@@ -885,8 +846,7 @@ request_config_attr_iter_destroy(DBusConnection *connection, DBusMessage *messag
 
 /* graphics */
 
-static DBusHandlerResult
-request_graphics_get_data(DBusConnection *connection, DBusMessage *message) {
+static DBusHandlerResult request_graphics_get_data(DBusConnection *connection, DBusMessage *message) {
     struct graphics *graphics;
     char *data;
     struct graphics_data_image *image;
@@ -919,30 +879,26 @@ request_graphics_get_data(DBusConnection *connection, DBusMessage *message) {
 
 /* gui */
 
-static DBusHandlerResult
-request_gui_get_attr(DBusConnection *connection, DBusMessage *message) {
+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);
 }
 
-static DBusHandlerResult
-request_gui_command(DBusConnection *connection, DBusMessage *message) {
+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);
 }
 
 
 
-static DBusHandlerResult
-request_graphics_set_attr(DBusConnection *connection, DBusMessage *message) {
+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);
 }
 
 /* layout */
 
-static DBusHandlerResult
-request_layout_get_attr(DBusConnection *connection, DBusMessage *message) {
+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);
 }
@@ -951,20 +907,17 @@ request_layout_get_attr(DBusConnection *connection, DBusMessage *message) {
 
 /* map */
 
-static DBusHandlerResult
-request_map_get_attr(DBusConnection *connection, DBusMessage *message) {
+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);
 }
 
 
-static DBusHandlerResult
-request_map_set_attr(DBusConnection *connection, DBusMessage *message) {
+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);
 }
 
-static DBusHandlerResult
-request_map_dump(DBusConnection *connection, DBusMessage *message) {
+static DBusHandlerResult request_map_dump(DBusConnection *connection, DBusMessage *message) {
     DBusMessageIter iter;
     struct map *map;
 
@@ -989,110 +942,93 @@ request_map_dump(DBusConnection *connection, DBusMessage *message) {
 
 /* mapset */
 
-static DBusHandlerResult
-request_mapset_attr_iter(DBusConnection *connection, DBusMessage *message) {
+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);
 }
 
-static DBusHandlerResult
-request_mapset_attr_iter_destroy(DBusConnection *connection, DBusMessage *message) {
+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);
 }
 
-static DBusHandlerResult
-request_mapset_get_attr(DBusConnection *connection, DBusMessage *message) {
+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);
 }
 
 /* navigation */
 
-static DBusHandlerResult
-request_navigation_get_attr(DBusConnection *connection, DBusMessage *message) {
+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);
 }
 
 /* osd */
 
-static DBusHandlerResult
-request_osd_get_attr(DBusConnection *connection, DBusMessage *message) {
+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);
 }
 
 
-static DBusHandlerResult
-request_osd_set_attr(DBusConnection *connection, DBusMessage *message) {
+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);
 }
 
 /* roadprofile */
 
-static DBusHandlerResult
-request_roadprofile_get_attr(DBusConnection *connection, DBusMessage *message) {
+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);
 }
 
 
-static DBusHandlerResult
-request_roadprofile_set_attr(DBusConnection *connection, DBusMessage *message) {
+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);
 }
 
-static DBusHandlerResult
-request_roadprofile_attr_iter(DBusConnection *connection, DBusMessage *message) {
+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);
 }
 
-static DBusHandlerResult
-request_roadprofile_attr_iter_destroy(DBusConnection *connection, DBusMessage *message) {
+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);
 }
 
 /* route */
 
-static DBusHandlerResult
-request_route_get_attr(DBusConnection *connection, DBusMessage *message) {
+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);
 }
 
 
-static DBusHandlerResult
-request_route_set_attr(DBusConnection *connection, DBusMessage *message) {
+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);
 }
 
-static DBusHandlerResult
-request_route_add_attr(DBusConnection *connection, DBusMessage *message) {
+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);
 }
 
-static DBusHandlerResult
-request_route_remove_attr(DBusConnection *connection, DBusMessage *message) {
+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);
 }
 
-static DBusHandlerResult
-request_route_destroy(DBusConnection *connection, DBusMessage *message) {
+static DBusHandlerResult 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) {
+static DBusHandlerResult 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) {
+static DBusHandlerResult request_navit_draw(DBusConnection *connection, DBusMessage *message) {
     struct navit *navit;
 
     navit=object_get_from_message(message, "navit");
@@ -1113,8 +1049,7 @@ request_navit_draw(DBusConnection *connection, DBusMessage *message) {
  * @param p Pointer where the data should get stored
  * @returns Returns 1 when everything went right, otherwise 0
  */
-static int
-point_get_from_message(DBusMessage *message, DBusMessageIter *iter, struct point *p) {
+static int point_get_from_message(DBusMessage *message, DBusMessageIter *iter, struct point *p) {
     DBusMessageIter iter2;
 
     dbg(lvl_debug,"%s", dbus_message_iter_get_signature(iter));
@@ -1148,8 +1083,7 @@ point_get_from_message(DBusMessage *message, DBusMessageIter *iter, struct point
  * @returns An empty reply if everything went right, otherwise DBUS_HANDLER_RESULT_NOT_YET_HANDLED
  */
 
-static DBusHandlerResult
-request_navit_add_message(DBusConnection *connection, DBusMessage *message) {
+static DBusHandlerResult request_navit_add_message(DBusConnection *connection, DBusMessage *message) {
     struct navit *navit;
     char *usermessage;
 
@@ -1175,8 +1109,7 @@ request_navit_add_message(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(DBusConnection *connection, DBusMessage *message) {
+static DBusHandlerResult request_navit_set_center(DBusConnection *connection, DBusMessage *message) {
     struct pcoord pc;
     struct navit *navit;
     DBusMessageIter iter;
@@ -1200,8 +1133,7 @@ request_navit_set_center(DBusConnection *connection, DBusMessage *message) {
  * @param message The DBusMessage containing the x and y value
  * @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) {
+static DBusHandlerResult request_navit_set_center_screen(DBusConnection *connection, DBusMessage *message) {
     struct point p;
     struct navit *navit;
     DBusMessageIter iter;
@@ -1224,8 +1156,7 @@ request_navit_set_center_screen(DBusConnection *connection, DBusMessage *message
  * @param message The DBusMessage containing the name of the layout
  * @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) {
+static DBusHandlerResult request_navit_set_layout(DBusConnection *connection, DBusMessage *message) {
     char *new_layout_name;
     struct navit *navit;
     struct attr attr;
@@ -1253,8 +1184,7 @@ request_navit_set_layout(DBusConnection *connection, DBusMessage *message) {
  * @param message The DBusMessage
  * @returns An empty reply if everything went right, otherwise DBUS_HANDLER_RESULT_NOT_YET_HANDLED
  */
-static DBusHandlerResult
-request_navit_quit(DBusConnection *connection, DBusMessage *message) {
+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;
@@ -1318,8 +1248,7 @@ request_navit_traffic_inject(DBusConnection *connection, DBusMessage *message) {
     return empty_reply(connection, message);
 }
 
-static DBusHandlerResult
-request_navit_zoom(DBusConnection *connection, DBusMessage *message) {
+static DBusHandlerResult request_navit_zoom(DBusConnection *connection, DBusMessage *message) {
     int factor;
     struct point p, *pp=NULL;
     struct navit *navit;
@@ -1350,8 +1279,7 @@ request_navit_zoom(DBusConnection *connection, DBusMessage *message) {
 
 }
 
-static DBusHandlerResult
-request_navit_zoom_to_route(DBusConnection *connection, DBusMessage *message) {
+static DBusHandlerResult request_navit_zoom_to_route(DBusConnection *connection, DBusMessage *message) {
     struct navit *navit;
     DBusMessageIter iter;
 
@@ -1375,8 +1303,7 @@ request_navit_zoom_to_route(DBusConnection *connection, DBusMessage *message) {
  * @param message The DBusMessage including the `filename` parameter
  * @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) {
+static DBusHandlerResult request_navit_route_export_gpx(DBusConnection *connection, DBusMessage *message) {
     char * filename;
     struct navit *navit;
     DBusMessageIter iter;
@@ -1443,8 +1370,7 @@ request_navit_route_export_gpx(DBusConnection *connection, DBusMessage *message)
  * @param message The DBusMessage including the 'filename' parameter
  * @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) {
+static DBusHandlerResult request_navit_route_export_geojson(DBusConnection *connection, DBusMessage *message) {
     char * filename;
     struct point p;
     struct navit *navit;
@@ -1526,8 +1452,7 @@ request_navit_route_export_geojson(DBusConnection *connection, DBusMessage *mess
     return empty_reply(connection, message);
 }
 
-static DBusHandlerResult
-request_navit_block(DBusConnection *connection, DBusMessage *message) {
+static DBusHandlerResult request_navit_block(DBusConnection *connection, DBusMessage *message) {
     int mode;
     struct navit *navit;
     DBusMessageIter iter;
@@ -1545,8 +1470,7 @@ request_navit_block(DBusConnection *connection, DBusMessage *message) {
 
 }
 
-static DBusHandlerResult
-request_navit_resize(DBusConnection *connection, DBusMessage *message) {
+static DBusHandlerResult request_navit_resize(DBusConnection *connection, DBusMessage *message) {
     struct navit *navit;
     int w, h;
     DBusMessageIter iter;
@@ -1576,14 +1500,12 @@ request_navit_resize(DBusConnection *connection, DBusMessage *message) {
 
 }
 
-static DBusHandlerResult
-request_navit_get_attr(DBusConnection *connection, DBusMessage *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);
 }
 
-static DBusHandlerResult
-request_navit_attr_iter(DBusConnection *connection, DBusMessage *message) {
+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);
@@ -1595,8 +1517,7 @@ request_navit_attr_iter(DBusConnection *connection, DBusMessage *message) {
     return DBUS_HANDLER_RESULT_HANDLED;
 }
 
-static DBusHandlerResult
-request_navit_attr_iter_destroy(DBusConnection *connection, DBusMessage *message) {
+static DBusHandlerResult request_navit_attr_iter_destroy(DBusConnection *connection, DBusMessage *message) {
     struct attr_iter *attr_iter;
     DBusMessageIter iter;
 
@@ -1610,24 +1531,20 @@ request_navit_attr_iter_destroy(DBusConnection *connection, DBusMessage *message
 }
 
 
-static DBusHandlerResult
-request_navit_set_attr(DBusConnection *connection, DBusMessage *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);
 }
 
-static DBusHandlerResult
-request_navit_add_attr(DBusConnection *connection, DBusMessage *message) {
+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);
 }
 
-static DBusHandlerResult
-request_navit_remove_attr(DBusConnection *connection, DBusMessage *message) {
+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);
 }
 
-static DBusHandlerResult
-request_navit_set_position(DBusConnection *connection, DBusMessage *message) {
+static DBusHandlerResult request_navit_set_position(DBusConnection *connection, DBusMessage *message) {
     struct pcoord pc;
     struct navit *navit;
     DBusMessageIter iter;
@@ -1644,8 +1561,7 @@ request_navit_set_position(DBusConnection *connection, DBusMessage *message) {
     return empty_reply(connection, message);
 }
 
-static DBusHandlerResult
-request_navit_set_destination(DBusConnection *connection, DBusMessage *message) {
+static DBusHandlerResult request_navit_set_destination(DBusConnection *connection, DBusMessage *message) {
     struct pcoord pc;
     struct navit *navit;
     DBusMessageIter iter;
@@ -1667,8 +1583,7 @@ request_navit_set_destination(DBusConnection *connection, DBusMessage *message)
     return empty_reply(connection, message);
 }
 
-static DBusHandlerResult
-request_navit_clear_destination(DBusConnection *connection, DBusMessage *message) {
+static DBusHandlerResult request_navit_clear_destination(DBusConnection *connection, DBusMessage *message) {
     struct navit *navit;
 
     navit = object_get_from_message(message, "navit");
@@ -1678,8 +1593,7 @@ request_navit_clear_destination(DBusConnection *connection, DBusMessage *message
     return empty_reply(connection, message);
 }
 
-static DBusHandlerResult
-request_navit_evaluate(DBusConnection *connection, DBusMessage *message) {
+static DBusHandlerResult request_navit_evaluate(DBusConnection *connection, DBusMessage *message) {
     struct navit *navit;
     char *command;
     char *result;
@@ -1708,21 +1622,18 @@ request_navit_evaluate(DBusConnection *connection, DBusMessage *message) {
 
 /* search_list */
 
-static DBusHandlerResult
-request_search_list_destroy(DBusConnection *connection, DBusMessage *message) {
+static DBusHandlerResult 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) {
+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) {
+static DBusHandlerResult request_search_list_get_result(DBusConnection *connection, DBusMessage *message) {
     struct search_list *search_list;
     struct search_list_result *result;
     DBusMessage *reply;
@@ -1796,8 +1707,7 @@ request_search_list_get_result(DBusConnection *connection, DBusMessage *message)
     return DBUS_HANDLER_RESULT_HANDLED;
 }
 
-static DBusHandlerResult
-request_search_list_new(DBusConnection *connection, DBusMessage *message) {
+static DBusHandlerResult request_search_list_new(DBusConnection *connection, DBusMessage *message) {
     DBusMessageIter iter;
     DBusMessage *reply;
     struct mapset *mapset;
@@ -1817,8 +1727,7 @@ request_search_list_new(DBusConnection *connection, DBusMessage *message) {
     return DBUS_HANDLER_RESULT_HANDLED;
 }
 
-static DBusHandlerResult
-request_search_list_search(DBusConnection *connection, DBusMessage *message) {
+static DBusHandlerResult request_search_list_search(DBusConnection *connection, DBusMessage *message) {
     DBusMessageIter iter;
     struct search_list *search_list;
     struct attr attr;
@@ -1838,8 +1747,7 @@ request_search_list_search(DBusConnection *connection, DBusMessage *message) {
     return empty_reply(connection, message);
 }
 
-static DBusHandlerResult
-request_search_list_select(DBusConnection *connection, DBusMessage *message) {
+static DBusHandlerResult request_search_list_select(DBusConnection *connection, DBusMessage *message) {
     DBusMessageIter iter;
     struct search_list *search_list;
     int id, mode;
@@ -1865,8 +1773,7 @@ request_search_list_select(DBusConnection *connection, DBusMessage *message) {
 
 /* tracking */
 
-static DBusHandlerResult
-request_tracking_get_attr(DBusConnection *connection, DBusMessage *message) {
+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);
 }
@@ -1875,8 +1782,7 @@ request_tracking_get_attr(DBusConnection *connection, DBusMessage *message) {
 
 /* vehicle */
 
-static DBusHandlerResult
-request_vehicle_set_attr(DBusConnection *connection, DBusMessage *message) {
+static DBusHandlerResult request_vehicle_set_attr(DBusConnection *connection, DBusMessage *message) {
     struct vehicle *vehicle;
     struct attr attr;
     int ret;
@@ -1895,27 +1801,23 @@ request_vehicle_set_attr(DBusConnection *connection, DBusMessage *message) {
 
 /* vehicleprofile */
 
-static DBusHandlerResult
-request_vehicleprofile_get_attr(DBusConnection *connection, DBusMessage *message) {
+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);
 }
 
 
-static DBusHandlerResult
-request_vehicleprofile_set_attr(DBusConnection *connection, DBusMessage *message) {
+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);
 }
 
-static DBusHandlerResult
-request_vehicleprofile_attr_iter(DBusConnection *connection, DBusMessage *message) {
+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);
 }
 
-static DBusHandlerResult
-request_vehicleprofile_attr_iter_destroy(DBusConnection *connection, DBusMessage *message) {
+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);
 }
@@ -2010,8 +1912,7 @@ struct dbus_method {
     {".vehicleprofile","attr_iter_destroy","o",   "attr_iter",                               "",   "",      request_vehicleprofile_attr_iter_destroy},
 };
 
-static char *
-introspect_path(const char *object) {
+static char *introspect_path(const char *object) {
     char *ret;
     int i;
     char *def=".default_";
@@ -2039,8 +1940,7 @@ introspect_path(const char *object) {
     return ret;
 }
 
-static char *
-generate_navitintrospectxml(const char *object) {
+static char *generate_navitintrospectxml(const char *object) {
     int i,methods_size,n=0;
     char *navitintrospectxml;
     char *path=introspect_path(object);
@@ -2087,8 +1987,7 @@ generate_navitintrospectxml(const char *object) {
     return navitintrospectxml;
 }
 
-static DBusHandlerResult
-navit_handler_func(DBusConnection *connection, DBusMessage *message, void *user_data) {
+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",
@@ -2128,8 +2027,7 @@ static DBusObjectPathVTable dbus_navit_vtable = {
 };
 
 #if 0
-DBusHandlerResult
-filter(DBusConnection *connection, DBusMessage *message, void *user_data) {
+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));
@@ -2139,8 +2037,7 @@ filter(DBusConnection *connection, DBusMessage *message, void *user_data) {
 }
 #endif
 
-static int
-dbus_cmd_send_signal(struct navit *navit, char *command, struct attr **in, struct attr ***out) {
+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");
@@ -2173,8 +2070,7 @@ static struct command_table commands[] = {
 };
 
 
-static void
-dbus_main_navit(struct navit *navit, int added) {
+static void dbus_main_navit(struct navit *navit, int added) {
     struct attr attr;
     if (added==1) {
         DBusMessage* msg;
diff --git a/navit/binding/dbus/eval.py b/navit/binding/dbus/eval.py
index a2e1926fd..ecb1d9583 100755
--- a/navit/binding/dbus/eval.py
+++ b/navit/binding/dbus/eval.py
@@ -4,9 +4,9 @@ import sys
 bus = dbus.SessionBus()
 conn = bus.get_object('org.navit_project.navit',
                        '/org/navit_project/navit')
-iface = dbus.Interface(conn, dbus_interface='org.navit_project.navit');
-iter=iface.attr_iter();
-navit=bus.get_object('org.navit_project.navit', conn.get_attr_wi('navit',iter)[1]);
-iface.attr_iter_destroy(iter);
-navit_iface = dbus.Interface(navit, dbus_interface='org.navit_project.navit.navit');
-print navit_iface.evaluate(sys.argv[1]);
+iface = dbus.Interface(conn, dbus_interface='org.navit_project.navit')
+_iter=iface.attr_iter()
+navit=bus.get_object('org.navit_project.navit', conn.get_attr_wi('navit',_iter)[1])
+iface.attr_iter_destroy(_iter)
+navit_iface = dbus.Interface(navit, dbus_interface='org.navit_project.navit.navit')
+print navit_iface.evaluate(sys.argv[1])
diff --git a/navit/binding/dbus/test.py b/navit/binding/dbus/test.py
index 740f000e6..98a04b5a6 100755
--- a/navit/binding/dbus/test.py
+++ b/navit/binding/dbus/test.py
@@ -3,9 +3,9 @@ import dbus
 bus = dbus.SessionBus()
 conn = bus.get_object('org.navit_project.navit',
                        '/org/navit_project/navit')
-iface = dbus.Interface(conn, dbus_interface='org.navit_project.navit');
-iter=iface.attr_iter();
-navit=bus.get_object('org.navit_project.navit', conn.get_attr_wi("navit",iter)[1]);
-iface.attr_iter_destroy(iter);
-navit_iface = dbus.Interface(navit, dbus_interface='org.navit_project.navit.navit');
-navit_iface.set_center((1,0x138a4a,0x5d773f));
+iface = dbus.Interface(conn, dbus_interface='org.navit_project.navit')
+_iter=iface.attr_iter()
+navit=bus.get_object('org.navit_project.navit', conn.get_attr_wi("navit",_iter)[1])
+iface.attr_iter_destroy(_iter)
+navit_iface = dbus.Interface(navit, dbus_interface='org.navit_project.navit.navit')
+navit_iface.set_center((1,0x138a4a,0x5d773f))
diff --git a/navit/binding/python/attr.c b/navit/binding/python/attr.c
index e9365c3d3..f9ba18d47 100644
--- a/navit/binding/python/attr.c
+++ b/navit/binding/python/attr.c
@@ -27,8 +27,7 @@ typedef struct {
     struct attr *attr;
 } attrObject;
 
-static PyObject *
-attr_func(attrObject *self, PyObject *args) {
+static PyObject *attr_func(attrObject *self, PyObject *args) {
     const char *file;
     int ret;
     if (!PyArg_ParseTuple(args, "s", &file))
@@ -45,13 +44,11 @@ static PyMethodDef attr_methods[] = {
 };
 
 
-static PyObject *
-attr_getattr_py(PyObject *self, char *name) {
+static PyObject *attr_getattr_py(PyObject *self, char *name) {
     return Py_FindMethod(attr_methods, self, name);
 }
 
-static void
-attr_destroy_py(attrObject *self) {
+static void attr_destroy_py(attrObject *self) {
     if (! self->ref)
         attr_free(self->attr);
 }
@@ -69,8 +66,7 @@ attr_py_get(PyObject *self) {
     return ((attrObject *)self)->attr;
 }
 
-PyObject *
-attr_new_py(PyObject *self, PyObject *args) {
+PyObject *attr_new_py(PyObject *self, PyObject *args) {
     attrObject *ret;
     const char *name,*value;
     if (!PyArg_ParseTuple(args, "ss", &name, &value))
@@ -81,8 +77,7 @@ attr_new_py(PyObject *self, PyObject *args) {
     return (PyObject *)ret;
 }
 
-PyObject *
-attr_new_py_ref(struct attr *attr) {
+PyObject *attr_new_py_ref(struct attr *attr) {
     attrObject *ret;
 
     ret=PyObject_NEW(attrObject, &attr_Type);
diff --git a/navit/binding/python/binding_python.c b/navit/binding/python/binding_python.c
index df90371cf..6a3fe5197 100644
--- a/navit/binding/python/binding_python.c
+++ b/navit/binding/python/binding_python.c
@@ -79,8 +79,7 @@ PyTypeObject map_Type = {
 
 /* *** coord *** */
 
-static PyObject *
-coord_new_py(PyObject *self, PyObject *args) {
+static PyObject *coord_new_py(PyObject *self, PyObject *args) {
     coordObject *ret;
     int x,y;
     if (!PyArg_ParseTuple(args, "ii:navit.coord",&x,&y))
@@ -90,8 +89,7 @@ coord_new_py(PyObject *self, PyObject *args) {
     return (PyObject *)ret;
 }
 
-static void
-coord_destroy_py(coordObject *self) {
+static void coord_destroy_py(coordObject *self) {
     coord_destroy(self->c);
 }
 
@@ -116,8 +114,7 @@ PyTypeObject coord_rect_Type = {
     .tp_dealloc=(destructor)coord_rect_destroy_py,
 };
 
-static PyObject *
-coord_rect_new_py(PyObject *self, PyObject *args) {
+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))
@@ -127,8 +124,7 @@ coord_rect_new_py(PyObject *self, PyObject *args) {
     return (PyObject *)ret;
 }
 
-static void
-coord_rect_destroy_py(coord_rectObject *self) {
+static void coord_rect_destroy_py(coord_rectObject *self) {
     coord_rect_destroy(self->r);
 }
 
@@ -153,8 +149,7 @@ PyTypeObject map_rect_Type = {
     .tp_dealloc=(destructor)map_rect_destroy_py,
 };
 
-static PyObject *
-map_rect_new_py(mapObject *self, PyObject *args) {
+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))
@@ -164,16 +159,14 @@ map_rect_new_py(mapObject *self, PyObject *args) {
     return (PyObject *)ret;
 }
 
-static void
-map_rect_destroy_py(map_rectObject *self) {
+static void map_rect_destroy_py(map_rectObject *self) {
     map_rect_destroy(self->mr);
 }
 
 
 /* *** map *** */
 
-static PyObject *
-map_dump_file_py(mapObject *self, PyObject *args) {
+static PyObject *map_dump_file_py(mapObject *self, PyObject *args) {
     const char *s;
     if (!PyArg_ParseTuple(args, "s",&s))
         return NULL;
@@ -182,8 +175,7 @@ map_dump_file_py(mapObject *self, PyObject *args) {
 }
 
 
-static PyObject *
-map_set_attr_py(mapObject *self, PyObject *args) {
+static PyObject *map_set_attr_py(mapObject *self, PyObject *args) {
     PyObject *attr;
     if (!PyArg_ParseTuple(args, "O!", &attr_Type, &attr))
         return NULL;
@@ -200,14 +192,12 @@ static PyMethodDef map_methods[] = {
     {NULL, NULL },
 };
 
-static PyObject *
-map_getattr_py(PyObject *self, char *name) {
+static PyObject *map_getattr_py(PyObject *self, char *name) {
     return Py_FindMethod(map_methods, self, name);
 }
 
 
-static PyObject *
-map_new_py(PyObject *self, PyObject *args) {
+static PyObject *map_new_py(PyObject *self, PyObject *args) {
     mapObject *ret;
     char *type, *filename;
 
@@ -219,8 +209,7 @@ map_new_py(PyObject *self, PyObject *args) {
     return (PyObject *)ret;
 }
 
-PyObject *
-map_py_ref(struct map *map) {
+PyObject *map_py_ref(struct map *map) {
     mapObject *ret;
     ret=PyObject_NEW(mapObject, &map_Type);
     ret->m=map;
@@ -228,8 +217,7 @@ map_py_ref(struct map *map) {
     return (PyObject *)ret;
 }
 
-static void
-map_destroy_py(mapObject *self) {
+static void map_destroy_py(mapObject *self) {
     if (!self->ref)
         map_destroy(self->m);
 }
@@ -258,8 +246,7 @@ PyTypeObject mapset_Type = {
     .tp_getattr=mapset_getattr_py,
 };
 
-static PyObject *
-mapset_add_py(mapsetObject *self, PyObject *args) {
+static PyObject *mapset_add_py(mapsetObject *self, PyObject *args) {
     mapObject *map;
     if (!PyArg_ParseTuple(args, "O:navit.mapset", &map))
         return NULL;
@@ -275,13 +262,11 @@ static PyMethodDef mapset_methods[] = {
     {NULL, NULL },
 };
 
-static PyObject *
-mapset_getattr_py(PyObject *self, char *name) {
+static PyObject *mapset_getattr_py(PyObject *self, char *name) {
     return Py_FindMethod(mapset_methods, self, name);
 }
 
-static PyObject *
-mapset_new_py(PyObject *self, PyObject *args) {
+static PyObject *mapset_new_py(PyObject *self, PyObject *args) {
     mapsetObject *ret;
     if (!PyArg_ParseTuple(args, ":navit.mapset"))
         return NULL;
@@ -290,13 +275,11 @@ mapset_new_py(PyObject *self, PyObject *args) {
     return (PyObject *)ret;
 }
 
-static void
-mapset_destroy_py(mapsetObject *self) {
+static void mapset_destroy_py(mapsetObject *self) {
     mapset_destroy(self->ms);
 }
 
-static PyObject *
-config_load_py(PyObject *self, PyObject *args) {
+static PyObject *config_load_py(PyObject *self, PyObject *args) {
     const char *file;
     int ret;
     xmlerror *error;
@@ -319,8 +302,7 @@ static PyMethodDef navitMethods[]= {
 };
 
 
-PyObject *
-python_object_from_attr(struct attr *attr) {
+PyObject *python_object_from_attr(struct attr *attr) {
     switch (attr->type) {
     case attr_navigation:
         return navigation_py_ref(attr->u.navigation);
@@ -333,8 +315,7 @@ python_object_from_attr(struct attr *attr) {
 }
 
 
-void
-plugin_init(void) {
+void plugin_init(void) {
     int fd,size;
     char buffer[65536];
 
diff --git a/navit/binding/python/config.c b/navit/binding/python/config.c
index d8d91ead7..5115844a8 100644
--- a/navit/binding/python/config.c
+++ b/navit/binding/python/config.c
@@ -25,8 +25,7 @@ typedef struct {
     PyObject_HEAD
 } configObject;
 
-static PyObject *
-config_navit(PyObject *self, PyObject *args) {
+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);
@@ -41,13 +40,11 @@ static PyMethodDef config_methods[] = {
 };
 
 
-static PyObject *
-config_getattr_py(PyObject *self, char *name) {
+static PyObject *config_getattr_py(PyObject *self, char *name) {
     return Py_FindMethod(config_methods, self, name);
 }
 
-static void
-config_destroy_py(configObject *self) {
+static void config_destroy_py(configObject *self) {
 }
 
 PyTypeObject config_Type = {
@@ -58,8 +55,7 @@ PyTypeObject config_Type = {
     .tp_getattr=config_getattr_py,
 };
 
-PyObject *
-config_py(PyObject *self, PyObject *args) {
+PyObject *config_py(PyObject *self, PyObject *args) {
     configObject *ret;
 
     dbg(lvl_debug,"enter");
diff --git a/navit/binding/python/navigation.c b/navit/binding/python/navigation.c
index 3e027cef3..b5030b731 100644
--- a/navit/binding/python/navigation.c
+++ b/navit/binding/python/navigation.c
@@ -25,8 +25,7 @@ typedef struct {
     struct navigation *navigation;
 } navigationObject;
 
-static PyObject *
-navigation_get_map_py(navigationObject *self, PyObject *args) {
+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));
@@ -40,13 +39,11 @@ static PyMethodDef navigation_methods[] = {
 };
 
 
-static PyObject *
-navigation_getattr_py(PyObject *self, char *name) {
+static PyObject *navigation_getattr_py(PyObject *self, char *name) {
     return Py_FindMethod(navigation_methods, self, name);
 }
 
-static void
-navigation_destroy_py(navigationObject *self) {
+static void navigation_destroy_py(navigationObject *self) {
 }
 
 PyTypeObject navigation_Type = {
@@ -57,16 +54,14 @@ PyTypeObject navigation_Type = {
     .tp_getattr=navigation_getattr_py,
 };
 
-PyObject *
-navigation_py(PyObject *self, PyObject *args) {
+PyObject *navigation_py(PyObject *self, PyObject *args) {
     navigationObject *ret;
 
     ret=PyObject_NEW(navigationObject, &navigation_Type);
     return (PyObject *)ret;
 }
 
-PyObject *
-navigation_py_ref(struct navigation *navigation) {
+PyObject *navigation_py_ref(struct navigation *navigation) {
     navigationObject *ret;
 
     ret=PyObject_NEW(navigationObject, &navigation_Type);
diff --git a/navit/binding/python/navit.c b/navit/binding/python/navit.c
index 6991e30d7..38248b74b 100644
--- a/navit/binding/python/navit.c
+++ b/navit/binding/python/navit.c
@@ -26,8 +26,7 @@ typedef struct {
     struct navit *navit;
 } navitObject;
 
-static PyObject *
-navit_set_attr_py(navitObject *self, PyObject *args) {
+static PyObject *navit_set_attr_py(navitObject *self, PyObject *args) {
     PyObject *attr;
     if (!PyArg_ParseTuple(args, "O!", &attr_Type, &attr))
         return NULL;
@@ -35,8 +34,7 @@ navit_set_attr_py(navitObject *self, PyObject *args) {
     Py_RETURN_NONE;
 }
 
-static PyObject *
-navit_get_attr_py(navitObject *self, PyObject *args) {
+static PyObject *navit_get_attr_py(navitObject *self, PyObject *args) {
     char *name;
     struct attr attr;
     if (!PyArg_ParseTuple(args, "s", &name))
@@ -49,8 +47,7 @@ navit_get_attr_py(navitObject *self, PyObject *args) {
     return python_object_from_attr(&attr);
 }
 
-static PyObject *
-navit_set_center_py(navitObject *self, PyObject *args) {
+static PyObject *navit_set_center_py(navitObject *self, PyObject *args) {
     PyObject *pcoord;
     if (!PyArg_ParseTuple(args, "O!", &pcoord_Type, &pcoord))
         return NULL;
@@ -58,8 +55,7 @@ navit_set_center_py(navitObject *self, PyObject *args) {
     Py_RETURN_NONE;
 }
 
-static PyObject *
-navit_set_destination_py(navitObject *self, PyObject *args) {
+static PyObject *navit_set_destination_py(navitObject *self, PyObject *args) {
     PyObject *pcoord;
     const char *description;
     int async;
@@ -69,8 +65,7 @@ navit_set_destination_py(navitObject *self, PyObject *args) {
     Py_RETURN_NONE;
 }
 
-static PyObject *
-navit_set_position_py(navitObject *self, PyObject *args) {
+static PyObject *navit_set_position_py(navitObject *self, PyObject *args) {
     PyObject *pcoord;
     if (!PyArg_ParseTuple(args, "O!", &pcoord_Type, &pcoord))
         return NULL;
@@ -79,8 +74,7 @@ navit_set_position_py(navitObject *self, PyObject *args) {
 }
 
 
-static PyObject *
-navit_zoom_to_route_py(navitObject *self, PyObject *args) {
+static PyObject *navit_zoom_to_route_py(navitObject *self, PyObject *args) {
     if (!PyArg_ParseTuple(args, ""))
         return NULL;
     navit_zoom_to_route(self->navit,0);
@@ -101,13 +95,11 @@ static PyMethodDef navit_methods[] = {
 };
 
 
-static PyObject *
-navit_getattr_py(PyObject *self, char *name) {
+static PyObject *navit_getattr_py(PyObject *self, char *name) {
     return Py_FindMethod(navit_methods, self, name);
 }
 
-static void
-navit_destroy_py(navitObject *self) {
+static void navit_destroy_py(navitObject *self) {
 }
 
 PyTypeObject navit_Type = {
@@ -118,8 +110,7 @@ PyTypeObject navit_Type = {
     .tp_getattr=navit_getattr_py,
 };
 
-PyObject *
-navit_py(PyObject *self, PyObject *args) {
+PyObject *navit_py(PyObject *self, PyObject *args) {
     navitObject *ret;
 
     dbg(lvl_debug,"enter");
@@ -127,8 +118,7 @@ navit_py(PyObject *self, PyObject *args) {
     return (PyObject *)ret;
 }
 
-PyObject *
-navit_py_ref(struct navit *navit) {
+PyObject *navit_py_ref(struct navit *navit) {
     dbg(lvl_debug,"navit=%p", navit);
     navitObject *ret=PyObject_NEW(navitObject, &navit_Type);
     ret->navit=navit;
diff --git a/navit/binding/python/pcoord.c b/navit/binding/python/pcoord.c
index e27c44a75..0c8d959fe 100644
--- a/navit/binding/python/pcoord.c
+++ b/navit/binding/python/pcoord.c
@@ -25,8 +25,7 @@ typedef struct {
     struct pcoord pc;
 } pcoordObject;
 
-static PyObject *
-pcoord_func(pcoordObject *self, PyObject *args) {
+static PyObject *pcoord_func(pcoordObject *self, PyObject *args) {
     const char *file;
     int ret=0;
     if (!PyArg_ParseTuple(args, "s", &file))
@@ -42,13 +41,11 @@ static PyMethodDef pcoord_methods[] = {
 };
 
 
-static PyObject *
-pcoord_getattr_py(PyObject *self, char *name) {
+static PyObject *pcoord_getattr_py(PyObject *self, char *name) {
     return Py_FindMethod(pcoord_methods, self, name);
 }
 
-static void
-pcoord_destroy_py(pcoordObject *self) {
+static void pcoord_destroy_py(pcoordObject *self) {
 }
 
 PyTypeObject pcoord_Type = {
@@ -59,8 +56,7 @@ PyTypeObject pcoord_Type = {
     .tp_getattr=pcoord_getattr_py,
 };
 
-PyObject *
-pcoord_py(PyObject *self, PyObject *args) {
+PyObject *pcoord_py(PyObject *self, PyObject *args) {
     pcoordObject *ret;
     const char *str;
     enum projection pro;
diff --git a/navit/binding/python/route.c b/navit/binding/python/route.c
index 8010b416f..3aaff8157 100644
--- a/navit/binding/python/route.c
+++ b/navit/binding/python/route.c
@@ -27,8 +27,7 @@ typedef struct {
     struct route *route;
 } routeObject;
 
-static PyObject *
-route_get_map_py(routeObject *self, PyObject *args) {
+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));
@@ -42,13 +41,11 @@ static PyMethodDef route_methods[] = {
 };
 
 
-static PyObject *
-route_getattr_py(PyObject *self, char *name) {
+static PyObject *route_getattr_py(PyObject *self, char *name) {
     return Py_FindMethod(route_methods, self, name);
 }
 
-static void
-route_destroy_py(routeObject *self) {
+static void route_destroy_py(routeObject *self) {
 }
 
 PyTypeObject route_Type = {
@@ -59,16 +56,14 @@ PyTypeObject route_Type = {
     .tp_getattr=route_getattr_py,
 };
 
-PyObject *
-route_py(PyObject *self, PyObject *args) {
+PyObject *route_py(PyObject *self, PyObject *args) {
     routeObject *ret;
 
     ret=PyObject_NEW(routeObject, &route_Type);
     return (PyObject *)ret;
 }
 
-PyObject *
-route_py_ref(struct route *route) {
+PyObject *route_py_ref(struct route *route) {
     routeObject *ret;
 
     ret=PyObject_NEW(routeObject, &route_Type);
diff --git a/navit/binding/python/startup.py b/navit/binding/python/startup.py
index f8e801551..272a78a2f 100644
--- a/navit/binding/python/startup.py
+++ b/navit/binding/python/startup.py
@@ -1,8 +1,8 @@
 import navit
 navit.config_load("navit.xml.local")
-pos=navit.pcoord("5023.7493 N 00730.2898 E",1);
-dest=navit.pcoord("5023.6604 N 00729.8500 E",1);
-inst=navit.config().navit();
-inst.set_position(pos);
-inst.set_destination(dest,"Test");
-inst.set_center(pos);
+pos=navit.pcoord("5023.7493 N 00730.2898 E",1)
+dest=navit.pcoord("5023.6604 N 00729.8500 E",1)
+inst=navit.config().navit()
+inst.set_position(pos)
+inst.set_destination(dest,"Test")
+inst.set_center(pos)
diff --git a/navit/binding/python/template.c b/navit/binding/python/template.c
index 2019173a3..69a3e7265 100644
--- a/navit/binding/python/template.c
+++ b/navit/binding/python/template.c
@@ -26,8 +26,7 @@ typedef struct {
     struct template *template;
 } templateObject;
 
-static PyObject *
-template_func(templateObject *self, PyObject *args) {
+static PyObject *template_func(templateObject *self, PyObject *args) {
     const char *file;
     int ret;
     if (!PyArg_ParseTuple(args, "s", &file))
@@ -44,13 +43,11 @@ static PyMethodDef template_methods[] = {
 };
 
 
-static PyObject *
-template_getattr_py(PyObject *self, char *name) {
+static PyObject *template_getattr_py(PyObject *self, char *name) {
     return Py_FindMethod(template_methods, self, name);
 }
 
-static void
-template_destroy_py(templateObject *self) {
+static void template_destroy_py(templateObject *self) {
     if (! self->ref)
         template_destroy(self->template);
 }
@@ -68,8 +65,7 @@ template_py_get(PyObject *self) {
     return ((templateObject *)self)->template;
 }
 
-PyObject *
-template_new_py(PyObject *self, PyObject *args) {
+PyObject *template_new_py(PyObject *self, PyObject *args) {
     templateObject *ret;
 
     ret=PyObject_NEW(templateObject, &template_Type);
@@ -78,8 +74,7 @@ template_new_py(PyObject *self, PyObject *args) {
     return (PyObject *)ret;
 }
 
-PyObject *
-template_new_py_ref(struct template *template) {
+PyObject *template_new_py_ref(struct template *template) {
     templateObject *ret;
 
     ret=PyObject_NEW(templateObject, &template_Type);
diff --git a/navit/binding/win32/binding_win32.c b/navit/binding/win32/binding_win32.c
index c50bb959e..6ff0af9c0 100644
--- a/navit/binding/win32/binding_win32.c
+++ b/navit/binding/win32/binding_win32.c
@@ -57,8 +57,7 @@ struct win32_binding_private {
 /* TODO: do something meaningful here
  *
  */
-static int
-win32_cmd_send_signal(struct navit *navit, char *command, struct attr **in, struct attr ***out) {
+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) {
@@ -75,8 +74,7 @@ static struct command_table commands[] = {
 };
 
 
-static void
-win32_wm_copydata(struct win32_binding_private *this, int *hwndSender, COPYDATASTRUCT *cpd) {
+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;
@@ -104,8 +102,7 @@ win32_wm_copydata(struct win32_binding_private *this, int *hwndSender, COPYDATAS
     command_evaluate(&navit, msg->text);
 }
 
-static void
-win32_cb_graphics_ready(struct win32_binding_private *this, struct navit *navit) {
+static void win32_cb_graphics_ready(struct win32_binding_private *this, struct navit *navit) {
     struct graphics *gra;
     struct callback *gcb;
 
@@ -115,8 +112,7 @@ win32_cb_graphics_ready(struct win32_binding_private *this, struct navit *navit)
     graphics_add_callback(gra, gcb);
 }
 
-static void
-win32_main_navit(struct win32_binding_private *this, struct navit *navit, int added) {
+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) {