reindent with gnu indent. add keyboard accelerators for view menu, fix toggle filter widget also connected to toggle graph cb. add Lithuanian translation thanks to Algimantas Margevičius via launchpad.

1 files changed, 272 insertions, 203 deletions

diff --git a/src/trg-torrent-model.c b/src/trg-torrent-model.c
index 26a6698..c7408fe 100644
--- a/src/trg-torrent-model.c
+++ b/src/trg-torrent-model.c
@@ -73,7 +73,8 @@ struct _TrgTorrentModelPrivate {
     trg_torrent_model_update_stats stats;
 };
 
-static void trg_torrent_model_dispose(GObject * object) {
+static void trg_torrent_model_dispose(GObject * object)
+{
     TrgTorrentModelPrivate *priv = TRG_TORRENT_MODEL_GET_PRIVATE(object);
     g_hash_table_destroy(priv->ht);
     G_OBJECT_CLASS(trg_torrent_model_parent_class)->dispose(object);
@@ -81,49 +82,70 @@ static void trg_torrent_model_dispose(GObject * object) {
 
 static void
 update_torrent_iter(TrgTorrentModel * model, TrgClient * tc, gint64 rpcv,
-        gint64 serial, GtkTreeIter * iter, JsonObject * t,
-        trg_torrent_model_update_stats * stats, guint *whatsChanged);
+                    gint64 serial, GtkTreeIter * iter, JsonObject * t,
+                    trg_torrent_model_update_stats * stats,
+                    guint * whatsChanged);
 
-static void trg_torrent_model_class_init(TrgTorrentModelClass * klass) {
+static void trg_torrent_model_class_init(TrgTorrentModelClass * klass)
+{
     GObjectClass *object_class = G_OBJECT_CLASS(klass);
 
     g_type_class_add_private(klass, sizeof(TrgTorrentModelPrivate));
     object_class->dispose = trg_torrent_model_dispose;
 
     signals[TMODEL_TORRENT_COMPLETED] = g_signal_new("torrent-completed",
-            G_TYPE_FROM_CLASS
-            (object_class), G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
-            G_STRUCT_OFFSET
-            (TrgTorrentModelClass,
-                    torrent_completed), NULL, NULL,
-            g_cclosure_marshal_VOID__POINTER, G_TYPE_NONE, 1, G_TYPE_POINTER);
+                                                     G_TYPE_FROM_CLASS
+                                                     (object_class),
+                                                     G_SIGNAL_RUN_LAST |
+                                                     G_SIGNAL_ACTION,
+                                                     G_STRUCT_OFFSET
+                                                     (TrgTorrentModelClass,
+                                                      torrent_completed),
+                                                     NULL, NULL,
+                                                     g_cclosure_marshal_VOID__POINTER,
+                                                     G_TYPE_NONE, 1,
+                                                     G_TYPE_POINTER);
 
     signals[TMODEL_TORRENT_ADDED] = g_signal_new("torrent-added",
-            G_TYPE_FROM_CLASS
-            (object_class), G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
-            G_STRUCT_OFFSET
-            (TrgTorrentModelClass,
-                    torrent_added), NULL, NULL,
-            g_cclosure_marshal_VOID__POINTER, G_TYPE_NONE, 1, G_TYPE_POINTER);
+                                                 G_TYPE_FROM_CLASS
+                                                 (object_class),
+                                                 G_SIGNAL_RUN_LAST |
+                                                 G_SIGNAL_ACTION,
+                                                 G_STRUCT_OFFSET
+                                                 (TrgTorrentModelClass,
+                                                  torrent_added), NULL,
+                                                 NULL,
+                                                 g_cclosure_marshal_VOID__POINTER,
+                                                 G_TYPE_NONE, 1,
+                                                 G_TYPE_POINTER);
 
     signals[TMODEL_STATE_CHANGED] = g_signal_new("torrents-state-change",
-            G_TYPE_FROM_CLASS
-            (object_class), G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
-            G_STRUCT_OFFSET
-            (TrgTorrentModelClass,
-                    torrent_removed), NULL, NULL, g_cclosure_marshal_VOID__UINT,
-            G_TYPE_NONE, 1, G_TYPE_UINT);
+                                                 G_TYPE_FROM_CLASS
+                                                 (object_class),
+                                                 G_SIGNAL_RUN_LAST |
+                                                 G_SIGNAL_ACTION,
+                                                 G_STRUCT_OFFSET
+                                                 (TrgTorrentModelClass,
+                                                  torrent_removed), NULL,
+                                                 NULL,
+                                                 g_cclosure_marshal_VOID__UINT,
+                                                 G_TYPE_NONE, 1,
+                                                 G_TYPE_UINT);
 }
 
-trg_torrent_model_update_stats *trg_torrent_model_get_stats(
-        TrgTorrentModel * model) {
+trg_torrent_model_update_stats *trg_torrent_model_get_stats(TrgTorrentModel
+                                                            * model)
+{
     TrgTorrentModelPrivate *priv = TRG_TORRENT_MODEL_GET_PRIVATE(model);
     return &(priv->stats);
 }
 
 static void trg_torrent_model_count_peers(TrgTorrentModel * model,
-        GtkTreeIter * iter, JsonObject * t) {
-    GList *trackersList = json_array_get_elements(torrent_get_tracker_stats(t));
+                                          GtkTreeIter * iter,
+                                          JsonObject * t)
+{
+    GList *trackersList =
+        json_array_get_elements(torrent_get_tracker_stats(t));
     gint seeders = 0;
     gint leechers = 0;
     gint downloads = 0;
@@ -140,11 +162,12 @@ static void trg_torrent_model_count_peers(TrgTorrentModel * model,
     g_list_free(trackersList);
 
     gtk_list_store_set(GTK_LIST_STORE(model), iter, TORRENT_COLUMN_SEEDS,
-            seeders, TORRENT_COLUMN_LEECHERS, leechers,
-            TORRENT_COLUMN_DOWNLOADS, downloads, -1);
+                       seeders, TORRENT_COLUMN_LEECHERS, leechers,
+                       TORRENT_COLUMN_DOWNLOADS, downloads, -1);
 }
 
-static void trg_torrent_model_ref_free(gpointer data) {
+static void trg_torrent_model_ref_free(gpointer data)
+{
     GtkTreeRowReference *rr = (GtkTreeRowReference *) data;
     GtkTreeModel *model = gtk_tree_row_reference_get_model(rr);
     GtkTreePath *path = gtk_tree_row_reference_get_path(rr);
@@ -152,13 +175,14 @@ static void trg_torrent_model_ref_free(gpointer data) {
         GtkTreeIter iter;
         JsonObject *json;
         if (gtk_tree_model_get_iter(model, &iter, path)) {
-            gtk_tree_model_get(model, &iter, TORRENT_COLUMN_JSON, &json, -1);
+            gtk_tree_model_get(model, &iter, TORRENT_COLUMN_JSON, &json,
+                               -1);
             json_object_unref(json);
             g_object_set_data(G_OBJECT(model), PROP_REMOVE_IN_PROGRESS,
-                    GINT_TO_POINTER(TRUE));
+                              GINT_TO_POINTER(TRUE));
             gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
             g_object_set_data(G_OBJECT(model), PROP_REMOVE_IN_PROGRESS,
-                    GINT_TO_POINTER(FALSE));
+                              GINT_TO_POINTER(FALSE));
         }
 
         gtk_tree_path_free(path);
@@ -167,7 +191,8 @@ static void trg_torrent_model_ref_free(gpointer data) {
     gtk_tree_row_reference_free(rr);
 }
 
-static void trg_torrent_model_init(TrgTorrentModel * self) {
+static void trg_torrent_model_init(TrgTorrentModel * self)
+{
     TrgTorrentModelPrivate *priv = TRG_TORRENT_MODEL_GET_PRIVATE(self);
 
     GType column_types[TORRENT_COLUMN_COLUMNS];
@@ -210,35 +235,43 @@ static void trg_torrent_model_init(TrgTorrentModel * self) {
     column_types[TORRENT_COLUMN_LASTACTIVE] = G_TYPE_INT64;
 
     gtk_list_store_set_column_types(GTK_LIST_STORE(self),
-            TORRENT_COLUMN_COLUMNS, column_types);
+                                    TORRENT_COLUMN_COLUMNS, column_types);
 
     priv->ht = g_hash_table_new_full(g_int64_hash, g_int64_equal,
-            (GDestroyNotify) g_free, trg_torrent_model_ref_free);
+                                     (GDestroyNotify) g_free,
+                                     trg_torrent_model_ref_free);
 
     g_object_set_data(G_OBJECT(self), PROP_REMOVE_IN_PROGRESS,
-            GINT_TO_POINTER(FALSE));
+                      GINT_TO_POINTER(FALSE));
 
     priv->urlHostRegex = trg_uri_host_regex_new();
 }
 
-gboolean trg_torrent_model_is_remove_in_progress(TrgTorrentModel * model) {
+gboolean trg_torrent_model_is_remove_in_progress(TrgTorrentModel * model)
+{
     return (gboolean) GPOINTER_TO_INT(g_object_get_data
-            (G_OBJECT(model),
-                    PROP_REMOVE_IN_PROGRESS));
+                                      (G_OBJECT(model),
+                                       PROP_REMOVE_IN_PROGRESS));
 }
 
-static gboolean trg_torrent_model_reload_dir_aliases_foreachfunc(
-        GtkTreeModel * model, GtkTreePath * path G_GNUC_UNUSED,
-        GtkTreeIter * iter, gpointer gdata) {
+static gboolean
+trg_torrent_model_reload_dir_aliases_foreachfunc(GtkTreeModel * model,
+                                                 GtkTreePath *
+                                                 path G_GNUC_UNUSED,
+                                                 GtkTreeIter * iter,
+                                                 gpointer gdata)
+{
     gchar *downloadDir, *shortDownloadDir;
 
-    gtk_tree_model_get(model, iter, TORRENT_COLUMN_DOWNLOADDIR, &downloadDir,
-            -1);
+    gtk_tree_model_get(model, iter, TORRENT_COLUMN_DOWNLOADDIR,
+                       &downloadDir, -1);
 
-    shortDownloadDir = shorten_download_dir((TrgClient *) gdata, downloadDir);
+    shortDownloadDir =
+        shorten_download_dir((TrgClient *) gdata, downloadDir);
 
     gtk_list_store_set(GTK_LIST_STORE(model), iter,
-            TORRENT_COLUMN_DOWNLOADDIR_SHORT, shortDownloadDir, -1);
+                       TORRENT_COLUMN_DOWNLOADDIR_SHORT, shortDownloadDir,
+                       -1);
 
     g_free(downloadDir);
     g_free(shortDownloadDir);
@@ -246,55 +279,56 @@ static gboolean trg_torrent_model_reload_dir_aliases_foreachfunc(
     return FALSE;
 }
 
-void trg_torrent_model_reload_dir_aliases(TrgClient * tc, GtkTreeModel * model) {
+void trg_torrent_model_reload_dir_aliases(TrgClient * tc,
+                                          GtkTreeModel * model)
+{
     gtk_tree_model_foreach(model,
-            trg_torrent_model_reload_dir_aliases_foreachfunc, tc);
+                           trg_torrent_model_reload_dir_aliases_foreachfunc,
+                           tc);
     g_signal_emit(model, signals[TMODEL_STATE_CHANGED], 0,
-            TORRENT_UPDATE_PATH_CHANGE);
+                  TORRENT_UPDATE_PATH_CHANGE);
 }
 
-static gboolean trg_torrent_model_stats_scan_foreachfunc(GtkTreeModel * model,
-        GtkTreePath * path G_GNUC_UNUSED, GtkTreeIter * iter, gpointer gdata) {
+static gboolean trg_torrent_model_stats_scan_foreachfunc(GtkTreeModel *
+                                                         model,
+                                                         GtkTreePath *
+                                                         path
+                                                         G_GNUC_UNUSED,
+                                                         GtkTreeIter *
+                                                         iter,
+                                                         gpointer gdata)
+{
     trg_torrent_model_update_stats *stats =
-            (trg_torrent_model_update_stats *) gdata;
+        (trg_torrent_model_update_stats *) gdata;
     guint flags;
 
     gtk_tree_model_get(model, iter, TORRENT_COLUMN_FLAGS, &flags, -1);
 
-    if (flags & TORRENT_FLAG_SEEDING
-    )
+    if (flags & TORRENT_FLAG_SEEDING)
         stats->seeding++;
-    else if (flags & TORRENT_FLAG_DOWNLOADING
-    )
+    else if (flags & TORRENT_FLAG_DOWNLOADING)
         stats->down++;
-    else if (flags & TORRENT_FLAG_PAUSED
-    )
+    else if (flags & TORRENT_FLAG_PAUSED)
         stats->paused++;
 
-    if (flags & TORRENT_FLAG_ERROR
-    )
+    if (flags & TORRENT_FLAG_ERROR)
         stats->error++;
 
-    if (flags & TORRENT_FLAG_COMPLETE
-    )
+    if (flags & TORRENT_FLAG_COMPLETE)
         stats->complete++;
     else
         stats->incomplete++;
 
-    if (flags & TORRENT_FLAG_CHECKING
-    )
+    if (flags & TORRENT_FLAG_CHECKING)
         stats->checking++;
 
-    if (flags & TORRENT_FLAG_ACTIVE
-    )
+    if (flags & TORRENT_FLAG_ACTIVE)
         stats->active++;
 
-    if (flags & TORRENT_FLAG_SEEDING_WAIT
-        )
+    if (flags & TORRENT_FLAG_SEEDING_WAIT)
         stats->seed_wait++;
 
-    if (flags & TORRENT_FLAG_DOWNLOADING_WAIT
-        )
+    if (flags & TORRENT_FLAG_DOWNLOADING_WAIT)
         stats->down_wait++;
 
     stats->count++;
@@ -302,16 +336,19 @@ static gboolean trg_torrent_model_stats_scan_foreachfunc(GtkTreeModel * model,
     return FALSE;
 }
 
-void trg_torrent_model_remove_all(TrgTorrentModel * model) {
+void trg_torrent_model_remove_all(TrgTorrentModel * model)
+{
     TrgTorrentModelPrivate *priv = TRG_TORRENT_MODEL_GET_PRIVATE(model);
     g_hash_table_remove_all(priv->ht);
     gtk_list_store_clear(GTK_LIST_STORE(model));
 }
 
-gchar *shorten_download_dir(TrgClient * tc, const gchar * downloadDir) {
+gchar *shorten_download_dir(TrgClient * tc, const gchar * downloadDir)
+{
     TrgPrefs *prefs = trg_client_get_prefs(tc);
-    JsonArray *labels = trg_prefs_get_array(prefs, TRG_PREFS_KEY_DESTINATIONS,
-            TRG_PREFS_CONNECTION);
+    JsonArray *labels =
+        trg_prefs_get_array(prefs, TRG_PREFS_KEY_DESTINATIONS,
+                            TRG_PREFS_CONNECTION);
     JsonObject *session = trg_client_get_session(tc);
     const gchar *defaultDownloadDir = session_get_download_dir(session);
     gchar *shortDownloadDir = NULL;
@@ -321,13 +358,15 @@ gchar *shorten_download_dir(TrgClient * tc, const gchar * downloadDir) {
         if (labelsList) {
             GList *li;
             for (li = labelsList; li; li = g_list_next(li)) {
-                JsonObject *labelObj = json_node_get_object(
-                        (JsonNode *) li->data);
-                const gchar *labelDir = json_object_get_string_member(labelObj,
-                        TRG_PREFS_KEY_DESTINATIONS_SUBKEY_DIR);
+                JsonObject *labelObj = json_node_get_object((JsonNode *)
+                                                            li->data);
+                const gchar *labelDir =
+                    json_object_get_string_member(labelObj,
+                                                  TRG_PREFS_KEY_DESTINATIONS_SUBKEY_DIR);
                 if (!g_strcmp0(downloadDir, labelDir)) {
-                    const gchar *labelLabel = json_object_get_string_member(
-                            labelObj, TRG_PREFS_SUBKEY_LABEL);
+                    const gchar *labelLabel =
+                        json_object_get_string_member(labelObj,
+                                                      TRG_PREFS_SUBKEY_LABEL);
                     shortDownloadDir = g_strdup(labelLabel);
                     break;
                 }
@@ -355,9 +394,13 @@ gchar *shorten_download_dir(TrgClient * tc, const gchar * downloadDir) {
     return g_strdup(downloadDir);
 }
 
-static inline void update_torrent_iter(TrgTorrentModel * model, TrgClient * tc,
-        gint64 rpcv, gint64 serial, GtkTreeIter * iter, JsonObject * t,
-        trg_torrent_model_update_stats * stats, guint *whatsChanged) {
+static inline void update_torrent_iter(TrgTorrentModel * model,
+                                       TrgClient * tc, gint64 rpcv,
+                                       gint64 serial, GtkTreeIter * iter,
+                                       JsonObject * t,
+                                       trg_torrent_model_update_stats *
+                                       stats, guint * whatsChanged)
+{
     TrgTorrentModelPrivate *priv = TRG_TORRENT_MODEL_GET_PRIVATE(model);
     GtkListStore *ls = GTK_LIST_STORE(model);
     guint lastFlags, newFlags;
@@ -390,147 +433,154 @@ static inline void update_torrent_iter(TrgTorrentModel * model, TrgClient * tc,
     trackerStats = torrent_get_tracker_stats(t);
 
     gtk_tree_model_get(GTK_TREE_MODEL(model), iter, TORRENT_COLUMN_FLAGS,
-            &lastFlags, TORRENT_COLUMN_JSON, &lastJson,
-            TORRENT_COLUMN_DOWNLOADDIR, &lastDownloadDir, -1);
+                       &lastFlags, TORRENT_COLUMN_JSON, &lastJson,
+                       TORRENT_COLUMN_DOWNLOADDIR, &lastDownloadDir, -1);
 
     json_object_ref(t);
 
     if (json_array_get_length(trackerStats) > 0) {
-        JsonObject *firstTracker = json_array_get_object_element(trackerStats,
-                0);
+        JsonObject *firstTracker =
+            json_array_get_object_element(trackerStats,
+                                          0);
         firstTrackerHost = trg_gregex_get_first(priv->urlHostRegex,
-                tracker_stats_get_host(firstTracker));
+                                                tracker_stats_get_host
+                                                (firstTracker));
     }
 
     lpd = peerfrom_get_lpd(pf);
     if (newFlags & TORRENT_FLAG_ACTIVE) {
         if (lpd >= 0) {
-            peerSources = g_strdup_printf(
-                    "%ld / %ld / %ld / %ld / %ld / %ld / %ld",
-                    peerfrom_get_trackers(pf), peerfrom_get_incoming(pf),
-                    peerfrom_get_ltep(pf), peerfrom_get_dht(pf),
-                    peerfrom_get_pex(pf), lpd, peerfrom_get_resume(pf));
+            peerSources =
+                g_strdup_printf("%ld / %ld / %ld / %ld / %ld / %ld / %ld",
+                                peerfrom_get_trackers(pf),
+                                peerfrom_get_incoming(pf),
+                                peerfrom_get_ltep(pf),
+                                peerfrom_get_dht(pf), peerfrom_get_pex(pf),
+                                lpd, peerfrom_get_resume(pf));
         } else {
-            peerSources = g_strdup_printf(
-                    "%ld / %ld / %ld / %ld / %ld / N/A / %ld",
-                    peerfrom_get_trackers(pf), peerfrom_get_incoming(pf),
-                    peerfrom_get_ltep(pf), peerfrom_get_dht(pf),
-                    peerfrom_get_pex(pf), peerfrom_get_resume(pf));
+            peerSources =
+                g_strdup_printf("%ld / %ld / %ld / %ld / %ld / N/A / %ld",
+                                peerfrom_get_trackers(pf),
+                                peerfrom_get_incoming(pf),
+                                peerfrom_get_ltep(pf),
+                                peerfrom_get_dht(pf), peerfrom_get_pex(pf),
+                                peerfrom_get_resume(pf));
         }
     }
 #ifdef DEBUG
     gtk_list_store_set(ls, iter, TORRENT_COLUMN_ICON, statusIcon, -1);
     gtk_list_store_set(ls, iter,
-            TORRENT_COLUMN_NAME, torrent_get_name(t), -1);
+                       TORRENT_COLUMN_NAME, torrent_get_name(t), -1);
     gtk_list_store_set(ls, iter,
-            TORRENT_COLUMN_SIZE, torrent_get_size(t), -1);
+                       TORRENT_COLUMN_SIZE, torrent_get_size(t), -1);
     gtk_list_store_set(ls, iter,
-            TORRENT_COLUMN_DONE,
-            (newFlags & TORRENT_FLAG_CHECKING) ?
-            torrent_get_recheck_progress(t)
-            : torrent_get_percent_done(t), -1);
+                       TORRENT_COLUMN_DONE,
+                       (newFlags & TORRENT_FLAG_CHECKING) ?
+                       torrent_get_recheck_progress(t)
+                       : torrent_get_percent_done(t), -1);
     gtk_list_store_set(ls, iter, TORRENT_COLUMN_STATUS, statusString, -1);
     gtk_list_store_set(ls, iter, TORRENT_COLUMN_DOWNSPEED, downRate, -1);
     gtk_list_store_set(ls, iter, TORRENT_COLUMN_FLAGS, newFlags, -1);
     gtk_list_store_set(ls, iter, TORRENT_COLUMN_UPSPEED, upRate, -1);
     gtk_list_store_set(ls, iter, TORRENT_COLUMN_ETA,
-            torrent_get_eta(t), -1);
+                       torrent_get_eta(t), -1);
     gtk_list_store_set(ls, iter, TORRENT_COLUMN_UPLOADED, uploaded, -1);
     gtk_list_store_set(ls, iter,
-            TORRENT_COLUMN_DOWNLOADED, downloaded, -1);
+                       TORRENT_COLUMN_DOWNLOADED, downloaded, -1);
     gtk_list_store_set(ls, iter, TORRENT_COLUMN_RATIO,
-            uploaded > 0
-            && downloaded >
-            0 ? (double) uploaded / (double) downloaded : 0,
-            -1);
+                       uploaded > 0
+                       && downloaded >
+                       0 ? (double) uploaded / (double) downloaded : 0,
+                       -1);
     gtk_list_store_set(ls, iter, TORRENT_COLUMN_ID, id, -1);
     gtk_list_store_set(ls, iter, TORRENT_COLUMN_JSON, t, -1);
     gtk_list_store_set(ls, iter, TORRENT_COLUMN_UPDATESERIAL, serial, -1);
     gtk_list_store_set(ls, iter,
-            TORRENT_COLUMN_ADDED, torrent_get_added_date(t),
-            -1);
+                       TORRENT_COLUMN_ADDED, torrent_get_added_date(t),
+                       -1);
     gtk_list_store_set(ls, iter, TORRENT_COLUMN_DOWNLOADDIR,
-            downloadDir, -1);
+                       downloadDir, -1);
     gtk_list_store_set(ls, iter, TORRENT_COLUMN_BANDWIDTH_PRIORITY,
-            torrent_get_bandwidth_priority(t), -1);
+                       torrent_get_bandwidth_priority(t), -1);
     gtk_list_store_set(ls, iter, TORRENT_COLUMN_DONE_DATE,
-            torrent_get_done_date(t), -1);
+                       torrent_get_done_date(t), -1);
     gtk_list_store_set(ls, iter, TORRENT_COLUMN_FROMPEX,
-            peerfrom_get_pex(pf), -1);
+                       peerfrom_get_pex(pf), -1);
     gtk_list_store_set(ls, iter, TORRENT_COLUMN_FROMDHT,
-            peerfrom_get_dht(pf), -1);
+                       peerfrom_get_dht(pf), -1);
     gtk_list_store_set(ls, iter, TORRENT_COLUMN_FROMTRACKERS,
-            peerfrom_get_trackers(pf), -1);
+                       peerfrom_get_trackers(pf), -1);
     gtk_list_store_set(ls, iter, TORRENT_COLUMN_FROMLTEP,
-            peerfrom_get_ltep(pf), -1);
+                       peerfrom_get_ltep(pf), -1);
     gtk_list_store_set(ls, iter, TORRENT_COLUMN_FROMRESUME,
-            peerfrom_get_resume(pf), -1);
+                       peerfrom_get_resume(pf), -1);
     gtk_list_store_set(ls, iter, TORRENT_COLUMN_FROMINCOMING,
-            peerfrom_get_incoming(pf), -1);
+                       peerfrom_get_incoming(pf), -1);
     gtk_list_store_set(ls, iter, TORRENT_COLUMN_PEER_SOURCES,
-            peerSources, -1);
+                       peerSources, -1);
     gtk_list_store_set(ls, iter, TORRENT_COLUMN_PEERS_CONNECTED,
-            torrent_get_peers_connected(t), -1);
+                       torrent_get_peers_connected(t), -1);
     gtk_list_store_set(ls, iter, TORRENT_COLUMN_PEERS_TO_US,
-            torrent_get_peers_sending_to_us(t), -1);
+                       torrent_get_peers_sending_to_us(t), -1);
     gtk_list_store_set(ls, iter, TORRENT_COLUMN_PEERS_FROM_US,
-            torrent_get_peers_getting_from_us(t), -1);
+                       torrent_get_peers_getting_from_us(t), -1);
     gtk_list_store_set(ls, iter, TORRENT_COLUMN_TRACKERHOST,
-            firstTrackerHost ? firstTrackerHost : "", -1);
+                       firstTrackerHost ? firstTrackerHost : "", -1);
     gtk_list_store_set(ls, iter, TORRENT_COLUMN_QUEUE_POSITION,
-            torrent_get_queue_position(t), -1);
+                       torrent_get_queue_position(t), -1);
     gtk_list_store_set(ls, iter, TORRENT_COLUMN_LASTACTIVE,
-            torrent_get_activity_date(t), -1);
+                       torrent_get_activity_date(t), -1);
 #else
     gtk_list_store_set(ls, iter, TORRENT_COLUMN_ICON, statusIcon,
-            TORRENT_COLUMN_ADDED, torrent_get_added_date(t),
-            TORRENT_COLUMN_DONE_DATE, torrent_get_done_date(t),
-            TORRENT_COLUMN_NAME, torrent_get_name(t), TORRENT_COLUMN_SIZE,
-            torrent_get_size(t), TORRENT_COLUMN_DONE,
-            (newFlags & TORRENT_FLAG_CHECKING) ?
-            torrent_get_recheck_progress(t)
-            : torrent_get_percent_done(t),
-            TORRENT_COLUMN_STATUS, statusString,
-            TORRENT_COLUMN_DOWNSPEED, downRate,
-            TORRENT_COLUMN_FLAGS, newFlags,
-            TORRENT_COLUMN_UPSPEED, upRate, TORRENT_COLUMN_ETA,
-            torrent_get_eta(t), TORRENT_COLUMN_UPLOADED,
-            uploaded, TORRENT_COLUMN_DOWNLOADED, downloaded,
-            TORRENT_COLUMN_FROMPEX, peerfrom_get_pex(pf),
-            TORRENT_COLUMN_FROMDHT, peerfrom_get_dht(pf),
-            TORRENT_COLUMN_FROMTRACKERS,
-            peerfrom_get_trackers(pf), TORRENT_COLUMN_FROMLTEP,
-            peerfrom_get_ltep(pf), TORRENT_COLUMN_FROMRESUME,
-            peerfrom_get_resume(pf),
-            TORRENT_COLUMN_FROMINCOMING,
-            peerfrom_get_incoming(pf),
-            TORRENT_COLUMN_PEER_SOURCES, peerSources,
-            TORRENT_COLUMN_PEERS_CONNECTED,
-            torrent_get_peers_connected(t),
-            TORRENT_COLUMN_PEERS_TO_US,
-            torrent_get_peers_sending_to_us(t),
-            TORRENT_COLUMN_PEERS_FROM_US,
-            torrent_get_peers_getting_from_us(t),
-            TORRENT_COLUMN_QUEUE_POSITION,
-            torrent_get_queue_position(t),
-            TORRENT_COLUMN_LASTACTIVE,
-            torrent_get_activity_date(t), TORRENT_COLUMN_RATIO,
-            uploaded > 0
-            && downloaded >
-            0 ? (double) uploaded / (double) downloaded : 0,
-            TORRENT_COLUMN_DOWNLOADDIR, downloadDir,
-            TORRENT_COLUMN_BANDWIDTH_PRIORITY,
-            torrent_get_bandwidth_priority(t),
-            TORRENT_COLUMN_ID, id, TORRENT_COLUMN_JSON, t,
-            TORRENT_COLUMN_TRACKERHOST,
-            firstTrackerHost ? firstTrackerHost : "",
-            TORRENT_COLUMN_UPDATESERIAL, serial, -1);
+                       TORRENT_COLUMN_ADDED, torrent_get_added_date(t),
+                       TORRENT_COLUMN_DONE_DATE, torrent_get_done_date(t),
+                       TORRENT_COLUMN_NAME, torrent_get_name(t),
+                       TORRENT_COLUMN_SIZE, torrent_get_size(t),
+                       TORRENT_COLUMN_DONE,
+                       (newFlags & TORRENT_FLAG_CHECKING) ?
+                       torrent_get_recheck_progress(t)
+                       : torrent_get_percent_done(t),
+                       TORRENT_COLUMN_STATUS, statusString,
+                       TORRENT_COLUMN_DOWNSPEED, downRate,
+                       TORRENT_COLUMN_FLAGS, newFlags,
+                       TORRENT_COLUMN_UPSPEED, upRate, TORRENT_COLUMN_ETA,
+                       torrent_get_eta(t), TORRENT_COLUMN_UPLOADED,
+                       uploaded, TORRENT_COLUMN_DOWNLOADED, downloaded,
+                       TORRENT_COLUMN_FROMPEX, peerfrom_get_pex(pf),
+                       TORRENT_COLUMN_FROMDHT, peerfrom_get_dht(pf),
+                       TORRENT_COLUMN_FROMTRACKERS,
+                       peerfrom_get_trackers(pf), TORRENT_COLUMN_FROMLTEP,
+                       peerfrom_get_ltep(pf), TORRENT_COLUMN_FROMRESUME,
+                       peerfrom_get_resume(pf),
+                       TORRENT_COLUMN_FROMINCOMING,
+                       peerfrom_get_incoming(pf),
+                       TORRENT_COLUMN_PEER_SOURCES, peerSources,
+                       TORRENT_COLUMN_PEERS_CONNECTED,
+                       torrent_get_peers_connected(t),
+                       TORRENT_COLUMN_PEERS_TO_US,
+                       torrent_get_peers_sending_to_us(t),
+                       TORRENT_COLUMN_PEERS_FROM_US,
+                       torrent_get_peers_getting_from_us(t),
+                       TORRENT_COLUMN_QUEUE_POSITION,
+                       torrent_get_queue_position(t),
+                       TORRENT_COLUMN_LASTACTIVE,
+                       torrent_get_activity_date(t), TORRENT_COLUMN_RATIO,
+                       uploaded > 0
+                       && downloaded >
+                       0 ? (double) uploaded / (double) downloaded : 0,
+                       TORRENT_COLUMN_DOWNLOADDIR, downloadDir,
+                       TORRENT_COLUMN_BANDWIDTH_PRIORITY,
+                       torrent_get_bandwidth_priority(t),
+                       TORRENT_COLUMN_ID, id, TORRENT_COLUMN_JSON, t,
+                       TORRENT_COLUMN_TRACKERHOST,
+                       firstTrackerHost ? firstTrackerHost : "",
+                       TORRENT_COLUMN_UPDATESERIAL, serial, -1);
 #endif
 
     if (!lastDownloadDir || g_strcmp0(downloadDir, lastDownloadDir)) {
         gchar *shortDownloadDir = shorten_download_dir(tc, downloadDir);
         gtk_list_store_set(ls, iter, TORRENT_COLUMN_DOWNLOADDIR_SHORT,
-                shortDownloadDir, -1);
+                           shortDownloadDir, -1);
         g_free(shortDownloadDir);
         *whatsChanged |= TORRENT_UPDATE_PATH_CHANGE;
     }
@@ -539,7 +589,7 @@ static inline void update_torrent_iter(TrgTorrentModel * model, TrgClient * tc,
         json_object_unref(lastJson);
 
     if ((lastFlags & TORRENT_FLAG_DOWNLOADING)
-            && (newFlags & TORRENT_FLAG_COMPLETE))
+        && (newFlags & TORRENT_FLAG_COMPLETE))
         g_signal_emit(model, signals[TMODEL_TORRENT_COMPLETED], 0, iter);
 
     if (lastFlags != newFlags)
@@ -558,7 +608,8 @@ static inline void update_torrent_iter(TrgTorrentModel * model, TrgClient * tc,
     g_free(statusIcon);
 }
 
-TrgTorrentModel *trg_torrent_model_new(void) {
+TrgTorrentModel *trg_torrent_model_new(void)
+{
     return g_object_new(TRG_TYPE_TORRENT_MODEL, NULL);
 }
 
@@ -567,18 +618,23 @@ struct TrgModelRemoveData {
     gint64 currentSerial;
 };
 
-GHashTable *get_torrent_table(TrgTorrentModel * model) {
+GHashTable *get_torrent_table(TrgTorrentModel * model)
+{
     TrgTorrentModelPrivate *priv = TRG_TORRENT_MODEL_GET_PRIVATE(model);
     return priv->ht;
 }
 
 gboolean trg_model_find_removed_foreachfunc(GtkTreeModel * model,
-        GtkTreePath * path G_GNUC_UNUSED, GtkTreeIter * iter, gpointer gdata) {
+                                            GtkTreePath *
+                                            path G_GNUC_UNUSED,
+                                            GtkTreeIter * iter,
+                                            gpointer gdata)
+{
     struct TrgModelRemoveData *args = (struct TrgModelRemoveData *) gdata;
     gint64 rowSerial;
 
-    gtk_tree_model_get(model, iter, TORRENT_COLUMN_UPDATESERIAL, &rowSerial,
-            -1);
+    gtk_tree_model_get(model, iter, TORRENT_COLUMN_UPDATESERIAL,
+                       &rowSerial, -1);
 
     if (rowSerial != args->currentSerial) {
         gint64 *id = g_new(gint64, 1);
@@ -590,19 +646,21 @@ gboolean trg_model_find_removed_foreachfunc(GtkTreeModel * model,
 }
 
 GList *trg_torrent_model_find_removed(GtkTreeModel * model,
-        gint64 currentSerial) {
+                                      gint64 currentSerial)
+{
     struct TrgModelRemoveData args;
     args.toRemove = NULL;
     args.currentSerial = currentSerial;
 
     gtk_tree_model_foreach(GTK_TREE_MODEL(model),
-            trg_model_find_removed_foreachfunc, &args);
+                           trg_model_find_removed_foreachfunc, &args);
 
     return args.toRemove;
 }
 
 gboolean get_torrent_data(GHashTable * table, gint64 id, JsonObject ** t,
-        GtkTreeIter * out_iter) {
+                          GtkTreeIter * out_iter)
+{
     gpointer result = g_hash_table_lookup(table, &id);
     gboolean found = FALSE;
 
@@ -616,7 +674,8 @@ gboolean get_torrent_data(GHashTable * table, gint64 id, JsonObject ** t,
             if (out_iter)
                 *out_iter = iter;
             if (t)
-                gtk_tree_model_get(model, &iter, TORRENT_COLUMN_JSON, t, -1);
+                gtk_tree_model_get(model, &iter, TORRENT_COLUMN_JSON, t,
+                                   -1);
             found = TRUE;
             gtk_tree_path_free(path);
         }
@@ -625,16 +684,22 @@ gboolean get_torrent_data(GHashTable * table, gint64 id, JsonObject ** t,
     return found;
 }
 
-static void trg_torrent_model_stat_counts_clear(
-        trg_torrent_model_update_stats *stats) {
-    stats->count = stats->down = stats->error = stats->paused = stats->seeding =
-            stats->complete = stats->incomplete = stats->active =
-                    stats->checking = stats->seed_wait = stats->down_wait = 0;
+static void
+trg_torrent_model_stat_counts_clear(trg_torrent_model_update_stats * stats)
+{
+    stats->count = stats->down = stats->error = stats->paused =
+        stats->seeding = stats->complete = stats->incomplete =
+        stats->active = stats->checking = stats->seed_wait =
+        stats->down_wait = 0;
 }
 
-trg_torrent_model_update_stats *trg_torrent_model_update(
-        TrgTorrentModel * model, TrgClient * tc, JsonObject * response,
-        gint mode) {
+trg_torrent_model_update_stats *trg_torrent_model_update(TrgTorrentModel *
+                                                         model,
+                                                         TrgClient * tc,
+                                                         JsonObject *
+                                                         response,
+                                                         gint mode)
+{
     TrgTorrentModelPrivate *priv = TRG_TORRENT_MODEL_GET_PRIVATE(model);
 
     GList *torrentList;
@@ -662,15 +727,15 @@ trg_torrent_model_update_stats *trg_torrent_model_update(
         id = torrent_get_id(t);
 
         result =
-                mode == TORRENT_GET_MODE_FIRST ? NULL :
-                        g_hash_table_lookup(priv->ht, &id);
+            mode == TORRENT_GET_MODE_FIRST ? NULL :
+            g_hash_table_lookup(priv->ht, &id);
 
         if (!result) {
             gtk_list_store_append(GTK_LIST_STORE(model), &iter);
             whatsChanged |= TORRENT_UPDATE_ADDREMOVE;
 
             update_torrent_iter(model, tc, rpcv, trg_client_get_serial(tc),
-                    &iter, t, &(priv->stats), &whatsChanged);
+                                &iter, t, &(priv->stats), &whatsChanged);
 
             path = gtk_tree_model_get_path(GTK_TREE_MODEL(model), &iter);
             rr = gtk_tree_row_reference_new(GTK_TREE_MODEL(model), path);
@@ -680,16 +745,17 @@ trg_torrent_model_update_stats *trg_torrent_model_update(
             gtk_tree_path_free(path);
 
             if (mode != TORRENT_GET_MODE_FIRST)
-                g_signal_emit(model, signals[TMODEL_TORRENT_ADDED], 0, &iter);
+                g_signal_emit(model, signals[TMODEL_TORRENT_ADDED], 0,
+                              &iter);
         } else {
-            path = gtk_tree_row_reference_get_path(
-                    (GtkTreeRowReference *) result);
+            path = gtk_tree_row_reference_get_path((GtkTreeRowReference *)
+                                                   result);
             if (path) {
                 if (gtk_tree_model_get_iter(GTK_TREE_MODEL(model), &iter,
-                        path)) {
+                                            path)) {
                     update_torrent_iter(model, tc, rpcv,
-                            trg_client_get_serial(tc), &iter, t, &(priv->stats),
-                            &whatsChanged);
+                                        trg_client_get_serial(tc), &iter,
+                                        t, &(priv->stats), &whatsChanged);
                 }
                 gtk_tree_path_free(path);
             }
@@ -699,8 +765,9 @@ trg_torrent_model_update_stats *trg_torrent_model_update(
     g_list_free(torrentList);
 
     if (mode == TORRENT_GET_MODE_UPDATE) {
-        GList *hitlist = trg_torrent_model_find_removed(GTK_TREE_MODEL(model),
-                trg_client_get_serial(tc));
+        GList *hitlist =
+            trg_torrent_model_find_removed(GTK_TREE_MODEL(model),
+                                           trg_client_get_serial(tc));
         if (hitlist) {
             for (li = hitlist; li; li = g_list_next(li)) {
                 g_hash_table_remove(priv->ht, li->data);
@@ -724,12 +791,14 @@ trg_torrent_model_update_stats *trg_torrent_model_update(
 
     if (whatsChanged != 0) {
         if ((whatsChanged & TORRENT_UPDATE_ADDREMOVE)
-                || (whatsChanged & TORRENT_UPDATE_STATE_CHANGE)) {
+            || (whatsChanged & TORRENT_UPDATE_STATE_CHANGE)) {
             trg_torrent_model_stat_counts_clear(&priv->stats);
             gtk_tree_model_foreach(GTK_TREE_MODEL(model),
-                    trg_torrent_model_stats_scan_foreachfunc, &(priv->stats));
+                                   trg_torrent_model_stats_scan_foreachfunc,
+                                   &(priv->stats));
         }
-        g_signal_emit(model, signals[TMODEL_STATE_CHANGED], 0, whatsChanged);
+        g_signal_emit(model, signals[TMODEL_STATE_CHANGED], 0,
+                      whatsChanged);
     }
 
     return &(priv->stats);