oops, no tabs. (indent -kr -nut)

1 files changed, 321 insertions, 321 deletions

diff --git a/src/trg-torrent-model.c b/src/trg-torrent-model.c
index 678f39a..7f9f922 100644
--- a/src/trg-torrent-model.c
+++ b/src/trg-torrent-model.c
@@ -82,9 +82,9 @@ 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,
-		    gboolean * updateFilters);
+                    gint64 serial, GtkTreeIter * iter, JsonObject * t,
+                    trg_torrent_model_update_stats * stats,
+                    gboolean * updateFilters);
 
 static void trg_torrent_model_class_init(TrgTorrentModelClass * klass)
 {
@@ -94,75 +94,75 @@ static void trg_torrent_model_class_init(TrgTorrentModelClass * klass)
     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_UPDATE_FILTERS] = g_signal_new("update-filters",
-						  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__VOID,
-						  G_TYPE_NONE, 0);
+                                                  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__VOID,
+                                                  G_TYPE_NONE, 0);
 }
 
 trg_torrent_model_update_stats *trg_torrent_model_get_stats(TrgTorrentModel
-							    * model)
+                                                            * 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)
+                                          GtkTreeIter * iter,
+                                          JsonObject * t)
 {
     GList *trackersList =
-	json_array_get_elements(torrent_get_tracker_stats(t));
+        json_array_get_elements(torrent_get_tracker_stats(t));
     gint seeders = 0;
     gint leechers = 0;
     gint downloads = 0;
     GList *li;
 
     for (li = trackersList; li; li = g_list_next(li)) {
-	JsonObject *tracker = json_node_get_object((JsonNode *) li->data);
+        JsonObject *tracker = json_node_get_object((JsonNode *) li->data);
 
-	seeders += tracker_stats_get_seeder_count(tracker);
-	leechers += tracker_stats_get_leecher_count(tracker);
-	downloads += tracker_stats_get_download_count(tracker);
+        seeders += tracker_stats_get_seeder_count(tracker);
+        leechers += tracker_stats_get_leecher_count(tracker);
+        downloads += tracker_stats_get_download_count(tracker);
     }
 
     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)
@@ -171,20 +171,20 @@ static void trg_torrent_model_ref_free(gpointer data)
     GtkTreeModel *model = gtk_tree_row_reference_get_model(rr);
     GtkTreePath *path = gtk_tree_row_reference_get_path(rr);
     if (path) {
-	GtkTreeIter iter;
-	JsonObject *json;
-	if (gtk_tree_model_get_iter(model, &iter, path)) {
-	    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));
-	    gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
-	    g_object_set_data(G_OBJECT(model), PROP_REMOVE_IN_PROGRESS,
-			      GINT_TO_POINTER(FALSE));
-	}
-
-	gtk_tree_path_free(path);
+        GtkTreeIter iter;
+        JsonObject *json;
+        if (gtk_tree_model_get_iter(model, &iter, path)) {
+            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));
+            gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
+            g_object_set_data(G_OBJECT(model), PROP_REMOVE_IN_PROGRESS,
+                              GINT_TO_POINTER(FALSE));
+        }
+
+        gtk_tree_path_free(path);
     }
 
     gtk_tree_row_reference_free(rr);
@@ -234,14 +234,14 @@ 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();
 }
@@ -249,28 +249,28 @@ static void trg_torrent_model_init(TrgTorrentModel * self)
 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)
+                                                 GtkTreePath *
+                                                 path G_GNUC_UNUSED,
+                                                 GtkTreeIter * iter,
+                                                 gpointer gdata)
 {
     gchar *downloadDir, *shortDownloadDir;
 
     gtk_tree_model_get(model, iter, TORRENT_COLUMN_DOWNLOADDIR,
-		       &downloadDir, -1);
+                       &downloadDir, -1);
 
     shortDownloadDir =
-	shorten_download_dir((TrgClient *) gdata, downloadDir);
+        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);
@@ -279,37 +279,37 @@ trg_torrent_model_reload_dir_aliases_foreachfunc(GtkTreeModel * model,
 }
 
 void trg_torrent_model_reload_dir_aliases(TrgClient * tc,
-					  GtkTreeModel * model)
+                                          GtkTreeModel * model)
 {
     gtk_tree_model_foreach(model,
-			   trg_torrent_model_reload_dir_aliases_foreachfunc,
-			   tc);
+                           trg_torrent_model_reload_dir_aliases_foreachfunc,
+                           tc);
 }
 
 static gboolean trg_torrent_model_stats_scan_foreachfunc(GtkTreeModel *
-							 model,
-							 GtkTreePath *
-							 path
-							 G_GNUC_UNUSED,
-							 GtkTreeIter *
-							 iter,
-							 gpointer gdata)
+                                                         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)
-	stats->seeding++;
+        stats->seeding++;
     else if (flags & TORRENT_FLAG_DOWNLOADING)
-	stats->down++;
+        stats->down++;
     else if (flags & TORRENT_FLAG_PAUSED)
-	stats->paused++;
+        stats->paused++;
 
     if (flags & TORRENT_FLAG_ERROR)
-	stats->error++;
+        stats->error++;
 
     stats->count++;
 
@@ -327,59 +327,59 @@ 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);
+        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;
 
     if (labels) {
-	GList *labelsList = json_array_get_elements(labels);
-	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);
-		if (!g_strcmp0(downloadDir, labelDir)) {
-		    const gchar *labelLabel =
-			json_object_get_string_member(labelObj,
-						      TRG_PREFS_SUBKEY_LABEL);
-		    shortDownloadDir = g_strdup(labelLabel);
-		    break;
-		}
-	    }
-	    g_list_free(labelsList);
-	}
+        GList *labelsList = json_array_get_elements(labels);
+        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);
+                if (!g_strcmp0(downloadDir, labelDir)) {
+                    const gchar *labelLabel =
+                        json_object_get_string_member(labelObj,
+                                                      TRG_PREFS_SUBKEY_LABEL);
+                    shortDownloadDir = g_strdup(labelLabel);
+                    break;
+                }
+            }
+            g_list_free(labelsList);
+        }
     }
 
     if (shortDownloadDir) {
-	return shortDownloadDir;
+        return shortDownloadDir;
     } else {
-	if (!g_strcmp0(defaultDownloadDir, downloadDir))
-	    return g_strdup(_("Default"));
+        if (!g_strcmp0(defaultDownloadDir, downloadDir))
+            return g_strdup(_("Default"));
 
-	if (g_str_has_prefix(downloadDir, defaultDownloadDir)) {
-	    int offset = strlen(defaultDownloadDir);
-	    if (*(downloadDir + offset) == '/')
-		offset++;
+        if (g_str_has_prefix(downloadDir, defaultDownloadDir)) {
+            int offset = strlen(defaultDownloadDir);
+            if (*(downloadDir + offset) == '/')
+                offset++;
 
-	    if (offset < strlen(downloadDir))
-		return g_strdup(downloadDir + offset);
-	}
+            if (offset < strlen(downloadDir))
+                return g_strdup(downloadDir + offset);
+        }
     }
 
     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, gboolean * updateFilters)
+                                       TrgClient * tc, gint64 rpcv,
+                                       gint64 serial, GtkTreeIter * iter,
+                                       JsonObject * t,
+                                       trg_torrent_model_update_stats *
+                                       stats, gboolean * updateFilters)
 {
     TrgTorrentModelPrivate *priv = TRG_TORRENT_MODEL_GET_PRIVATE(model);
     GtkListStore *ls = GTK_LIST_STORE(model);
@@ -413,172 +413,172 @@ static inline void update_torrent_iter(TrgTorrentModel * model,
     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);
-	firstTrackerHost = trg_gregex_get_first(priv->urlHostRegex,
-						tracker_stats_get_host
-						(firstTracker));
+        JsonObject *firstTracker =
+            json_array_get_object_element(trackerStats,
+                                          0);
+        firstTrackerHost = trg_gregex_get_first(priv->urlHostRegex,
+                                                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));
-	} 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));
-	}
+        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));
+        } 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));
+        }
     }
 #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);
-	g_free(shortDownloadDir);
-	*updateFilters = TRUE;
+        gchar *shortDownloadDir = shorten_download_dir(tc, downloadDir);
+        gtk_list_store_set(ls, iter, TORRENT_COLUMN_DOWNLOADDIR_SHORT,
+                           shortDownloadDir, -1);
+        g_free(shortDownloadDir);
+        *updateFilters = TRUE;
     }
 
     if (lastJson)
-	json_object_unref(lastJson);
+        json_object_unref(lastJson);
 
     if ((lastFlags & TORRENT_FLAG_DOWNLOADING)
-	&& (newFlags & TORRENT_FLAG_COMPLETE))
-	g_signal_emit(model, signals[TMODEL_TORRENT_COMPLETED], 0, iter);
+        && (newFlags & TORRENT_FLAG_COMPLETE))
+        g_signal_emit(model, signals[TMODEL_TORRENT_COMPLETED], 0, iter);
 
     trg_torrent_model_count_peers(model, iter, t);
 
     if (firstTrackerHost)
-	g_free(firstTrackerHost);
+        g_free(firstTrackerHost);
 
     if (peerSources)
-	g_free(peerSources);
+        g_free(peerSources);
 
     g_free(lastDownloadDir);
     g_free(statusString);
@@ -602,71 +602,71 @@ GHashTable *get_torrent_table(TrgTorrentModel * model)
 }
 
 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);
+                       &rowSerial, -1);
 
     if (rowSerial != args->currentSerial) {
-	gint64 *id = g_new(gint64, 1);
-	gtk_tree_model_get(model, iter, TORRENT_COLUMN_ID, id, -1);
-	args->toRemove = g_list_append(args->toRemove, id);
+        gint64 *id = g_new(gint64, 1);
+        gtk_tree_model_get(model, iter, TORRENT_COLUMN_ID, id, -1);
+        args->toRemove = g_list_append(args->toRemove, id);
     }
 
     return FALSE;
 }
 
 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;
 
     if (result) {
-	GtkTreeRowReference *rr = (GtkTreeRowReference *) result;
-	GtkTreePath *path = gtk_tree_row_reference_get_path(rr);
-	GtkTreeIter iter;
-	if (path) {
-	    GtkTreeModel *model = gtk_tree_row_reference_get_model(rr);
-	    gtk_tree_model_get_iter(model, &iter, path);
-	    if (out_iter)
-		*out_iter = iter;
-	    if (t)
-		gtk_tree_model_get(model, &iter, TORRENT_COLUMN_JSON, t,
-				   -1);
-	    found = TRUE;
-	    gtk_tree_path_free(path);
-	}
+        GtkTreeRowReference *rr = (GtkTreeRowReference *) result;
+        GtkTreePath *path = gtk_tree_row_reference_get_path(rr);
+        GtkTreeIter iter;
+        if (path) {
+            GtkTreeModel *model = gtk_tree_row_reference_get_model(rr);
+            gtk_tree_model_get_iter(model, &iter, path);
+            if (out_iter)
+                *out_iter = iter;
+            if (t)
+                gtk_tree_model_get(model, &iter, TORRENT_COLUMN_JSON, t,
+                                   -1);
+            found = TRUE;
+            gtk_tree_path_free(path);
+        }
     }
 
     return found;
 }
 
 trg_torrent_model_update_stats *trg_torrent_model_update(TrgTorrentModel *
-							 model,
-							 TrgClient * tc,
-							 JsonObject *
-							 response,
-							 gint mode)
+                                                         model,
+                                                         TrgClient * tc,
+                                                         JsonObject *
+                                                         response,
+                                                         gint mode)
 {
     TrgTorrentModelPrivate *priv = TRG_TORRENT_MODEL_GET_PRIVATE(model);
 
@@ -690,76 +690,76 @@ trg_torrent_model_update_stats *trg_torrent_model_update(TrgTorrentModel *
     memset(&(priv->stats), 0, sizeof(trg_torrent_model_update_stats));
 
     for (li = torrentList; li; li = g_list_next(li)) {
-	t = json_node_get_object((JsonNode *) li->data);
-	id = torrent_get_id(t);
-
-	result =
-	    mode == TORRENT_GET_MODE_FIRST ? NULL :
-	    g_hash_table_lookup(priv->ht, &id);
-
-	if (!result) {
-	    gtk_list_store_append(GTK_LIST_STORE(model), &iter);
-
-	    update_torrent_iter(model, tc, rpcv, trg_client_get_serial(tc),
-				&iter, t, &(priv->stats), &updateFilters);
-
-	    path = gtk_tree_model_get_path(GTK_TREE_MODEL(model), &iter);
-	    rr = gtk_tree_row_reference_new(GTK_TREE_MODEL(model), path);
-	    idCopy = g_new(gint64, 1);
-	    *idCopy = id;
-	    g_hash_table_insert(priv->ht, idCopy, rr);
-	    gtk_tree_path_free(path);
-	    if (mode != TORRENT_GET_MODE_FIRST)
-		g_signal_emit(model, signals[TMODEL_TORRENT_ADDED], 0,
-			      &iter);
-	} else {
-	    path = gtk_tree_row_reference_get_path((GtkTreeRowReference *)
-						   result);
-	    if (path) {
-		if (gtk_tree_model_get_iter(GTK_TREE_MODEL(model), &iter,
-					    path)) {
-		    update_torrent_iter(model, tc, rpcv,
-					trg_client_get_serial(tc), &iter,
-					t, &(priv->stats), &updateFilters);
-		}
-		gtk_tree_path_free(path);
-	    }
-	}
+        t = json_node_get_object((JsonNode *) li->data);
+        id = torrent_get_id(t);
+
+        result =
+            mode == TORRENT_GET_MODE_FIRST ? NULL :
+            g_hash_table_lookup(priv->ht, &id);
+
+        if (!result) {
+            gtk_list_store_append(GTK_LIST_STORE(model), &iter);
+
+            update_torrent_iter(model, tc, rpcv, trg_client_get_serial(tc),
+                                &iter, t, &(priv->stats), &updateFilters);
+
+            path = gtk_tree_model_get_path(GTK_TREE_MODEL(model), &iter);
+            rr = gtk_tree_row_reference_new(GTK_TREE_MODEL(model), path);
+            idCopy = g_new(gint64, 1);
+            *idCopy = id;
+            g_hash_table_insert(priv->ht, idCopy, rr);
+            gtk_tree_path_free(path);
+            if (mode != TORRENT_GET_MODE_FIRST)
+                g_signal_emit(model, signals[TMODEL_TORRENT_ADDED], 0,
+                              &iter);
+        } else {
+            path = gtk_tree_row_reference_get_path((GtkTreeRowReference *)
+                                                   result);
+            if (path) {
+                if (gtk_tree_model_get_iter(GTK_TREE_MODEL(model), &iter,
+                                            path)) {
+                    update_torrent_iter(model, tc, rpcv,
+                                        trg_client_get_serial(tc), &iter,
+                                        t, &(priv->stats), &updateFilters);
+                }
+                gtk_tree_path_free(path);
+            }
+        }
     }
 
     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));
-	if (hitlist) {
-	    for (li = hitlist; li; li = g_list_next(li)) {
-		g_hash_table_remove(priv->ht, li->data);
-		g_free(li->data);
-	    }
-	    updateFilters = TRUE;
-	    g_list_free(hitlist);
-	}
+        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);
+                g_free(li->data);
+            }
+            updateFilters = TRUE;
+            g_list_free(hitlist);
+        }
     } else if (mode > TORRENT_GET_MODE_FIRST) {
-	removedTorrents = get_torrents_removed(args);
-	if (removedTorrents) {
-	    GList *hitlist = json_array_get_elements(removedTorrents);
-	    for (li = hitlist; li; li = g_list_next(li)) {
-		id = json_node_get_int((JsonNode *) li->data);
-		g_hash_table_remove(priv->ht, &id);
-		updateFilters = TRUE;
-	    }
-	    g_list_free(hitlist);
-	}
+        removedTorrents = get_torrents_removed(args);
+        if (removedTorrents) {
+            GList *hitlist = json_array_get_elements(removedTorrents);
+            for (li = hitlist; li; li = g_list_next(li)) {
+                id = json_node_get_int((JsonNode *) li->data);
+                g_hash_table_remove(priv->ht, &id);
+                updateFilters = TRUE;
+            }
+            g_list_free(hitlist);
+        }
     }
 
     if (updateFilters)
-	g_signal_emit(model, signals[TMODEL_UPDATE_FILTERS], 0);
+        g_signal_emit(model, signals[TMODEL_UPDATE_FILTERS], 0);
 
     gtk_tree_model_foreach(GTK_TREE_MODEL(model),
-			   trg_torrent_model_stats_scan_foreachfunc,
-			   &(priv->stats));
+                           trg_torrent_model_stats_scan_foreachfunc,
+                           &(priv->stats));
 
     return &(priv->stats);
 }