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, 142 insertions, 76 deletions

diff --git a/src/trg-client.c b/src/trg-client.c
index 0b1d1f6..cdb018f 100644
--- a/src/trg-client.c
+++ b/src/trg-client.c
@@ -89,10 +89,12 @@ struct _TrgClientPrivate {
     GMutex *configMutex;
 };
 
-static void dispatch_async_threadfunc(trg_request * reqrsp, TrgClient * client);
+static void dispatch_async_threadfunc(trg_request * reqrsp,
+                                      TrgClient * client);
 
 static void trg_client_get_property(GObject * object, guint property_id,
-        GValue * value, GParamSpec * pspec) {
+                                    GValue * value, GParamSpec * pspec)
+{
     switch (property_id) {
     default:
         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
@@ -101,7 +103,9 @@ static void trg_client_get_property(GObject * object, guint property_id,
 }
 
 static void trg_client_set_property(GObject * object, guint property_id,
-        const GValue * value, GParamSpec * pspec) {
+                                    const GValue * value,
+                                    GParamSpec * pspec)
+{
     switch (property_id) {
     default:
         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
@@ -109,11 +113,13 @@ static void trg_client_set_property(GObject * object, guint property_id,
     }
 }
 
-static void trg_client_dispose(GObject * object) {
+static void trg_client_dispose(GObject * object)
+{
     G_OBJECT_CLASS(trg_client_parent_class)->dispose(object);
 }
 
-static void trg_client_class_init(TrgClientClass * klass) {
+static void trg_client_class_init(TrgClientClass * klass)
+{
     GObjectClass *object_class = G_OBJECT_CLASS(klass);
 
     g_type_class_add_private(klass, sizeof(TrgClientPrivate));
@@ -123,16 +129,25 @@ static void trg_client_class_init(TrgClientClass * klass) {
     object_class->dispose = trg_client_dispose;
 
     signals[TC_SESSION_UPDATED] = g_signal_new("session-updated",
-            G_TYPE_FROM_CLASS(object_class),
-            G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET(TrgClientClass,
-                    session_updated), 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
+                                               (TrgClientClass,
+                                                session_updated), NULL,
+                                               NULL,
+                                               g_cclosure_marshal_VOID__POINTER,
+                                               G_TYPE_NONE, 1,
+                                               G_TYPE_POINTER);
 }
 
-static void trg_client_init(TrgClient * self) {
+static void trg_client_init(TrgClient * self)
+{
 }
 
-TrgClient *trg_client_new(void) {
+TrgClient *trg_client_new(void)
+{
     TrgClient *tc = g_object_new(TRG_TYPE_CLIENT, NULL);
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     TrgPrefs *prefs = priv->prefs = trg_prefs_new();
@@ -144,37 +159,42 @@ TrgClient *trg_client_new(void) {
     priv->tlsKey = g_private_new(NULL);
 
     priv->pool = g_thread_pool_new((GFunc) dispatch_async_threadfunc, tc,
-            DISPATCH_POOL_SIZE, TRUE, NULL);
+                                   DISPATCH_POOL_SIZE, TRUE, NULL);
 
-    tr_formatter_size_init(disk_K, _(disk_K_str), _(disk_M_str), _(disk_G_str),
-            _(disk_T_str));
+    tr_formatter_size_init(disk_K, _(disk_K_str), _(disk_M_str),
+                           _(disk_G_str), _(disk_T_str));
     tr_formatter_speed_init(speed_K, _(speed_K_str), _(speed_M_str),
-            _(speed_G_str), _(speed_T_str));
+                            _(speed_G_str), _(speed_T_str));
 
     return tc;
 }
 
-const gchar *trg_client_get_version_string(TrgClient * tc) {
+const gchar *trg_client_get_version_string(TrgClient * tc)
+{
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     return session_get_version_string(priv->session);
 }
 
-float trg_client_get_version(TrgClient * tc) {
+float trg_client_get_version(TrgClient * tc)
+{
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     return priv->version;
 }
 
-gint64 trg_client_get_rpc_version(TrgClient * tc) {
+gint64 trg_client_get_rpc_version(TrgClient * tc)
+{
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     return session_get_rpc_version(priv->session);
 }
 
-void trg_client_inc_connid(TrgClient * tc) {
+void trg_client_inc_connid(TrgClient * tc)
+{
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     g_atomic_int_inc(&priv->connid);
 }
 
-void trg_client_set_session(TrgClient * tc, JsonObject * session) {
+void trg_client_set_session(TrgClient * tc, JsonObject * session)
+{
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
 
     if (priv->session) {
@@ -189,12 +209,14 @@ void trg_client_set_session(TrgClient * tc, JsonObject * session) {
     g_signal_emit(tc, signals[TC_SESSION_UPDATED], 0, session);
 }
 
-TrgPrefs *trg_client_get_prefs(TrgClient * tc) {
+TrgPrefs *trg_client_get_prefs(TrgClient * tc)
+{
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     return priv->prefs;
 }
 
-int trg_client_populate_with_settings(TrgClient * tc) {
+int trg_client_populate_with_settings(TrgClient * tc)
+{
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     TrgPrefs *prefs = priv->prefs;
 
@@ -217,33 +239,34 @@ int trg_client_populate_with_settings(TrgClient * tc) {
     g_free(priv->password);
     priv->password = NULL;
 
-    port = trg_prefs_get_int(prefs, TRG_PREFS_KEY_PORT, TRG_PREFS_CONNECTION);
+    port =
+        trg_prefs_get_int(prefs, TRG_PREFS_KEY_PORT, TRG_PREFS_CONNECTION);
 
     host = trg_prefs_get_string(prefs, TRG_PREFS_KEY_HOSTNAME,
-            TRG_PREFS_CONNECTION);
+                                TRG_PREFS_CONNECTION);
     if (!host || strlen(host) < 1) {
         g_free(host);
         g_mutex_unlock(priv->configMutex);
         return TRG_NO_HOSTNAME_SET;
     }
-
 #ifndef CURL_NO_SSL
     priv->ssl = trg_prefs_get_bool(prefs, TRG_PREFS_KEY_SSL,
-            TRG_PREFS_CONNECTION);
+                                   TRG_PREFS_CONNECTION);
 #else
     priv->ssl = FALSE;
 #endif
 
     priv->url = g_strdup_printf("%s://%s:%d/transmission/rpc",
-            priv->ssl ? HTTPS_URI_PREFIX : HTTP_URI_PREFIX,
-            host, port);
+                                priv->
+                                ssl ? HTTPS_URI_PREFIX : HTTP_URI_PREFIX,
+                                host, port);
     g_free(host);
 
     priv->username = trg_prefs_get_string(prefs, TRG_PREFS_KEY_USERNAME,
-            TRG_PREFS_CONNECTION);
+                                          TRG_PREFS_CONNECTION);
 
     priv->password = trg_prefs_get_string(prefs, TRG_PREFS_KEY_PASSWORD,
-            TRG_PREFS_CONNECTION);
+                                          TRG_PREFS_CONNECTION);
 
     g_free(priv->proxy);
     priv->proxy = NULL;
@@ -272,27 +295,32 @@ int trg_client_populate_with_settings(TrgClient * tc) {
     return 0;
 }
 
-gchar *trg_client_get_password(TrgClient * tc) {
+gchar *trg_client_get_password(TrgClient * tc)
+{
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     return priv->password;
 }
 
-gchar *trg_client_get_username(TrgClient * tc) {
+gchar *trg_client_get_username(TrgClient * tc)
+{
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     return priv->username;
 }
 
-gchar *trg_client_get_url(TrgClient * tc) {
+gchar *trg_client_get_url(TrgClient * tc)
+{
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     return priv->url;
 }
 
-gchar *trg_client_get_session_id(TrgClient * tc) {
+gchar *trg_client_get_session_id(TrgClient * tc)
+{
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     return priv->session_id ? g_strdup(priv->session_id) : NULL;
 }
 
-void trg_client_set_session_id(TrgClient * tc, gchar * session_id) {
+void trg_client_set_session_id(TrgClient * tc, gchar * session_id)
+{
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
 
     g_mutex_lock(priv->configMutex);
@@ -305,111 +333,132 @@ void trg_client_set_session_id(TrgClient * tc, gchar * session_id) {
     g_mutex_unlock(priv->configMutex);
 }
 
-void trg_client_status_change(TrgClient * tc, gboolean connected) {
+void trg_client_status_change(TrgClient * tc, gboolean connected)
+{
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
 
     if (!connected) {
         if (priv->session) {
             json_object_unref(priv->session);
             priv->session = NULL;
-        }g_mutex_lock(priv->configMutex);
+        }
+        g_mutex_lock(priv->configMutex);
         trg_prefs_set_connection(priv->prefs, NULL);
         g_mutex_unlock(priv->configMutex);
     }
 }
 
-JsonObject *trg_client_get_session(TrgClient * tc) {
+JsonObject *trg_client_get_session(TrgClient * tc)
+{
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     return priv->session;
 }
 
-void trg_client_thread_pool_push(TrgClient * tc, gpointer data, GError ** err) {
+void trg_client_thread_pool_push(TrgClient * tc, gpointer data,
+                                 GError ** err)
+{
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     g_thread_pool_push(priv->pool, data, err);
 }
 
-void trg_client_inc_serial(TrgClient * tc) {
+void trg_client_inc_serial(TrgClient * tc)
+{
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     priv->updateSerial++;
 }
 
-gint64 trg_client_get_serial(TrgClient * tc) {
+gint64 trg_client_get_serial(TrgClient * tc)
+{
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     return priv->updateSerial;
 }
 
 #ifndef CURL_NO_SSL
-gboolean trg_client_get_ssl(TrgClient * tc) {
+gboolean trg_client_get_ssl(TrgClient * tc)
+{
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     return priv->ssl;
 }
 #endif
 
-gchar *trg_client_get_proxy(TrgClient * tc) {
+gchar *trg_client_get_proxy(TrgClient * tc)
+{
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     return priv->proxy;
 }
 
-void trg_client_set_torrent_table(TrgClient * tc, GHashTable * table) {
+void trg_client_set_torrent_table(TrgClient * tc, GHashTable * table)
+{
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     priv->torrentTable = table;
 }
 
-GHashTable *trg_client_get_torrent_table(TrgClient * tc) {
+GHashTable *trg_client_get_torrent_table(TrgClient * tc)
+{
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     return priv->torrentTable;
 }
 
-gboolean trg_client_is_connected(TrgClient * tc) {
+gboolean trg_client_is_connected(TrgClient * tc)
+{
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     return priv->session != NULL;
 }
 
-void trg_client_updatelock(TrgClient * tc) {
+void trg_client_updatelock(TrgClient * tc)
+{
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     g_mutex_lock(priv->updateMutex);
 }
 
-void trg_client_configlock(TrgClient * tc) {
+void trg_client_configlock(TrgClient * tc)
+{
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     g_mutex_lock(priv->configMutex);
 }
 
-guint trg_client_get_failcount(TrgClient * tc) {
+guint trg_client_get_failcount(TrgClient * tc)
+{
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     return priv->failCount;
 }
 
-guint trg_client_inc_failcount(TrgClient * tc) {
+guint trg_client_inc_failcount(TrgClient * tc)
+{
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     return ++(priv->failCount);
 }
 
-void trg_client_reset_failcount(TrgClient * tc) {
+void trg_client_reset_failcount(TrgClient * tc)
+{
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     priv->failCount = 0;
 }
 
-void trg_client_updateunlock(TrgClient * tc) {
+void trg_client_updateunlock(TrgClient * tc)
+{
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     g_mutex_unlock(priv->updateMutex);
 }
 
-void trg_client_configunlock(TrgClient * tc) {
+void trg_client_configunlock(TrgClient * tc)
+{
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     g_mutex_unlock(priv->configMutex);
 }
 
 /* formerly http.c */
 
-void trg_response_free(trg_response * response) {
+void trg_response_free(trg_response * response)
+{
     if (response->obj)
         json_object_unref(response->obj);
     g_free(response);
 }
 
 static size_t http_receive_callback(void *ptr, size_t size, size_t nmemb,
-        void *data) {
+                                    void *data)
+{
     size_t realsize = size * nmemb;
     trg_response *mem = (trg_response *) data;
 
@@ -423,7 +472,9 @@ static size_t http_receive_callback(void *ptr, size_t size, size_t nmemb,
     return realsize;
 }
 
-static size_t header_callback(void *ptr, size_t size, size_t nmemb, void *data) {
+static size_t header_callback(void *ptr, size_t size, size_t nmemb,
+                              void *data)
+{
     char *header = (char *) (ptr);
     TrgClient *tc = TRG_CLIENT(data);
     gchar *session_id;
@@ -442,11 +493,14 @@ static size_t header_callback(void *ptr, size_t size, size_t nmemb, void *data)
     return (nmemb * size);
 }
 
-static void trg_tls_update(TrgClient * tc, trg_tls * tls, gint serial) {
+static void trg_tls_update(TrgClient * tc, trg_tls * tls, gint serial)
+{
     gchar *proxy;
 
-    curl_easy_setopt(tls->curl, CURLOPT_PASSWORD, trg_client_get_password(tc));
-    curl_easy_setopt(tls->curl, CURLOPT_USERNAME, trg_client_get_username(tc));
+    curl_easy_setopt(tls->curl, CURLOPT_PASSWORD,
+                     trg_client_get_password(tc));
+    curl_easy_setopt(tls->curl, CURLOPT_USERNAME,
+                     trg_client_get_username(tc));
     curl_easy_setopt(tls->curl, CURLOPT_URL, trg_client_get_url(tc));
 
 #ifndef CURL_NO_SSL
@@ -463,13 +517,15 @@ static void trg_tls_update(TrgClient * tc, trg_tls * tls, gint serial) {
     tls->serial = serial;
 }
 
-trg_tls *trg_tls_new(TrgClient * tc) {
+trg_tls *trg_tls_new(TrgClient * tc)
+{
     trg_tls *tls = g_new0(trg_tls, 1);
 
     tls->curl = curl_easy_init();
     curl_easy_setopt(tls->curl, CURLOPT_USERAGENT, PACKAGE_NAME);
     curl_easy_setopt(tls->curl, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
-    curl_easy_setopt(tls->curl, CURLOPT_WRITEFUNCTION, &http_receive_callback);
+    curl_easy_setopt(tls->curl, CURLOPT_WRITEFUNCTION,
+                     &http_receive_callback);
     curl_easy_setopt(tls->curl, CURLOPT_HEADERFUNCTION, &header_callback);
     curl_easy_setopt(tls->curl, CURLOPT_WRITEHEADER, (void *) tc);
 
@@ -479,7 +535,9 @@ trg_tls *trg_tls_new(TrgClient * tc) {
 }
 
 static int trg_http_perform_inner(TrgClient * tc, gchar * reqstr,
-        trg_response * response, gboolean recurse) {
+                                  trg_response * response,
+                                  gboolean recurse)
+{
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     TrgPrefs *prefs = trg_client_get_prefs(tc);
     gpointer threadLocalStorage = g_private_get(priv->tlsKey);
@@ -507,7 +565,8 @@ static int trg_http_perform_inner(TrgClient * tc, gchar * reqstr,
     }
 
     curl_easy_setopt(tls->curl, CURLOPT_TIMEOUT,
-            (long)trg_prefs_get_int(prefs, TRG_PREFS_KEY_TIMEOUT, TRG_PREFS_CONNECTION));
+                     (long) trg_prefs_get_int(prefs, TRG_PREFS_KEY_TIMEOUT,
+                                              TRG_PREFS_CONNECTION));
 
     g_mutex_unlock(priv->configMutex);
 
@@ -526,34 +585,35 @@ static int trg_http_perform_inner(TrgClient * tc, gchar * reqstr,
     curl_easy_getinfo(tls->curl, CURLINFO_RESPONSE_CODE, &httpCode);
 
     if (response->status == CURLE_OK) {
-        if (httpCode == HTTP_CONFLICT && recurse == TRUE
-            )
+        if (httpCode == HTTP_CONFLICT && recurse == TRUE)
             return trg_http_perform_inner(tc, reqstr, response, FALSE);
-        else if (httpCode != HTTP_OK
-            )
+        else if (httpCode != HTTP_OK)
             response->status = (-httpCode) - 100;
     }
 
     return response->status;
 }
 
-int trg_http_perform(TrgClient * tc, gchar * reqstr, trg_response * reqrsp) {
+int trg_http_perform(TrgClient * tc, gchar * reqstr, trg_response * reqrsp)
+{
     return trg_http_perform_inner(tc, reqstr, reqrsp, TRUE);
 }
 
 /* formerly dispatch.c */
 
-trg_response *dispatch(TrgClient * client, JsonNode * req) {
+trg_response *dispatch(TrgClient * client, JsonNode * req)
+{
     gchar *serialized = trg_serialize(req);
     json_node_free(req);
 #ifdef DEBUG
     if (g_getenv("TRG_SHOW_OUTGOING"))
-    g_debug("=>(OUTgoing)=>: %s", serialized);
+        g_debug("=>(OUTgoing)=>: %s", serialized);
 #endif
     return dispatch_str(client, serialized);
 }
 
-trg_response *dispatch_str(TrgClient * client, gchar * req) {
+trg_response *dispatch_str(TrgClient * client, gchar * req)
+{
     trg_response *response = g_new0(trg_response, 1);
     GError *decode_error = NULL;
     JsonNode *result;
@@ -582,7 +642,9 @@ trg_response *dispatch_str(TrgClient * client, gchar * req) {
     return response;
 }
 
-static void dispatch_async_threadfunc(trg_request * req, TrgClient * client) {
+static void dispatch_async_threadfunc(trg_request * req,
+                                      TrgClient * client)
+{
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(client);
 
     trg_response *rsp;
@@ -603,8 +665,10 @@ static void dispatch_async_threadfunc(trg_request * req, TrgClient * client) {
     g_free(req);
 }
 
-static gboolean dispatch_async_common(TrgClient * client, trg_request * trg_req,
-        GSourceFunc callback, gpointer data) {
+static gboolean dispatch_async_common(TrgClient * client,
+                                      trg_request * trg_req,
+                                      GSourceFunc callback, gpointer data)
+{
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(client);
     GError *error = NULL;
 
@@ -624,7 +688,8 @@ static gboolean dispatch_async_common(TrgClient * client, trg_request * trg_req,
 }
 
 gboolean dispatch_async(TrgClient * client, JsonNode * req,
-        GSourceFunc callback, gpointer data) {
+                        GSourceFunc callback, gpointer data)
+{
     trg_request *trg_req = g_new0(trg_request, 1);
     trg_req->node = req;
 
@@ -632,7 +697,8 @@ gboolean dispatch_async(TrgClient * client, JsonNode * req,
 }
 
 gboolean dispatch_async_str(TrgClient * client, gchar * req,
-        GSourceFunc callback, gpointer data) {
+                            GSourceFunc callback, gpointer data)
+{
     trg_request *trg_req = g_new0(trg_request, 1);
     trg_req->str = req;