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

1 files changed, 90 insertions, 90 deletions

diff --git a/src/trg-peers-model.c b/src/trg-peers-model.c
index e97eb8b..507d4f9 100644
--- a/src/trg-peers-model.c
+++ b/src/trg-peers-model.c
@@ -50,7 +50,7 @@ struct _TrgPeersModelPrivate {
 #endif
 
 static void trg_peers_model_class_init(TrgPeersModelClass *
-				       klass G_GNUC_UNUSED)
+                                       klass G_GNUC_UNUSED)
 {
 #ifdef HAVE_GEOIP
     g_type_class_add_private(klass, sizeof(TrgPeersModelPrivate));
@@ -58,41 +58,41 @@ static void trg_peers_model_class_init(TrgPeersModelClass *
 }
 
 gboolean find_existing_peer_item_foreachfunc(GtkTreeModel * model,
-					     GtkTreePath *
-					     path G_GNUC_UNUSED,
-					     GtkTreeIter * iter,
-					     gpointer data)
+                                             GtkTreePath *
+                                             path G_GNUC_UNUSED,
+                                             GtkTreeIter * iter,
+                                             gpointer data)
 {
     struct peerAndIter *pi = (struct peerAndIter *) data;
 
     gchar *ip;
     gtk_tree_model_get(model, iter, PEERSCOL_IP, &ip, -1);
     if (g_strcmp0(ip, pi->ip) == 0) {
-	pi->iter = *iter;
-	pi->found = TRUE;
+        pi->iter = *iter;
+        pi->found = TRUE;
     }
     g_free(ip);
     return pi->found;
 }
 
 gboolean find_existing_peer_item(TrgPeersModel * model, JsonObject * p,
-				 GtkTreeIter * iter)
+                                 GtkTreeIter * iter)
 {
     struct peerAndIter pi;
     pi.ip = peer_get_address(p);
     pi.found = FALSE;
 
     gtk_tree_model_foreach(GTK_TREE_MODEL(model),
-			   find_existing_peer_item_foreachfunc, &pi);
+                           find_existing_peer_item_foreachfunc, &pi);
 
     if (pi.found == TRUE)
-	*iter = pi.iter;
+        *iter = pi.iter;
 
     return pi.found;
 }
 
 static void resolved_dns_cb(GObject * source_object, GAsyncResult * res,
-			    gpointer data)
+                            gpointer data)
 {
     GtkTreeRowReference *treeRef;
     GtkTreeModel *model;
@@ -103,36 +103,36 @@ static void resolved_dns_cb(GObject * source_object, GAsyncResult * res,
     path = gtk_tree_row_reference_get_path(treeRef);
 
     if (path != NULL) {
-	gchar *rdns =
-	    g_resolver_lookup_by_address_finish(G_RESOLVER(source_object),
-						res, NULL);
-	if (rdns != NULL) {
-	    GtkTreeIter iter;
-	    if (gtk_tree_model_get_iter(model, &iter, path) == TRUE) {
-		gdk_threads_enter();
-		gtk_list_store_set(GTK_LIST_STORE(model), &iter,
-				   PEERSCOL_HOST, rdns, -1);
-		gdk_threads_leave();
-	    }
-	    g_free(rdns);
-	}
-	gtk_tree_path_free(path);
+        gchar *rdns =
+            g_resolver_lookup_by_address_finish(G_RESOLVER(source_object),
+                                                res, NULL);
+        if (rdns != NULL) {
+            GtkTreeIter iter;
+            if (gtk_tree_model_get_iter(model, &iter, path) == TRUE) {
+                gdk_threads_enter();
+                gtk_list_store_set(GTK_LIST_STORE(model), &iter,
+                                   PEERSCOL_HOST, rdns, -1);
+                gdk_threads_leave();
+            }
+            g_free(rdns);
+        }
+        gtk_tree_path_free(path);
     }
 
     gtk_tree_row_reference_free(treeRef);
 }
 
 void trg_peers_model_update(TrgPeersModel * model, TrgTreeView * tv,
-			    gint64 updateSerial, JsonObject * t, gint mode)
+                            gint64 updateSerial, JsonObject * t, gint mode)
 {
 #ifdef HAVE_GEOIP
     TrgPeersModelPrivate *priv = TRG_PEERS_MODEL_GET_PRIVATE(model);
     gboolean doGeoLookup =
-	trg_tree_view_is_column_showing(tv, PEERSCOL_COUNTRY);
+        trg_tree_view_is_column_showing(tv, PEERSCOL_COUNTRY);
 #endif
 
     gboolean doHostLookup =
-	trg_tree_view_is_column_showing(tv, PEERSCOL_HOST);
+        trg_tree_view_is_column_showing(tv, PEERSCOL_HOST);
     JsonArray *peers;
     GtkTreeIter peerIter;
     GList *li, *peersList;
@@ -141,79 +141,79 @@ void trg_peers_model_update(TrgPeersModel * model, TrgTreeView * tv,
     peers = torrent_get_peers(t);
 
     if (mode == TORRENT_GET_MODE_FIRST)
-	gtk_list_store_clear(GTK_LIST_STORE(model));
+        gtk_list_store_clear(GTK_LIST_STORE(model));
 
     peersList = json_array_get_elements(peers);
     for (li = peersList; li; li = g_list_next(li)) {
-	JsonObject *peer = json_node_get_object((JsonNode *) li->data);
-	const gchar *address = NULL, *flagStr;
+        JsonObject *peer = json_node_get_object((JsonNode *) li->data);
+        const gchar *address = NULL, *flagStr;
 #ifdef HAVE_GEOIP
-	const gchar *country = NULL;
+        const gchar *country = NULL;
 #endif
 
-	if (mode == TORRENT_GET_MODE_FIRST
-	    || find_existing_peer_item(model, peer, &peerIter) == FALSE) {
-	    gtk_list_store_append(GTK_LIST_STORE(model), &peerIter);
+        if (mode == TORRENT_GET_MODE_FIRST
+            || find_existing_peer_item(model, peer, &peerIter) == FALSE) {
+            gtk_list_store_append(GTK_LIST_STORE(model), &peerIter);
 
-	    address = peer_get_address(peer);
+            address = peer_get_address(peer);
 #ifdef HAVE_GEOIP
-	    if (address && doGeoLookup) {	// just in case address wasn't set
-		if (strchr(address, ':') && priv->geoipv6)
-		    country =
-			GeoIP_country_name_by_addr_v6(priv->geoipv6,
-						      address);
-		else if (priv->geoip)
-		    country =
-			GeoIP_country_name_by_addr(priv->geoip, address);
-	    }
+            if (address && doGeoLookup) {       // just in case address wasn't set
+                if (strchr(address, ':') && priv->geoipv6)
+                    country =
+                        GeoIP_country_name_by_addr_v6(priv->geoipv6,
+                                                      address);
+                else if (priv->geoip)
+                    country =
+                        GeoIP_country_name_by_addr(priv->geoip, address);
+            }
 #endif
-	    gtk_list_store_set(GTK_LIST_STORE(model), &peerIter,
-			       PEERSCOL_ICON, GTK_STOCK_NETWORK,
-			       PEERSCOL_IP, address,
+            gtk_list_store_set(GTK_LIST_STORE(model), &peerIter,
+                               PEERSCOL_ICON, GTK_STOCK_NETWORK,
+                               PEERSCOL_IP, address,
 #ifdef HAVE_GEOIP
-			       PEERSCOL_COUNTRY, country ? country : "",
+                               PEERSCOL_COUNTRY, country ? country : "",
 #endif
-			       PEERSCOL_CLIENT, peer_get_client_name(peer),
-			       -1);
-
-	    isNew = TRUE;
-	} else {
-	    isNew = FALSE;
-	}
-
-	flagStr = peer_get_flagstr(peer);
-	gtk_list_store_set(GTK_LIST_STORE(model), &peerIter,
-			   PEERSCOL_FLAGS, flagStr, PEERSCOL_PROGRESS,
-			   peer_get_progress(peer), PEERSCOL_DOWNSPEED,
-			   peer_get_rate_to_client(peer), PEERSCOL_UPSPEED,
-			   peer_get_rate_to_peer(peer),
-			   PEERSCOL_UPDATESERIAL, updateSerial, -1);
-
-	if (doHostLookup && isNew == TRUE) {
-	    GtkTreePath *path =
-		gtk_tree_model_get_path(GTK_TREE_MODEL(model),
-					&peerIter);
-	    GtkTreeRowReference *treeRef =
-		gtk_tree_row_reference_new(GTK_TREE_MODEL(model), path);
-	    GInetAddress *inetAddr;
-	    GResolver *resolver;
-
-	    gtk_tree_path_free(path);
-
-	    inetAddr = g_inet_address_new_from_string(address);
-	    resolver = g_resolver_get_default();
-	    g_resolver_lookup_by_address_async(resolver, inetAddr, NULL,
-					       resolved_dns_cb, treeRef);
-	    g_object_unref(resolver);
-	    g_object_unref(inetAddr);
-	}
+                               PEERSCOL_CLIENT, peer_get_client_name(peer),
+                               -1);
+
+            isNew = TRUE;
+        } else {
+            isNew = FALSE;
+        }
+
+        flagStr = peer_get_flagstr(peer);
+        gtk_list_store_set(GTK_LIST_STORE(model), &peerIter,
+                           PEERSCOL_FLAGS, flagStr, PEERSCOL_PROGRESS,
+                           peer_get_progress(peer), PEERSCOL_DOWNSPEED,
+                           peer_get_rate_to_client(peer), PEERSCOL_UPSPEED,
+                           peer_get_rate_to_peer(peer),
+                           PEERSCOL_UPDATESERIAL, updateSerial, -1);
+
+        if (doHostLookup && isNew == TRUE) {
+            GtkTreePath *path =
+                gtk_tree_model_get_path(GTK_TREE_MODEL(model),
+                                        &peerIter);
+            GtkTreeRowReference *treeRef =
+                gtk_tree_row_reference_new(GTK_TREE_MODEL(model), path);
+            GInetAddress *inetAddr;
+            GResolver *resolver;
+
+            gtk_tree_path_free(path);
+
+            inetAddr = g_inet_address_new_from_string(address);
+            resolver = g_resolver_get_default();
+            g_resolver_lookup_by_address_async(resolver, inetAddr, NULL,
+                                               resolved_dns_cb, treeRef);
+            g_object_unref(resolver);
+            g_object_unref(inetAddr);
+        }
     }
 
     g_list_free(peersList);
 
     if (mode != TORRENT_GET_MODE_FIRST)
-	trg_model_remove_removed(GTK_LIST_STORE(model),
-				 PEERSCOL_UPDATESERIAL, updateSerial);
+        trg_model_remove_removed(GTK_LIST_STORE(model),
+                                 PEERSCOL_UPDATESERIAL, updateSerial);
 }
 
 static void trg_peers_model_init(TrgPeersModel * self)
@@ -238,15 +238,15 @@ static void trg_peers_model_init(TrgPeersModel * self)
     column_types[PEERSCOL_UPDATESERIAL] = G_TYPE_INT64;
 
     gtk_list_store_set_column_types(GTK_LIST_STORE(self), PEERSCOL_COLUMNS,
-				    column_types);
+                                    column_types);
 
 #ifdef HAVE_GEOIP
     if (g_file_test(TRG_GEOIP_DATABASE, G_FILE_TEST_EXISTS) == TRUE)
-	priv->geoip = GeoIP_open(TRG_GEOIP_DATABASE,
-				 GEOIP_STANDARD | GEOIP_CHECK_CACHE);
+        priv->geoip = GeoIP_open(TRG_GEOIP_DATABASE,
+                                 GEOIP_STANDARD | GEOIP_CHECK_CACHE);
     if (g_file_test(TRG_GEOIPV6_DATABASE, G_FILE_TEST_EXISTS) == TRUE)
-	priv->geoipv6 = GeoIP_open(TRG_GEOIPV6_DATABASE,
-				   GEOIP_STANDARD | GEOIP_CHECK_CACHE);
+        priv->geoipv6 = GeoIP_open(TRG_GEOIPV6_DATABASE,
+                                   GEOIP_STANDARD | GEOIP_CHECK_CACHE);
 #endif
 }