filter items (not trackers+dirs for now) show counts next to them. while doing this, I made the stats update loop something that happens only if something changes, which avoids a full iteration over all torrents (even in active only).

1 files changed, 233 insertions, 268 deletions

diff --git a/src/trg-torrent-model.c b/src/trg-torrent-model.c
index 3dd7f9f..e46b876 100644
--- a/src/trg-torrent-model.c
+++ b/src/trg-torrent-model.c
@@ -54,7 +54,7 @@
 enum {
     TMODEL_TORRENT_COMPLETED,
     TMODEL_TORRENT_ADDED,
-    TMODEL_UPDATE_FILTERS,
+    TMODEL_STATE_CHANGED,
     TMODEL_SIGNAL_COUNT
 };
 
@@ -73,8 +73,7 @@ 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);
@@ -82,69 +81,49 @@ 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, 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);
-
-    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_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);
 }
 
-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;
@@ -161,12 +140,11 @@ 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);
@@ -174,14 +152,13 @@ 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);
@@ -190,8 +167,7 @@ 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];
@@ -234,43 +210,35 @@ 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);
@@ -278,57 +246,68 @@ trg_torrent_model_reload_dir_aliases_foreachfunc(GtkTreeModel * model,
     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);
 }
 
-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
+        )
+        stats->complete++;
+    else
+        stats->incomplete++;
+
+    if (flags & TORRENT_FLAG_CHECKING
+        )
+        stats->checking++;
+
+    if (flags & TORRENT_FLAG_ACTIVE
+        )
+        stats->active++;
+
+    if (flags & TORRENT_FLAG_SEEDING_WAIT)
+        stats->seed_wait++;
+
+    if (flags & TORRENT_FLAG_DOWNLOADING_WAIT)
+        stats->down_wait++;
+
     stats->count++;
 
     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;
@@ -338,15 +317,13 @@ 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;
                 }
@@ -374,13 +351,9 @@ 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, gboolean * updateFilters)
-{
+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;
@@ -413,165 +386,161 @@ 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);
+        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);
-        *updateFilters = TRUE;
+        *whatsChanged |= TORRENT_UPDATE_PATH_CHANGE;
     }
 
     if (lastJson)
         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)
+        *whatsChanged |= TORRENT_UPDATE_STATE_CHANGE;
+
     trg_torrent_model_count_peers(model, iter, t);
 
     if (firstTrackerHost)
@@ -585,8 +554,7 @@ static inline void update_torrent_iter(TrgTorrentModel * model,
     g_free(statusIcon);
 }
 
-TrgTorrentModel *trg_torrent_model_new(void)
-{
+TrgTorrentModel *trg_torrent_model_new(void) {
     return g_object_new(TRG_TYPE_TORRENT_MODEL, NULL);
 }
 
@@ -595,23 +563,18 @@ 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);
@@ -623,21 +586,19 @@ 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;
 
@@ -651,8 +612,7 @@ 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);
         }
@@ -661,13 +621,16 @@ gboolean get_torrent_data(GHashTable * table, gint64 id, JsonObject ** t,
     return found;
 }
 
-trg_torrent_model_update_stats *trg_torrent_model_update(TrgTorrentModel *
-                                                         model,
-                                                         TrgClient * tc,
-                                                         JsonObject *
-                                                         response,
-                                                         gint mode)
-{
+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) {
     TrgTorrentModelPrivate *priv = TRG_TORRENT_MODEL_GET_PRIVATE(model);
 
     GList *torrentList;
@@ -680,28 +643,30 @@ trg_torrent_model_update_stats *trg_torrent_model_update(TrgTorrentModel *
     GtkTreePath *path;
     GtkTreeRowReference *rr;
     gpointer *result;
-    gboolean updateFilters = FALSE;
+    guint whatsChanged = 0;
 
     gint64 rpcv = trg_client_get_rpc_version(tc);
 
     args = get_arguments(response);
     torrentList = json_array_get_elements(get_torrents(args));
 
-    memset(&(priv->stats), 0, sizeof(trg_torrent_model_update_stats));
+    priv->stats.downRateTotal = 0;
+    priv->stats.upRateTotal = 0;
 
     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);
+                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), &updateFilters);
+                    &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);
@@ -709,18 +674,19 @@ trg_torrent_model_update_stats *trg_torrent_model_update(TrgTorrentModel *
             *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);
+
+            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);
+            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), &updateFilters);
+                            trg_client_get_serial(tc), &iter, t, &(priv->stats),
+                            &whatsChanged);
                 }
                 gtk_tree_path_free(path);
             }
@@ -730,15 +696,14 @@ trg_torrent_model_update_stats *trg_torrent_model_update(TrgTorrentModel *
     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);
                 g_free(li->data);
             }
-            updateFilters = TRUE;
+            whatsChanged |= TORRENT_UPDATE_ADDREMOVE;
             g_list_free(hitlist);
         }
     } else if (mode > TORRENT_GET_MODE_FIRST) {
@@ -748,18 +713,18 @@ trg_torrent_model_update_stats *trg_torrent_model_update(TrgTorrentModel *
             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;
+                whatsChanged |= TORRENT_UPDATE_ADDREMOVE;
             }
             g_list_free(hitlist);
         }
     }
 
-    if (updateFilters)
-        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));
+    if (whatsChanged != 0) {
+        trg_torrent_model_stat_counts_clear(&priv->stats);
+        gtk_tree_model_foreach(GTK_TREE_MODEL(model),
+                trg_torrent_model_stats_scan_foreachfunc, &(priv->stats));
+        g_signal_emit(model, signals[TMODEL_STATE_CHANGED], 0, whatsChanged);
+    }
 
     return &(priv->stats);
 }