From 24195d0013f81933578afa14a44a10e4b75817dd Mon Sep 17 00:00:00 2001 From: Alan Fitton Date: Sun, 11 Dec 2011 14:48:11 +0000 Subject: a few more appindicator fixes and reindent trg-main-window.c --- Makefile.am | 19 + configure.ac | 19 + src/Makefile.am | 19 + src/trg-main-window.c | 2173 ++++++++++++++++++++++++++++--------------------- 4 files changed, 1323 insertions(+), 907 deletions(-) diff --git a/Makefile.am b/Makefile.am index 4c92f22..137915e 100644 --- a/Makefile.am +++ b/Makefile.am @@ -1,3 +1,22 @@ +# +# transmission-remote-gtk - A GTK RPC client to Transmission +# Copyright (C) 2011 Alan Fitton + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +# + ACLOCAL_AMFLAGS = -I m4 AUTOMAKE_OPTIONS = foreign SUBDIRS = src po diff --git a/configure.ac b/configure.ac index 3a2d7e5..7a30dec 100644 --- a/configure.ac +++ b/configure.ac @@ -1,3 +1,22 @@ +dnl +dnl transmission-remote-gtk - A GTK RPC client to Transmission +dnl Copyright (C) 2011 Alan Fitton + +dnl This program is free software; you can redistribute it and/or modify +dnl it under the terms of the GNU General Public License as published by +dnl the Free Software Foundation; either version 2 of the License, or +dnl (at your option) any later version. + +dnl This program is distributed in the hope that it will be useful, +dnl but WITHOUT ANY WARRANTY; without even the implied warranty of +dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +dnl GNU General Public License for more details. + +dnl You should have received a copy of the GNU General Public License along +dnl with this program; if not, write to the Free Software Foundation, Inc., +dnl 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +dnl + AC_PREREQ(2.63) AC_INIT(transmission-remote-gtk, 0.8, alan@eth0.org.uk) diff --git a/src/Makefile.am b/src/Makefile.am index 7e16160..7345485 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -1,3 +1,22 @@ +# +# transmission-remote-gtk - A GTK RPC client to Transmission +# Copyright (C) 2011 Alan Fitton + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +# + NULL = public_icons_themes = \ diff --git a/src/trg-main-window.c b/src/trg-main-window.c index 6c72c3d..95cd703 100644 --- a/src/trg-main-window.c +++ b/src/trg-main-window.c @@ -31,7 +31,7 @@ #include #include #include -#if GTK_CHECK_VERSION( 3,0, 0 ) +#if GTK_CHECK_VERSION( 3, 0, 0 ) #include #endif #include @@ -81,23 +81,31 @@ /* The rather large main window class, which glues everything together. */ -static void update_selected_torrent_notebook(TrgMainWindow * win, gint mode, - gint64 id); +static void update_selected_torrent_notebook(TrgMainWindow * win, + gint mode, gint64 id); #ifdef HAVE_LIBNOTIFY -static void torrent_event_notification(TrgTorrentModel * model, gchar * icon, - gchar * desc, gint tmout, gchar * prefKey, GtkTreeIter * iter, - gpointer data); +static void torrent_event_notification(TrgTorrentModel * model, + gchar * icon, gchar * desc, + gint tmout, gchar * prefKey, + GtkTreeIter * iter, gpointer data); #endif -static void connchange_whatever_statusicon(TrgMainWindow *win, gboolean connected); -static void update_whatever_statusicon(TrgMainWindow *win, const gchar *speedLabel, trg_torrent_model_update_stats *stats); -static void on_torrent_completed(TrgTorrentModel * model, GtkTreeIter * iter, - gpointer data); +static void connchange_whatever_statusicon(TrgMainWindow * win, + gboolean connected); +static void update_whatever_statusicon(TrgMainWindow * win, + const gchar * speedLabel, + trg_torrent_model_update_stats * + stats); +static void on_torrent_completed(TrgTorrentModel * model, + GtkTreeIter * iter, gpointer data); static void on_torrent_added(TrgTorrentModel * model, GtkTreeIter * iter, - gpointer data); -static gboolean delete_event(GtkWidget * w, GdkEvent * event, gpointer data); + gpointer data); +static gboolean delete_event(GtkWidget * w, GdkEvent * event, + gpointer data); static void destroy_window(GtkWidget * w, gpointer data); static void torrent_tv_onRowActivated(GtkTreeView * treeview, - GtkTreePath * path, GtkTreeViewColumn * col, gpointer userdata); + GtkTreePath * path, + GtkTreeViewColumn * col, + gpointer userdata); static void add_url_cb(GtkWidget * w, gpointer data); static void add_cb(GtkWidget * w, gpointer data); static void disconnect_cb(GtkWidget * w, gpointer data); @@ -115,8 +123,10 @@ static void move_cb(GtkWidget * w, gpointer data); static void delete_cb(GtkWidget * w, gpointer data); static void open_props_cb(GtkWidget * w, gpointer data); static gint confirm_action_dialog(GtkWindow * win, - GtkTreeSelection * selection, gchar * question_single, - gchar * question_multi, gchar * action_stock); + GtkTreeSelection * selection, + gchar * question_single, + gchar * question_multi, + gchar * action_stock); static void view_stats_toggled_cb(GtkWidget * w, gpointer data); static void view_states_toggled_cb(GtkCheckMenuItem * w, gpointer data); static void view_notebook_toggled_cb(GtkCheckMenuItem * w, gpointer data); @@ -130,55 +140,67 @@ static gboolean on_torrent_get_interactive(gpointer data); static gboolean trg_update_torrents_timerfunc(gpointer data); static void open_about_cb(GtkWidget * w, GtkWindow * parent); static gboolean trg_torrent_tree_view_visible_func(GtkTreeModel * model, - GtkTreeIter * iter, gpointer data); -static TrgTorrentTreeView -* trg_main_window_torrent_tree_view_new(TrgMainWindow * win, - GtkTreeModel * model); + GtkTreeIter * iter, + gpointer data); +static TrgTorrentTreeView * +trg_main_window_torrent_tree_view_new(TrgMainWindow * win, + GtkTreeModel * model); static gboolean trg_dialog_error_handler(TrgMainWindow * win, - trg_response *response); + trg_response * response); static gboolean torrent_selection_changed(GtkTreeSelection * selection, - gpointer data); + gpointer data); static void trg_main_window_torrent_scrub(TrgMainWindow * win); static void entry_filter_changed_cb(GtkWidget * w, gpointer data); static void torrent_state_selection_changed(TrgStateSelector * selector, - guint flag, gpointer data); + guint flag, gpointer data); static void trg_main_window_conn_changed(TrgMainWindow * win, - gboolean connected); -static void trg_main_window_get_property(GObject * object, guint property_id, - GValue * value, GParamSpec * pspec); -static void trg_main_window_set_property(GObject * object, guint property_id, - const GValue * value, GParamSpec * pspec); + gboolean connected); +static void trg_main_window_get_property(GObject * object, + guint property_id, GValue * value, + GParamSpec * pspec); +static void trg_main_window_set_property(GObject * object, + guint property_id, + const GValue * value, + GParamSpec * pspec); static void quit_cb(GtkWidget * w, gpointer data); static TrgMenuBar *trg_main_window_menu_bar_new(TrgMainWindow * win); #ifndef HAVE_LIBAPPINDICATOR static void status_icon_activated(GtkStatusIcon * icon, gpointer data); static gboolean trg_status_icon_popup_menu_cb(GtkStatusIcon * icon, - gpointer userdata); + gpointer userdata); static gboolean status_icon_button_press_event(GtkStatusIcon * icon, - GdkEventButton * event, gpointer data); + GdkEventButton * event, + gpointer data); #endif -static void clear_filter_entry_cb(GtkEntry *entry, - GtkEntryIconPosition icon_pos, - GdkEvent *event, - gpointer user_data); -static gboolean torrent_tv_key_press_event(GtkWidget * w, GdkEventKey * key, - gpointer data); -static GtkWidget *trg_imagemenuitem_new(GtkMenuShell * shell, const gchar *text, - char *stock_id, gboolean sensitive, GCallback cb, gpointer cbdata); +static void clear_filter_entry_cb(GtkEntry * entry, + GtkEntryIconPosition icon_pos, + GdkEvent * event, gpointer user_data); +static gboolean torrent_tv_key_press_event(GtkWidget * w, + GdkEventKey * key, + gpointer data); +static GtkWidget *trg_imagemenuitem_new(GtkMenuShell * shell, + const gchar * text, char *stock_id, + gboolean sensitive, GCallback cb, + gpointer cbdata); static void set_limit_cb(GtkWidget * w, gpointer data); static GtkWidget *limit_item_new(TrgMainWindow * win, GtkWidget * menu, - gint64 currentLimit, gfloat limit); + gint64 currentLimit, gfloat limit); static GtkWidget *limit_menu_new(TrgMainWindow * win, gchar * title, - gchar * enabledKey, gchar * speedKey, JsonArray * ids); + gchar * enabledKey, gchar * speedKey, + JsonArray * ids); static void trg_torrent_tv_view_menu(GtkWidget * treeview, - GdkEventButton * event, gpointer data); -static GtkMenu *trg_status_icon_view_menu(TrgMainWindow *win, const gchar *msg); + GdkEventButton * event, + gpointer data); +static GtkMenu *trg_status_icon_view_menu(TrgMainWindow * win, + const gchar * msg); static gboolean torrent_tv_button_pressed_cb(GtkWidget * treeview, - GdkEventButton * event, gpointer userdata); + GdkEventButton * event, + gpointer userdata); static gboolean torrent_tv_popup_menu_cb(GtkWidget * treeview, - gpointer userdata); + gpointer userdata); static gboolean window_state_event(GtkWidget * widget, - GdkEventWindowState * event, gpointer trayIcon); + GdkEventWindowState * event, + gpointer trayIcon); G_DEFINE_TYPE(TrgMainWindow, trg_main_window, GTK_TYPE_WINDOW) #define TRG_MAIN_WINDOW_GET_PRIVATE(o) \ @@ -193,7 +215,8 @@ struct _TrgMainWindowPrivate { TrgStatusBar *statusBar; #ifdef HAVE_LIBAPPINDICATOR AppIndicator *appIndicator; - GtkWidget *appIndicatorStatusItem; + GtkWidget *appIndicatorStatusItem, *appIndicatorDownloadingItem, + *appIndicatorSeedingItem, *appIndicatorSepItem; #else GtkStatusIcon *statusIcon; #endif @@ -242,74 +265,83 @@ static void reset_connect_args(TrgMainWindow * win) { TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win); if (priv->args) { - g_strfreev(priv->args); - priv->args = NULL; + g_strfreev(priv->args); + priv->args = NULL; } } -static void trg_main_window_init(TrgMainWindow * self G_GNUC_UNUSED) { +static void trg_main_window_init(TrgMainWindow * self G_GNUC_UNUSED) +{ } -GtkTreeModel *trg_main_window_get_torrent_model(TrgMainWindow * win) { +GtkTreeModel *trg_main_window_get_torrent_model(TrgMainWindow * win) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win); return GTK_TREE_MODEL(priv->torrentModel); } -gint trg_mw_get_selected_torrent_id(TrgMainWindow * win) { +gint trg_mw_get_selected_torrent_id(TrgMainWindow * win) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win); return priv->selectedTorrentId; } -static void update_selected_torrent_notebook(TrgMainWindow * win, gint mode, - gint64 id) { +static void update_selected_torrent_notebook(TrgMainWindow * win, + gint mode, gint64 id) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win); TrgClient *client = priv->client; JsonObject *t; GtkTreeIter iter; - if (id >= 0 && get_torrent_data(trg_client_get_torrent_table(client), id, - &t, &iter)) { - trg_toolbar_torrent_actions_sensitive(priv->toolBar, TRUE); - trg_menu_bar_torrent_actions_sensitive(priv->menuBar, TRUE); - trg_general_panel_update(priv->genDetails, t, &iter); - trg_trackers_model_update(priv->trackersModel, - trg_client_get_serial(client), t, mode); - trg_files_model_update(priv->filesModel, trg_client_get_serial(client), - t, mode); - trg_peers_model_update(priv->peersModel, TRG_TREE_VIEW(priv->peersTreeView), trg_client_get_serial(client), - t, mode); + if (id >= 0 + && get_torrent_data(trg_client_get_torrent_table(client), id, &t, + &iter)) { + trg_toolbar_torrent_actions_sensitive(priv->toolBar, TRUE); + trg_menu_bar_torrent_actions_sensitive(priv->menuBar, TRUE); + trg_general_panel_update(priv->genDetails, t, &iter); + trg_trackers_model_update(priv->trackersModel, + trg_client_get_serial(client), t, mode); + trg_files_model_update(priv->filesModel, + trg_client_get_serial(client), t, mode); + trg_peers_model_update(priv->peersModel, + TRG_TREE_VIEW(priv->peersTreeView), + trg_client_get_serial(client), t, mode); } else if (id < 0) { - trg_main_window_torrent_scrub(win); + trg_main_window_torrent_scrub(win); } priv->selectedTorrentId = id; } #ifdef HAVE_LIBNOTIFY -static void torrent_event_notification(TrgTorrentModel * model, gchar * icon, - gchar * desc, gint tmout, gchar * prefKey, GtkTreeIter * iter, - gpointer data) { +static void torrent_event_notification(TrgTorrentModel * model, + gchar * icon, gchar * desc, + gint tmout, gchar * prefKey, + GtkTreeIter * iter, gpointer data) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data); TrgPrefs *prefs = trg_client_get_prefs(priv->client); gchar *name; NotifyNotification *notify; if (!trg_prefs_get_bool(prefs, prefKey, TRG_PREFS_NOFLAGS)) - return; + return; - gtk_tree_model_get(GTK_TREE_MODEL(model), iter, TORRENT_COLUMN_NAME, &name, - -1); + gtk_tree_model_get(GTK_TREE_MODEL(model), iter, TORRENT_COLUMN_NAME, + &name, -1); notify = notify_notification_new(name, desc, icon #if !defined(NOTIFY_VERSION_MINOR) || (NOTIFY_VERSION_MAJOR == 0 && NOTIFY_VERSION_MINOR < 7) - , NULL + , NULL #endif - ); + ); #ifndef HAVE_LIBAPPINDICATOR #if !defined(NOTIFY_VERSION_MINOR) || (NOTIFY_VERSION_MAJOR == 0 && NOTIFY_VERSION_MINOR < 7) -if (priv->statusIcon && gtk_status_icon_is_embedded(priv->statusIcon)) - notify_notification_attach_to_status_icon(notify, priv->statusIcon); + if (priv->statusIcon && gtk_status_icon_is_embedded(priv->statusIcon)) + notify_notification_attach_to_status_icon(notify, + priv->statusIcon); #endif #endif @@ -322,46 +354,55 @@ if (priv->statusIcon && gtk_status_icon_is_embedded(priv->statusIcon)) } #endif -static void on_torrent_completed(TrgTorrentModel * model, GtkTreeIter * iter, - gpointer data) { +static void on_torrent_completed(TrgTorrentModel * model, + GtkTreeIter * iter, gpointer data) +{ #ifdef HAVE_LIBNOTIFY torrent_event_notification(model, GTK_STOCK_APPLY, - _("This torrent has completed."), - TORRENT_COMPLETE_NOTIFY_TMOUT, TRG_PREFS_KEY_COMPLETE_NOTIFY, iter, - data); + _("This torrent has completed."), + TORRENT_COMPLETE_NOTIFY_TMOUT, + TRG_PREFS_KEY_COMPLETE_NOTIFY, iter, data); #endif } -static void on_update_filters(TrgTorrentModel * model, gpointer data) { +static void on_update_filters(TrgTorrentModel * model, gpointer data) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data); trg_state_selector_update(priv->stateSelector); } static void on_torrent_added(TrgTorrentModel * model, GtkTreeIter * iter, - gpointer data) { + gpointer data) +{ #ifdef HAVE_LIBNOTIFY torrent_event_notification(model, GTK_STOCK_ADD, - _("This torrent has been added."), TORRENT_ADD_NOTIFY_TMOUT, - TRG_PREFS_KEY_ADD_NOTIFY, iter, data); + _("This torrent has been added."), + TORRENT_ADD_NOTIFY_TMOUT, + TRG_PREFS_KEY_ADD_NOTIFY, iter, data); #endif } -static gboolean delete_event(GtkWidget * w, GdkEvent * event G_GNUC_UNUSED, gpointer data G_GNUC_UNUSED) { +static gboolean delete_event(GtkWidget * w, GdkEvent * event G_GNUC_UNUSED, + gpointer data G_GNUC_UNUSED) +{ return FALSE; } -static void destroy_window(GtkWidget * w, gpointer data G_GNUC_UNUSED) { +static void destroy_window(GtkWidget * w, gpointer data G_GNUC_UNUSED) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(w); TrgPrefs *prefs = trg_client_get_prefs(priv->client); trg_prefs_set_int(prefs, TRG_PREFS_KEY_WINDOW_HEIGHT, priv->height, - TRG_PREFS_GLOBAL); + TRG_PREFS_GLOBAL); trg_prefs_set_int(prefs, TRG_PREFS_KEY_WINDOW_WIDTH, priv->width, - TRG_PREFS_GLOBAL); - trg_prefs_set_int(prefs, TRG_PREFS_KEY_NOTEBOOK_PANED_POS, gtk_paned_get_position(GTK_PANED(priv->vpaned)), - TRG_PREFS_GLOBAL); - trg_prefs_set_int(prefs, TRG_PREFS_KEY_STATES_PANED_POS, gtk_paned_get_position(GTK_PANED(priv->hpaned)), - TRG_PREFS_GLOBAL); + TRG_PREFS_GLOBAL); + trg_prefs_set_int(prefs, TRG_PREFS_KEY_NOTEBOOK_PANED_POS, + gtk_paned_get_position(GTK_PANED(priv->vpaned)), + TRG_PREFS_GLOBAL); + trg_prefs_set_int(prefs, TRG_PREFS_KEY_STATES_PANED_POS, + gtk_paned_get_position(GTK_PANED(priv->hpaned)), + TRG_PREFS_GLOBAL); trg_tree_view_persist(TRG_TREE_VIEW(priv->peersTreeView), FALSE); trg_tree_view_persist(TRG_TREE_VIEW(priv->filesTreeView), FALSE); @@ -372,50 +413,62 @@ static void destroy_window(GtkWidget * w, gpointer data G_GNUC_UNUSED) { gtk_main_quit(); } -static void open_props_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) { +static void open_props_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data); - TrgTorrentPropsDialog *dialog = trg_torrent_props_dialog_new( - GTK_WINDOW(data), priv->torrentTreeView, priv->client); + TrgTorrentPropsDialog *dialog = + trg_torrent_props_dialog_new(GTK_WINDOW(data), + priv->torrentTreeView, priv->client); gtk_widget_show_all(GTK_WIDGET(dialog)); } static void torrent_tv_onRowActivated(GtkTreeView * treeview, - GtkTreePath * path G_GNUC_UNUSED, GtkTreeViewColumn * col G_GNUC_UNUSED, gpointer userdata) { + GtkTreePath * path G_GNUC_UNUSED, + GtkTreeViewColumn * + col G_GNUC_UNUSED, gpointer userdata) +{ open_props_cb(GTK_WIDGET(treeview), userdata); } -static void add_url_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) { +static void add_url_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) +{ TrgMainWindow *win = TRG_MAIN_WINDOW(data); TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data); TrgTorrentAddUrlDialog *dlg = trg_torrent_add_url_dialog_new(win, - priv->client); + priv-> + client); gtk_widget_show_all(GTK_WIDGET(dlg)); } -static void add_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) { +static void add_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data); trg_torrent_add_dialog(TRG_MAIN_WINDOW(data), priv->client); } -static void pause_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) { +static void pause_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data); dispatch_async(priv->client, - torrent_pause(build_json_id_array(priv->torrentTreeView)), - on_generic_interactive_action, data); + torrent_pause(build_json_id_array + (priv->torrentTreeView)), + on_generic_interactive_action, data); } -static void pause_all_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) { +static void pause_all_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data); dispatch_async(priv->client, torrent_pause(NULL), - on_generic_interactive_action, data); + on_generic_interactive_action, data); } -gboolean trg_add_from_filename(TrgMainWindow * win, gchar ** uris) { +gboolean trg_add_from_filename(TrgMainWindow * win, gchar ** uris) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win); TrgClient *client = priv->client; TrgPrefs *prefs = trg_client_get_prefs(client); @@ -423,56 +476,62 @@ gboolean trg_add_from_filename(TrgMainWindow * win, gchar ** uris) { int i; for (i = 0; uris[i]; i++) - filesList = g_slist_append(filesList, uris[i]); + filesList = g_slist_append(filesList, uris[i]); if (trg_prefs_get_bool(prefs, TRG_PREFS_KEY_ADD_OPTIONS_DIALOG, - TRG_PREFS_GLOBAL)) { - TrgTorrentAddDialog *dialog = trg_torrent_add_dialog_new(win, client, - filesList); + TRG_PREFS_GLOBAL)) { + TrgTorrentAddDialog *dialog = + trg_torrent_add_dialog_new(win, client, + filesList); - gtk_widget_show_all(GTK_WIDGET(dialog)); + gtk_widget_show_all(GTK_WIDGET(dialog)); } else { - struct add_torrent_threadfunc_args *args = - g_new0(struct add_torrent_threadfunc_args, 1); - args->list = filesList; - args->cb_data = win; - args->client = client; - args->extraArgs = FALSE; - args->flags = trg_prefs_get_add_flags(prefs); - - launch_add_thread(args); + struct add_torrent_threadfunc_args *args = + g_new0(struct add_torrent_threadfunc_args, 1); + args->list = filesList; + args->cb_data = win; + args->client = client; + args->extraArgs = FALSE; + args->flags = trg_prefs_get_add_flags(prefs); + + launch_add_thread(args); } - g_free(uris); // launch_add_thread() or trg_torrent_add_dialog() will free the filenames and fileList; + g_free(uris); // launch_add_thread() or trg_torrent_add_dialog() will free the filenames and fileList; priv->args = NULL; return TRUE; } -static void resume_all_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) { +static void resume_all_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data); dispatch_async(priv->client, torrent_start(NULL), - on_generic_interactive_action, data); + on_generic_interactive_action, data); } -static void resume_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) { +static void resume_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data); dispatch_async(priv->client, - torrent_start(build_json_id_array(priv->torrentTreeView)), - on_generic_interactive_action, data); + torrent_start(build_json_id_array + (priv->torrentTreeView)), + on_generic_interactive_action, data); } -static void disconnect_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) { +static void disconnect_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data); trg_main_window_conn_changed(TRG_MAIN_WINDOW(data), FALSE); trg_status_bar_reset(priv->statusBar); } -void connect_cb(GtkWidget * w, gpointer data) { +void connect_cb(GtkWidget * w, gpointer data) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data); TrgPrefs *prefs = trg_client_get_prefs(priv->client); JsonObject *currentProfile = trg_prefs_get_profile(prefs); @@ -481,93 +540,107 @@ void connect_cb(GtkWidget * w, gpointer data) { int populate_result; if (w) - profile = (JsonObject*)g_object_get_data(G_OBJECT(w), "profile"); + profile = (JsonObject *) g_object_get_data(G_OBJECT(w), "profile"); if (trg_client_is_connected(priv->client)) - disconnect_cb(NULL, data); + disconnect_cb(NULL, data); if (profile && currentProfile != profile) - trg_prefs_set_profile(prefs, profile); + trg_prefs_set_profile(prefs, profile); else - trg_prefs_profile_change_emit_signal(prefs); + trg_prefs_profile_change_emit_signal(prefs); populate_result = trg_client_populate_with_settings(priv->client); if (populate_result < 0) { - gchar *msg; - - switch (populate_result) { - case TRG_NO_HOSTNAME_SET: - msg = _("No hostname set"); - break; - default: - msg = _("Unknown error getting settings"); - break; - } - - dialog = gtk_message_dialog_new(GTK_WINDOW(data), - GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, - GTK_BUTTONS_OK, "%s", msg); - gtk_dialog_run(GTK_DIALOG(dialog)); - gtk_widget_destroy(dialog); - reset_connect_args(TRG_MAIN_WINDOW(data)); - return; + gchar *msg; + + switch (populate_result) { + case TRG_NO_HOSTNAME_SET: + msg = _("No hostname set"); + break; + default: + msg = _("Unknown error getting settings"); + break; + } + + dialog = gtk_message_dialog_new(GTK_WINDOW(data), + GTK_DIALOG_DESTROY_WITH_PARENT, + GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, + "%s", msg); + gtk_dialog_run(GTK_DIALOG(dialog)); + gtk_widget_destroy(dialog); + reset_connect_args(TRG_MAIN_WINDOW(data)); + return; } - trg_status_bar_push_connection_msg(priv->statusBar, _("Connecting...")); + trg_status_bar_push_connection_msg(priv->statusBar, + _("Connecting...")); trg_client_inc_connid(priv->client); dispatch_async(priv->client, session_get(), on_session_get, data); } -static void open_local_prefs_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) { +static void open_local_prefs_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data); - GtkWidget *dlg = trg_preferences_dialog_get_instance(TRG_MAIN_WINDOW(data), - priv->client); + GtkWidget *dlg = + trg_preferences_dialog_get_instance(TRG_MAIN_WINDOW(data), + priv->client); gtk_widget_show_all(dlg); } -static void open_remote_prefs_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) { +static void open_remote_prefs_cb(GtkWidget * w G_GNUC_UNUSED, + gpointer data) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data); - TrgRemotePrefsDialog *dlg = trg_remote_prefs_dialog_get_instance( - TRG_MAIN_WINDOW(data), priv->client); + TrgRemotePrefsDialog *dlg = + trg_remote_prefs_dialog_get_instance(TRG_MAIN_WINDOW(data), + priv->client); gtk_widget_show_all(GTK_WIDGET(dlg)); } -static void main_window_toggle_filter_dirs(GtkCheckMenuItem * w, gpointer win) { +static void main_window_toggle_filter_dirs(GtkCheckMenuItem * w, + gpointer win) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win); trg_state_selector_set_show_dirs(priv->stateSelector, - gtk_check_menu_item_get_active(w)); + gtk_check_menu_item_get_active(w)); } static void main_window_toggle_filter_trackers(GtkCheckMenuItem * w, - gpointer win) { + gpointer win) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win); trg_state_selector_set_show_trackers(priv->stateSelector, - gtk_check_menu_item_get_active(w)); + gtk_check_menu_item_get_active + (w)); } -static TrgToolbar *trg_main_window_toolbar_new(TrgMainWindow * win) { +static TrgToolbar *trg_main_window_toolbar_new(TrgMainWindow * win) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win); TrgPrefs *prefs = trg_client_get_prefs(priv->client); GObject *b_connect, *b_disconnect, *b_add, *b_resume, *b_pause; - GObject *b_remove, *b_delete, *b_props, *b_local_prefs, *b_remote_prefs; + GObject *b_remove, *b_delete, *b_props, *b_local_prefs, + *b_remote_prefs; TrgToolbar *toolBar = trg_toolbar_new(win, prefs); - g_object_get(toolBar, "connect-button", &b_connect, "disconnect-button", - &b_disconnect, "add-button", &b_add, "resume-button", &b_resume, - "pause-button", &b_pause, "delete-button", &b_delete, - "remove-button", &b_remove, "props-button", &b_props, - "remote-prefs-button", &b_remote_prefs, "local-prefs-button", - &b_local_prefs, NULL); + g_object_get(toolBar, "connect-button", &b_connect, + "disconnect-button", &b_disconnect, "add-button", &b_add, + "resume-button", &b_resume, "pause-button", &b_pause, + "delete-button", &b_delete, "remove-button", &b_remove, + "props-button", &b_props, "remote-prefs-button", + &b_remote_prefs, "local-prefs-button", &b_local_prefs, + NULL); g_signal_connect(b_connect, "clicked", G_CALLBACK(connect_cb), win); g_signal_connect(b_disconnect, "clicked", - G_CALLBACK(disconnect_cb), win); + G_CALLBACK(disconnect_cb), win); g_signal_connect(b_add, "clicked", G_CALLBACK(add_cb), win); g_signal_connect(b_resume, "clicked", G_CALLBACK(resume_cb), win); g_signal_connect(b_pause, "clicked", G_CALLBACK(pause_cb), win); @@ -575,75 +648,89 @@ static TrgToolbar *trg_main_window_toolbar_new(TrgMainWindow * win) { g_signal_connect(b_remove, "clicked", G_CALLBACK(remove_cb), win); g_signal_connect(b_props, "clicked", G_CALLBACK(open_props_cb), win); g_signal_connect(b_local_prefs, "clicked", - G_CALLBACK(open_local_prefs_cb), win); + G_CALLBACK(open_local_prefs_cb), win); g_signal_connect(b_remote_prefs, "clicked", - G_CALLBACK(open_remote_prefs_cb), win); + G_CALLBACK(open_remote_prefs_cb), win); return toolBar; } -static void reannounce_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) { +static void reannounce_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data); dispatch_async(priv->client, - torrent_reannounce(build_json_id_array(priv->torrentTreeView)), - on_generic_interactive_action, data); + torrent_reannounce(build_json_id_array + (priv->torrentTreeView)), + on_generic_interactive_action, data); } -static void verify_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) { +static void verify_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data); dispatch_async(priv->client, - torrent_verify(build_json_id_array(priv->torrentTreeView)), - on_generic_interactive_action, data); + torrent_verify(build_json_id_array + (priv->torrentTreeView)), + on_generic_interactive_action, data); } -static void start_now_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) { +static void start_now_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data); dispatch_async(priv->client, - torrent_start_now(build_json_id_array(priv->torrentTreeView)), - on_generic_interactive_action, data); + torrent_start_now(build_json_id_array + (priv->torrentTreeView)), + on_generic_interactive_action, data); } -static void up_queue_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) { +static void up_queue_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data); dispatch_async(priv->client, - torrent_queue_move_up(build_json_id_array(priv->torrentTreeView)), - on_generic_interactive_action, data); + torrent_queue_move_up(build_json_id_array + (priv->torrentTreeView)), + on_generic_interactive_action, data); } -static void top_queue_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) { +static void top_queue_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data); dispatch_async(priv->client, - torrent_queue_move_top(build_json_id_array(priv->torrentTreeView)), - on_generic_interactive_action, data); + torrent_queue_move_top(build_json_id_array + (priv->torrentTreeView)), + on_generic_interactive_action, data); } -static void bottom_queue_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) { +static void bottom_queue_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data); - dispatch_async( - priv->client, - torrent_queue_move_bottom( - build_json_id_array(priv->torrentTreeView)), - on_generic_interactive_action, data); + dispatch_async(priv->client, + torrent_queue_move_bottom(build_json_id_array + (priv->torrentTreeView)), + on_generic_interactive_action, data); } -static void down_queue_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) { +static void down_queue_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data); - dispatch_async( - priv->client, - torrent_queue_move_down(build_json_id_array(priv->torrentTreeView)), - on_generic_interactive_action, data); + dispatch_async(priv->client, + torrent_queue_move_down(build_json_id_array + (priv->torrentTreeView)), + on_generic_interactive_action, data); } static gint confirm_action_dialog(GtkWindow * win, - GtkTreeSelection * selection, gchar * question_single, - gchar * question_multi, gchar * action_stock) { + GtkTreeSelection * selection, + gchar * question_single, + gchar * question_multi, + gchar * action_stock) +{ TrgMainWindowPrivate *priv; gint selectCount; gint response; @@ -654,179 +741,215 @@ static gint confirm_action_dialog(GtkWindow * win, selectCount = gtk_tree_selection_count_selected_rows(selection); if (selectCount == 1) { - GList *list; - GList *firstNode; - GtkTreeIter firstIter; - gchar *name = NULL; - - list = gtk_tree_selection_get_selected_rows(selection, NULL); - firstNode = g_list_first(list); - - gtk_tree_model_get_iter(GTK_TREE_MODEL - (priv->filteredTorrentModel), &firstIter, firstNode->data); - gtk_tree_model_get(GTK_TREE_MODEL - (priv->filteredTorrentModel), &firstIter, TORRENT_COLUMN_NAME, - &name, -1); - g_list_foreach(list, (GFunc) gtk_tree_path_free, NULL); - g_list_free(list); - - dialog = gtk_message_dialog_new_with_markup(GTK_WINDOW(win), - GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION, - GTK_BUTTONS_NONE, question_single, name); - g_free(name); + GList *list; + GList *firstNode; + GtkTreeIter firstIter; + gchar *name = NULL; + + list = gtk_tree_selection_get_selected_rows(selection, NULL); + firstNode = g_list_first(list); + + gtk_tree_model_get_iter(GTK_TREE_MODEL + (priv->filteredTorrentModel), &firstIter, + firstNode->data); + gtk_tree_model_get(GTK_TREE_MODEL(priv->filteredTorrentModel), + &firstIter, TORRENT_COLUMN_NAME, &name, -1); + g_list_foreach(list, (GFunc) gtk_tree_path_free, NULL); + g_list_free(list); + + dialog = gtk_message_dialog_new_with_markup(GTK_WINDOW(win), + GTK_DIALOG_DESTROY_WITH_PARENT, + GTK_MESSAGE_QUESTION, + GTK_BUTTONS_NONE, + question_single, name); + g_free(name); } else if (selectCount > 1) { - dialog = gtk_message_dialog_new_with_markup(GTK_WINDOW(win), - GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION, - GTK_BUTTONS_NONE, question_multi, selectCount); + dialog = gtk_message_dialog_new_with_markup(GTK_WINDOW(win), + GTK_DIALOG_DESTROY_WITH_PARENT, + GTK_MESSAGE_QUESTION, + GTK_BUTTONS_NONE, + question_multi, + selectCount); } else { - return 0; + return 0; } gtk_dialog_add_buttons(GTK_DIALOG(dialog), GTK_STOCK_CANCEL, - GTK_RESPONSE_CANCEL, action_stock, GTK_RESPONSE_ACCEPT, NULL); - gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CANCEL); + GTK_RESPONSE_CANCEL, action_stock, + GTK_RESPONSE_ACCEPT, NULL); + gtk_dialog_set_default_response(GTK_DIALOG(dialog), + GTK_RESPONSE_CANCEL); gtk_dialog_set_alternative_button_order(GTK_DIALOG(dialog), - GTK_RESPONSE_ACCEPT, GTK_RESPONSE_CANCEL, -1); + GTK_RESPONSE_ACCEPT, + GTK_RESPONSE_CANCEL, -1); response = gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_destroy(dialog); return response; } -static void move_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) { +static void move_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data); - TrgTorrentMoveDialog *dlg = trg_torrent_move_dialog_new( - TRG_MAIN_WINDOW(data), priv->client, priv->torrentTreeView); + TrgTorrentMoveDialog *dlg = + trg_torrent_move_dialog_new(TRG_MAIN_WINDOW(data), priv->client, + priv->torrentTreeView); gtk_widget_show_all(GTK_WIDGET(dlg)); } -static void remove_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) { +static void remove_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) +{ TrgMainWindowPrivate *priv; GtkTreeSelection *selection; JsonArray *ids; priv = TRG_MAIN_WINDOW_GET_PRIVATE(data); - selection = gtk_tree_view_get_selection( - GTK_TREE_VIEW(priv->torrentTreeView)); + selection = + gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->torrentTreeView)); ids = build_json_id_array(priv->torrentTreeView); if (confirm_action_dialog(GTK_WINDOW(data), selection, - _("Remove torrent \"%s\"?"), - _("Remove %d torrents?"), GTK_STOCK_REMOVE) - == GTK_RESPONSE_ACCEPT) - dispatch_async(priv->client, torrent_remove(ids, FALSE), - on_generic_interactive_action, data); + _ + ("Remove torrent \"%s\"?"), + _("Remove %d torrents?"), + GTK_STOCK_REMOVE) + == GTK_RESPONSE_ACCEPT) + dispatch_async(priv->client, torrent_remove(ids, FALSE), + on_generic_interactive_action, data); else - json_array_unref(ids); + json_array_unref(ids); } -static void delete_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) { +static void delete_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) +{ TrgMainWindowPrivate *priv; GtkTreeSelection *selection; JsonArray *ids; priv = TRG_MAIN_WINDOW_GET_PRIVATE(data); - selection = gtk_tree_view_get_selection( - GTK_TREE_VIEW(priv->torrentTreeView)); + selection = + gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->torrentTreeView)); ids = build_json_id_array(priv->torrentTreeView); if (confirm_action_dialog(GTK_WINDOW(data), selection, - _("Remove and delete torrent \"%s\"?"), - _("Remove and delete %d torrents?"), - GTK_STOCK_DELETE) == GTK_RESPONSE_ACCEPT) - dispatch_async(priv->client, torrent_remove(ids, TRUE), - on_generic_interactive_action, data); + _ + ("Remove and delete torrent \"%s\"?"), + _ + ("Remove and delete %d torrents?"), + GTK_STOCK_DELETE) == GTK_RESPONSE_ACCEPT) + dispatch_async(priv->client, torrent_remove(ids, TRUE), + on_generic_interactive_action, data); else - json_array_unref(ids); + json_array_unref(ids); } -static void view_stats_toggled_cb(GtkWidget * w, gpointer data) { +static void view_stats_toggled_cb(GtkWidget * w, gpointer data) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data); - TrgStatsDialog *dlg = trg_stats_dialog_get_instance(TRG_MAIN_WINDOW(data), - priv->client); + TrgStatsDialog *dlg = + trg_stats_dialog_get_instance(TRG_MAIN_WINDOW(data), + priv->client); gtk_widget_show_all(GTK_WIDGET(dlg)); } -static void view_states_toggled_cb(GtkCheckMenuItem * w, gpointer data) { +static void view_states_toggled_cb(GtkCheckMenuItem * w, gpointer data) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data); trg_widget_set_visible(priv->stateSelectorScroller, - gtk_check_menu_item_get_active(w)); + gtk_check_menu_item_get_active(w)); } -static void view_notebook_toggled_cb(GtkCheckMenuItem * w, gpointer data) { +static void view_notebook_toggled_cb(GtkCheckMenuItem * w, gpointer data) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data); - trg_widget_set_visible(priv->notebook, gtk_check_menu_item_get_active(w)); + trg_widget_set_visible(priv->notebook, + gtk_check_menu_item_get_active(w)); } #ifndef TRG_NO_GRAPH -static void trg_main_window_toggle_graph_cb(GtkCheckMenuItem * w, gpointer win) { +static void trg_main_window_toggle_graph_cb(GtkCheckMenuItem * w, + gpointer win) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win); if (gtk_check_menu_item_get_active(w)) { - if (priv->graphNotebookIndex < 0) - trg_main_window_add_graph(TRG_MAIN_WINDOW(win), TRUE); + if (priv->graphNotebookIndex < 0) + trg_main_window_add_graph(TRG_MAIN_WINDOW(win), TRUE); } else { - if (priv->graphNotebookIndex >= 0) - trg_main_window_remove_graph(TRG_MAIN_WINDOW(win)); + if (priv->graphNotebookIndex >= 0) + trg_main_window_remove_graph(TRG_MAIN_WINDOW(win)); } } #endif -void trg_main_window_notebook_set_visible(TrgMainWindow *win, gboolean visible) { +void trg_main_window_notebook_set_visible(TrgMainWindow * win, + gboolean visible) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win); trg_widget_set_visible(priv->notebook, visible); } -static GtkWidget *trg_main_window_notebook_new(TrgMainWindow * win) { +static GtkWidget *trg_main_window_notebook_new(TrgMainWindow * win) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win); TrgPrefs *prefs = trg_client_get_prefs(priv->client); GtkWidget *notebook = priv->notebook = gtk_notebook_new(); - priv->genDetails = trg_general_panel_new( - GTK_TREE_MODEL(priv->torrentModel), priv->client); + priv->genDetails = + trg_general_panel_new(GTK_TREE_MODEL(priv->torrentModel), + priv->client); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), - GTK_WIDGET(priv->genDetails), gtk_label_new(_("General"))); + GTK_WIDGET(priv->genDetails), + gtk_label_new(_("General"))); priv->trackersModel = trg_trackers_model_new(); - priv->trackersTreeView = trg_trackers_tree_view_new(priv->trackersModel, - priv->client, win); + priv->trackersTreeView = + trg_trackers_tree_view_new(priv->trackersModel, priv->client, win); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), - my_scrolledwin_new(GTK_WIDGET - (priv->trackersTreeView)), gtk_label_new(_("Trackers"))); + my_scrolledwin_new(GTK_WIDGET + (priv->trackersTreeView)), + gtk_label_new(_("Trackers"))); priv->filesModel = trg_files_model_new(); priv->filesTreeView = trg_files_tree_view_new(priv->filesModel, win, - priv->client); + priv->client); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), - my_scrolledwin_new(GTK_WIDGET - (priv->filesTreeView)), gtk_label_new(_("Files"))); + my_scrolledwin_new(GTK_WIDGET + (priv->filesTreeView)), + gtk_label_new(_("Files"))); priv->peersModel = trg_peers_model_new(); priv->peersTreeView = trg_peers_tree_view_new(prefs, priv->peersModel); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), - my_scrolledwin_new(GTK_WIDGET - (priv->peersTreeView)), gtk_label_new(_("Peers"))); + my_scrolledwin_new(GTK_WIDGET + (priv->peersTreeView)), + gtk_label_new(_("Peers"))); #ifndef TRG_NO_GRAPH - if (trg_prefs_get_bool(prefs, TRG_PREFS_KEY_SHOW_GRAPH, TRG_PREFS_GLOBAL)) - trg_main_window_add_graph(win, FALSE); + if (trg_prefs_get_bool + (prefs, TRG_PREFS_KEY_SHOW_GRAPH, TRG_PREFS_GLOBAL)) + trg_main_window_add_graph(win, FALSE); else - priv->graphNotebookIndex = -1; + priv->graphNotebookIndex = -1; #endif return notebook; } -gboolean on_session_set(gpointer data) { - trg_response *response = (trg_response*)data; - TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(response->cb_data); +gboolean on_session_set(gpointer data) +{ + trg_response *response = (trg_response *) data; + TrgMainWindowPrivate *priv = + TRG_MAIN_WINDOW_GET_PRIVATE(response->cb_data); - if (response->status == CURLE_OK || response->status == FAIL_RESPONSE_UNSUCCESSFUL) - dispatch_async(priv->client, session_get(), on_session_get, response->cb_data); + if (response->status == CURLE_OK + || response->status == FAIL_RESPONSE_UNSUCCESSFUL) + dispatch_async(priv->client, session_get(), on_session_get, + response->cb_data); trg_dialog_error_handler(TRG_MAIN_WINDOW(response->cb_data), response); trg_response_free(response); @@ -834,54 +957,61 @@ gboolean on_session_set(gpointer data) { return FALSE; } -static gboolean on_session_get(gpointer data) { - trg_response *response = (trg_response*)data; +static gboolean on_session_get(gpointer data) +{ + trg_response *response = (trg_response *) data; TrgMainWindow *win = TRG_MAIN_WINDOW(response->cb_data); - TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(response->cb_data); + TrgMainWindowPrivate *priv = + TRG_MAIN_WINDOW_GET_PRIVATE(response->cb_data); TrgClient *client = priv->client; gboolean isConnected = trg_client_is_connected(client); JsonObject *newSession = NULL; if (response->obj) - newSession = get_arguments(response->obj); + newSession = get_arguments(response->obj); if (!isConnected) { - float version; - - if (trg_dialog_error_handler(win, response) == TRUE) { - trg_response_free(response); - reset_connect_args(win); - return FALSE; - } - - if (session_get_version(newSession, &version)==0 || version < TRANSMISSION_MIN_SUPPORTED) { - gchar *msg = g_strdup_printf( - _("This application supports Transmission %.2f and later, you have %.2f."), - TRANSMISSION_MIN_SUPPORTED, version); - GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(win), - GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, - "%s", msg); - gtk_window_set_title(GTK_WINDOW(dialog), _("Error")); - gtk_dialog_run(GTK_DIALOG(dialog)); - gtk_widget_destroy(dialog); - g_free(msg); - trg_response_free(response); - reset_connect_args(win); - return FALSE; - } - - trg_status_bar_connect(priv->statusBar, newSession); + float version; + + if (trg_dialog_error_handler(win, response) == TRUE) { + trg_response_free(response); + reset_connect_args(win); + return FALSE; + } + + if (session_get_version(newSession, &version) == 0 + || version < TRANSMISSION_MIN_SUPPORTED) { + gchar *msg = + g_strdup_printf(_ + ("This application supports Transmission %.2f and later, you have %.2f."), +TRANSMISSION_MIN_SUPPORTED, version); + GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(win), + GTK_DIALOG_MODAL, + GTK_MESSAGE_ERROR, + GTK_BUTTONS_OK, + "%s", msg); + gtk_window_set_title(GTK_WINDOW(dialog), _("Error")); + gtk_dialog_run(GTK_DIALOG(dialog)); + gtk_widget_destroy(dialog); + g_free(msg); + trg_response_free(response); + reset_connect_args(win); + return FALSE; + } + + trg_status_bar_connect(priv->statusBar, newSession); } if (newSession) { - trg_client_set_session(client, newSession); - json_object_ref(newSession); + trg_client_set_session(client, newSession); + json_object_ref(newSession); } if (!isConnected) { - trg_main_window_conn_changed(win, TRUE); - trg_trackers_tree_view_new_connection(priv->trackersTreeView, client); - dispatch_async(client, torrent_get(-1), on_torrent_get_first, win); + trg_main_window_conn_changed(win, TRUE); + trg_trackers_tree_view_new_connection(priv->trackersTreeView, + client); + dispatch_async(client, torrent_get(-1), on_torrent_get_first, win); } trg_response_free(response); @@ -889,44 +1019,70 @@ static gboolean on_session_get(gpointer data) { return FALSE; } -static void connchange_whatever_statusicon(TrgMainWindow *win, gboolean connected) +static void connchange_whatever_statusicon(TrgMainWindow * win, + gboolean connected) { TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win); const gchar *display = connected ? _("Connected") : _("Disconnected"); #ifdef HAVE_LIBAPPINDICATOR if (priv->appIndicator) - app_indicator_set_menu(priv->appIndicator, trg_status_icon_view_menu(win, display)); + app_indicator_set_menu(priv->appIndicator, + trg_status_icon_view_menu(win, display)); #else if (priv->statusIcon) - gtk_status_icon_set_tooltip_text(priv->statusIcon, display); + gtk_status_icon_set_tooltip_text(priv->statusIcon, display); #endif } -static void update_whatever_statusicon(TrgMainWindow *win, const gchar *speedLabel, trg_torrent_model_update_stats *stats) +static void update_whatever_statusicon(TrgMainWindow * win, + const gchar * speedLabel, + trg_torrent_model_update_stats * + stats) { TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win); - gchar *display = g_strdup_printf("%s: %s", _("Connected"), speedLabel); #ifdef HAVE_LIBAPPINDICATOR + gtk_widget_set_visible(priv->appIndicatorSeedingItem, stats != NULL); + gtk_widget_set_visible(priv->appIndicatorDownloadingItem, + stats != NULL); + gtk_widget_set_visible(priv->appIndicatorSepItem, stats != NULL); + + if (stats) { + gchar *downloadingLabel = + g_strdup_printf(_("Downloading %d"), stats->down); + gchar *seedingLabel = + g_strdup_printf(_("Seeding %d"), stats->seeding); + gtk_menu_item_set_label(GTK_MENU_ITEM + (priv->appIndicatorSeedingItem), + seedingLabel); + gtk_menu_item_set_label(GTK_MENU_ITEM + (priv->appIndicatorDownloadingItem), + downloadingLabel); + g_free(downloadingLabel); + g_free(seedingLabel); + } + if (priv->appIndicatorStatusItem) - gtk_menu_item_set_label(GTK_MENU_ITEM(priv->appIndicatorStatusItem), display); + gtk_menu_item_set_label(GTK_MENU_ITEM + (priv->appIndicatorStatusItem), + speedLabel); #else if (priv->statusIcon) - gtk_status_icon_set_tooltip_text(priv->statusIcon, display); + gtk_status_icon_set_tooltip_text(priv->statusIcon, speedLabel); #endif - - g_free(display); } -/* - * The callback for a torrent-get response. - */ + /* + * The callback for a torrent-get response. + */ -static gboolean on_torrent_get(gpointer data, int mode) { - trg_response *response = (trg_response*)data; - TrgMainWindow *win = TRG_MAIN_WINDOW(response->cb_data); - TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(response->cb_data); +static gboolean on_torrent_get(gpointer data, int mode) +{ + trg_response *response = (trg_response *) data; + TrgMainWindow *win = TRG_MAIN_WINDOW(response->cb_data); + TrgMainWindowPrivate *priv = + TRG_MAIN_WINDOW_GET_PRIVATE(response->cb_data); TrgClient *client = priv->client; TrgPrefs *prefs = trg_client_get_prefs(client); trg_torrent_model_update_stats *stats; @@ -934,110 +1090,138 @@ static gboolean on_torrent_get(gpointer data, int mode) { /* Disconnected between request and response callback */ if (!trg_client_is_connected(client)) { - trg_response_free(response); - return FALSE; + trg_response_free(response); + return FALSE; } trg_client_updatelock(client); interval - = gtk_widget_get_visible(GTK_WIDGET(win)) ? trg_prefs_get_int(prefs, - TRG_PREFS_KEY_UPDATE_INTERVAL, TRG_PREFS_CONNECTION) - : trg_prefs_get_int(prefs, - TRG_PREFS_KEY_MINUPDATE_INTERVAL, TRG_PREFS_CONNECTION); + = + gtk_widget_get_visible(GTK_WIDGET(win)) ? trg_prefs_get_int(prefs, + TRG_PREFS_KEY_UPDATE_INTERVAL, + TRG_PREFS_CONNECTION) + : trg_prefs_get_int(prefs, TRG_PREFS_KEY_MINUPDATE_INTERVAL, + TRG_PREFS_CONNECTION); if (interval < 1) - interval = TRG_INTERVAL_DEFAULT; + interval = TRG_INTERVAL_DEFAULT; if (response->status != CURLE_OK) { - if (trg_client_inc_failcount(client) >= TRG_MAX_RETRIES) { - trg_main_window_conn_changed(win, FALSE); - trg_dialog_error_handler(win, response); - } else { - gchar *msg = make_error_message(response->obj, response->status); - gchar *statusBarMsg = g_strdup_printf(_("Request %d/%d failed: %s"), - trg_client_get_failcount(client), TRG_MAX_RETRIES, msg); - trg_status_bar_push_connection_msg(priv->statusBar, statusBarMsg); - g_free(msg); - g_free(statusBarMsg); - priv->timerId = g_timeout_add_seconds(interval, trg_update_torrents_timerfunc, win); - } - trg_client_updateunlock(client); - trg_response_free(response); - return FALSE; + if (trg_client_inc_failcount(client) >= TRG_MAX_RETRIES) { + trg_main_window_conn_changed(win, FALSE); + trg_dialog_error_handler(win, response); + } else { + gchar *msg = + make_error_message(response->obj, response->status); + gchar *statusBarMsg = + g_strdup_printf(_("Request %d/%d failed: %s"), + trg_client_get_failcount(client), + TRG_MAX_RETRIES, msg); + trg_status_bar_push_connection_msg(priv->statusBar, + statusBarMsg); + g_free(msg); + g_free(statusBarMsg); + priv->timerId = + g_timeout_add_seconds(interval, + trg_update_torrents_timerfunc, win); + } + trg_client_updateunlock(client); + trg_response_free(response); + return FALSE; } trg_client_reset_failcount(client); trg_client_inc_serial(client); - stats = trg_torrent_model_update(priv->torrentModel, client, response->obj, mode); + stats = + trg_torrent_model_update(priv->torrentModel, client, response->obj, + mode); trg_state_selector_stats_update(priv->stateSelector, stats); update_selected_torrent_notebook(win, mode, priv->selectedTorrentId); trg_status_bar_update(priv->statusBar, stats, client); - update_whatever_statusicon(win, trg_status_bar_get_speed_text(priv->statusBar), stats); + update_whatever_statusicon(win, + trg_status_bar_get_speed_text(priv-> + statusBar), + stats); #ifndef TRG_NO_GRAPH if (priv->graphNotebookIndex >= 0) - trg_torrent_graph_set_speed(priv->graph, stats); + trg_torrent_graph_set_speed(priv->graph, stats); #endif if (mode != TORRENT_GET_MODE_INTERACTION) - priv->timerId = g_timeout_add_seconds(interval, trg_update_torrents_timerfunc, win); + priv->timerId = + g_timeout_add_seconds(interval, trg_update_torrents_timerfunc, + win); trg_client_updateunlock(client); trg_response_free(response); return FALSE; } -static gboolean on_torrent_get_active(gpointer data) { +static gboolean on_torrent_get_active(gpointer data) +{ return on_torrent_get(data, TORRENT_GET_MODE_ACTIVE); } -static gboolean on_torrent_get_first(gpointer data) { - trg_response *response = (trg_response*)data; - TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(response->cb_data); +static gboolean on_torrent_get_first(gpointer data) +{ + trg_response *response = (trg_response *) data; + TrgMainWindowPrivate *priv = + TRG_MAIN_WINDOW_GET_PRIVATE(response->cb_data); TrgMainWindow *win = TRG_MAIN_WINDOW(response->cb_data); gboolean result = on_torrent_get(data, TORRENT_GET_MODE_FIRST); if (priv->args) - trg_add_from_filename(win, priv->args); + trg_add_from_filename(win, priv->args); return result; } -static gboolean on_torrent_get_interactive(gpointer data) { +static gboolean on_torrent_get_interactive(gpointer data) +{ return on_torrent_get(data, TORRENT_GET_MODE_INTERACTION); } -static gboolean on_torrent_get_update(gpointer data) { +static gboolean on_torrent_get_update(gpointer data) +{ return on_torrent_get(data, TORRENT_GET_MODE_UPDATE); } -static gboolean trg_update_torrents_timerfunc(gpointer data) { +static gboolean trg_update_torrents_timerfunc(gpointer data) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data); TrgClient *tc = priv->client; TrgPrefs *prefs = trg_client_get_prefs(tc); if (trg_client_is_connected(tc)) { - gboolean activeOnly = trg_prefs_get_bool(prefs, TRG_PREFS_KEY_UPDATE_ACTIVE_ONLY, TRG_PREFS_CONNECTION) - && (!trg_prefs_get_bool(prefs, - TRG_PREFS_ACTIVEONLY_FULLSYNC_ENABLED, - TRG_PREFS_CONNECTION) || (trg_client_get_serial(tc) - % trg_prefs_get_int(prefs, - TRG_PREFS_ACTIVEONLY_FULLSYNC_EVERY, - TRG_PREFS_CONNECTION) != 0)); - dispatch_async(tc, torrent_get(activeOnly ? TORRENT_GET_TAG_MODE_UPDATE : TORRENT_GET_TAG_MODE_FULL), - activeOnly ? on_torrent_get_active : on_torrent_get_update, - data); - - if (trg_client_get_serial(tc) % SESSION_UPDATE_DIVISOR == 0) - dispatch_async(priv->client, session_get(), on_session_get, data); + gboolean activeOnly = + trg_prefs_get_bool(prefs, TRG_PREFS_KEY_UPDATE_ACTIVE_ONLY, + TRG_PREFS_CONNECTION) + && (!trg_prefs_get_bool(prefs, + TRG_PREFS_ACTIVEONLY_FULLSYNC_ENABLED, + TRG_PREFS_CONNECTION) + || (trg_client_get_serial(tc) + % trg_prefs_get_int(prefs, + TRG_PREFS_ACTIVEONLY_FULLSYNC_EVERY, + TRG_PREFS_CONNECTION) != 0)); + dispatch_async(tc, + torrent_get(activeOnly ? TORRENT_GET_TAG_MODE_UPDATE + : TORRENT_GET_TAG_MODE_FULL), + activeOnly ? on_torrent_get_active : + on_torrent_get_update, data); + + if (trg_client_get_serial(tc) % SESSION_UPDATE_DIVISOR == 0) + dispatch_async(priv->client, session_get(), on_session_get, + data); } return FALSE; } -static void open_about_cb(GtkWidget * w G_GNUC_UNUSED, GtkWindow * parent) { +static void open_about_cb(GtkWidget * w G_GNUC_UNUSED, GtkWindow * parent) +{ GtkWidget *aboutDialog = trg_about_window_new(parent); gtk_dialog_run(GTK_DIALOG(aboutDialog)); @@ -1045,7 +1229,9 @@ static void open_about_cb(GtkWidget * w G_GNUC_UNUSED, GtkWindow * parent) { } static gboolean trg_torrent_tree_view_visible_func(GtkTreeModel * model, - GtkTreeIter * iter, gpointer data) { + GtkTreeIter * iter, + gpointer data) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data); guint flags; @@ -1058,100 +1244,110 @@ static gboolean trg_torrent_tree_view_visible_func(GtkTreeModel * model, gtk_tree_model_get(model, iter, TORRENT_COLUMN_FLAGS, &flags, -1); if (criteria != 0) { - if (criteria & FILTER_FLAG_TRACKER) { - gchar *text = trg_state_selector_get_selected_text( - priv->stateSelector); - JsonObject *json; - gtk_tree_model_get(model, iter, TORRENT_COLUMN_JSON, &json, -1); - - if (!json || !torrent_has_tracker(json, - trg_state_selector_get_url_host_regex(priv->stateSelector), - text)) - return FALSE; - } else if (criteria & FILTER_FLAG_DIR) { - gchar *text = trg_state_selector_get_selected_text( - priv->stateSelector); - gchar *dd; - int cmp; - gtk_tree_model_get(model, iter, TORRENT_COLUMN_DOWNLOADDIR_SHORT, &dd, -1); - cmp = g_strcmp0(text, dd); - g_free(dd); - g_free(text); - if (cmp) - return FALSE; - } else if (!(flags & criteria)) { - return FALSE; - } + if (criteria & FILTER_FLAG_TRACKER) { + gchar *text = + trg_state_selector_get_selected_text(priv->stateSelector); + JsonObject *json; + gtk_tree_model_get(model, iter, TORRENT_COLUMN_JSON, &json, + -1); + + if (!json || !torrent_has_tracker(json, + trg_state_selector_get_url_host_regex + (priv->stateSelector), text)) + return FALSE; + } else if (criteria & FILTER_FLAG_DIR) { + gchar *text = + trg_state_selector_get_selected_text(priv->stateSelector); + gchar *dd; + int cmp; + gtk_tree_model_get(model, iter, + TORRENT_COLUMN_DOWNLOADDIR_SHORT, &dd, -1); + cmp = g_strcmp0(text, dd); + g_free(dd); + g_free(text); + if (cmp) + return FALSE; + } else if (!(flags & criteria)) { + return FALSE; + } } visible = TRUE; filterText = gtk_entry_get_text(GTK_ENTRY(priv->filterEntry)); if (strlen(filterText) > 0) { - gtk_tree_model_get(model, iter, TORRENT_COLUMN_NAME, &name, -1); - if (name) { - gchar *filterCmp = g_utf8_casefold(filterText, -1); - gchar *nameCmp = g_utf8_casefold(name, -1); - - if (!strstr(nameCmp, filterCmp)) - visible = FALSE; - - g_free(nameCmp); - g_free(filterCmp); - g_free(name); - } + gtk_tree_model_get(model, iter, TORRENT_COLUMN_NAME, &name, -1); + if (name) { + gchar *filterCmp = g_utf8_casefold(filterText, -1); + gchar *nameCmp = g_utf8_casefold(name, -1); + + if (!strstr(nameCmp, filterCmp)) + visible = FALSE; + + g_free(nameCmp); + g_free(filterCmp); + g_free(name); + } } return visible; } -void trg_main_window_reload_dir_aliases(TrgMainWindow *win) +void trg_main_window_reload_dir_aliases(TrgMainWindow * win) { TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win); - trg_torrent_model_reload_dir_aliases(priv->client, GTK_TREE_MODEL(priv->torrentModel)); + trg_torrent_model_reload_dir_aliases(priv->client, + GTK_TREE_MODEL(priv-> + torrentModel)); trg_state_selector_update(priv->stateSelector); } -static TrgTorrentTreeView *trg_main_window_torrent_tree_view_new( - TrgMainWindow * win, GtkTreeModel * model) { +static TrgTorrentTreeView + *trg_main_window_torrent_tree_view_new(TrgMainWindow * win, + GtkTreeModel * model) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win); - TrgTorrentTreeView *torrentTreeView = trg_torrent_tree_view_new( - trg_client_get_prefs(priv->client), model); + TrgTorrentTreeView *torrentTreeView = + trg_torrent_tree_view_new(trg_client_get_prefs(priv->client), + model); - GtkTreeSelection *selection = gtk_tree_view_get_selection( - GTK_TREE_VIEW(torrentTreeView)); + GtkTreeSelection *selection = + gtk_tree_view_get_selection(GTK_TREE_VIEW(torrentTreeView)); g_signal_connect(G_OBJECT(selection), "changed", - G_CALLBACK(torrent_selection_changed), win); + G_CALLBACK(torrent_selection_changed), win); return torrentTreeView; } static gboolean trg_dialog_error_handler(TrgMainWindow * win, - trg_response *response) { + trg_response * response) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win); if (response->status != CURLE_OK) { - GtkWidget *dialog; - const gchar *msg; - - msg = make_error_message(response->obj, response->status); - trg_status_bar_clear_indicators(priv->statusBar); - trg_status_bar_push_connection_msg(priv->statusBar, msg); - dialog = gtk_message_dialog_new(GTK_WINDOW(win), GTK_DIALOG_MODAL, - GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "%s", msg); - gtk_window_set_title(GTK_WINDOW(dialog), _("Error")); - gtk_dialog_run(GTK_DIALOG(dialog)); - gtk_widget_destroy(dialog); - g_free((gpointer) msg); - return TRUE; + GtkWidget *dialog; + const gchar *msg; + + msg = make_error_message(response->obj, response->status); + trg_status_bar_clear_indicators(priv->statusBar); + trg_status_bar_push_connection_msg(priv->statusBar, msg); + dialog = gtk_message_dialog_new(GTK_WINDOW(win), GTK_DIALOG_MODAL, + GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, + "%s", msg); + gtk_window_set_title(GTK_WINDOW(dialog), _("Error")); + gtk_dialog_run(GTK_DIALOG(dialog)); + gtk_widget_destroy(dialog); + g_free((gpointer) msg); + return TRUE; } else { - return FALSE; + return FALSE; } } static gboolean torrent_selection_changed(GtkTreeSelection * selection, - gpointer data) { + gpointer data) +{ TrgMainWindow *win = TRG_MAIN_WINDOW(data); TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data); GList *selectionList; @@ -1159,8 +1355,8 @@ static gboolean torrent_selection_changed(GtkTreeSelection * selection, gint64 id; if (trg_torrent_model_is_remove_in_progress(priv->torrentModel)) { - trg_main_window_torrent_scrub(win); - return TRUE; + trg_main_window_torrent_scrub(win); + return TRUE; } selectionList = gtk_tree_selection_get_selected_rows(selection, NULL); @@ -1168,12 +1364,12 @@ static gboolean torrent_selection_changed(GtkTreeSelection * selection, id = -1; if (firstNode) { - GtkTreeIter iter; - if (gtk_tree_model_get_iter(priv->filteredTorrentModel, &iter, - (GtkTreePath *) firstNode->data)) { - gtk_tree_model_get(priv->filteredTorrentModel, &iter, - TORRENT_COLUMN_ID, &id, -1); - } + GtkTreeIter iter; + if (gtk_tree_model_get_iter(priv->filteredTorrentModel, &iter, + (GtkTreePath *) firstNode->data)) { + gtk_tree_model_get(priv->filteredTorrentModel, &iter, + TORRENT_COLUMN_ID, &id, -1); + } } g_list_foreach(selectionList, (GFunc) gtk_tree_path_free, NULL); @@ -1184,27 +1380,32 @@ static gboolean torrent_selection_changed(GtkTreeSelection * selection, return TRUE; } -gboolean on_generic_interactive_action(gpointer data) { - trg_response *response = (trg_response*)data; - TrgMainWindow *win = TRG_MAIN_WINDOW(response->cb_data); - TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(response->cb_data); +gboolean on_generic_interactive_action(gpointer data) +{ + trg_response *response = (trg_response *) data; + TrgMainWindow *win = TRG_MAIN_WINDOW(response->cb_data); + TrgMainWindowPrivate *priv = + TRG_MAIN_WINDOW_GET_PRIVATE(response->cb_data); TrgClient *tc = priv->client; TrgPrefs *prefs = trg_client_get_prefs(tc); if (trg_client_is_connected(tc)) { - trg_dialog_error_handler(win, response); - - if (response->status == CURLE_OK) { - gint64 id; - if (json_object_has_member(response->obj, PARAM_TAG)) - id = json_object_get_int_member(response->obj, PARAM_TAG); - else if (trg_prefs_get_bool(prefs, TRG_PREFS_KEY_UPDATE_ACTIVE_ONLY, TRG_PREFS_CONNECTION)) - id = -2; - else - id = -1; - - dispatch_async(tc, torrent_get(id), on_torrent_get_interactive, win); - } + trg_dialog_error_handler(win, response); + + if (response->status == CURLE_OK) { + gint64 id; + if (json_object_has_member(response->obj, PARAM_TAG)) + id = json_object_get_int_member(response->obj, PARAM_TAG); + else if (trg_prefs_get_bool + (prefs, TRG_PREFS_KEY_UPDATE_ACTIVE_ONLY, + TRG_PREFS_CONNECTION)) + id = -2; + else + id = -1; + + dispatch_async(tc, torrent_get(id), on_torrent_get_interactive, + win); + } } trg_response_free(response); @@ -1212,7 +1413,8 @@ gboolean on_generic_interactive_action(gpointer data) { } static -void trg_main_window_torrent_scrub(TrgMainWindow * win) { +void trg_main_window_torrent_scrub(TrgMainWindow * win) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win); gtk_list_store_clear(GTK_LIST_STORE(priv->filesModel)); @@ -1220,30 +1422,35 @@ void trg_main_window_torrent_scrub(TrgMainWindow * win) { gtk_list_store_clear(GTK_LIST_STORE(priv->peersModel)); trg_general_panel_clear(priv->genDetails); trg_trackers_model_set_no_selection(TRG_TRACKERS_MODEL - (priv->trackersModel)); + (priv->trackersModel)); trg_toolbar_torrent_actions_sensitive(priv->toolBar, FALSE); trg_menu_bar_torrent_actions_sensitive(priv->menuBar, FALSE); } -static void entry_filter_changed_cb(GtkWidget * w, gpointer data) { +static void entry_filter_changed_cb(GtkWidget * w, gpointer data) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data); gboolean clearSensitive = gtk_entry_get_text_length(GTK_ENTRY(w)) > 0; gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER - (priv->filteredTorrentModel)); + (priv->filteredTorrentModel)); g_object_set(priv->filterEntry, "secondary-icon-sensitive", - clearSensitive, NULL); + clearSensitive, NULL); } -static void torrent_state_selection_changed(TrgStateSelector * selector G_GNUC_UNUSED, - guint flag G_GNUC_UNUSED, gpointer data) { +static void torrent_state_selection_changed(TrgStateSelector * + selector G_GNUC_UNUSED, + guint flag G_GNUC_UNUSED, + gpointer data) +{ gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(data)); } static -void trg_main_window_conn_changed(TrgMainWindow * win, gboolean connected) { +void trg_main_window_conn_changed(TrgMainWindow * win, gboolean connected) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win); TrgClient *tc = priv->client; @@ -1253,143 +1460,157 @@ void trg_main_window_conn_changed(TrgMainWindow * win, gboolean connected) { gtk_widget_set_sensitive(GTK_WIDGET(priv->torrentTreeView), connected); gtk_widget_set_sensitive(GTK_WIDGET(priv->peersTreeView), connected); gtk_widget_set_sensitive(GTK_WIDGET(priv->filesTreeView), connected); - gtk_widget_set_sensitive(GTK_WIDGET(priv->trackersTreeView), connected); + gtk_widget_set_sensitive(GTK_WIDGET(priv->trackersTreeView), + connected); gtk_widget_set_sensitive(GTK_WIDGET(priv->genDetails), connected); if (!connected) { - trg_main_window_torrent_scrub(win); - trg_state_selector_disconnect(priv->stateSelector); + trg_main_window_torrent_scrub(win); + trg_state_selector_disconnect(priv->stateSelector); #ifndef TRG_NO_GRAPH - if (priv->graphNotebookIndex >= 0) - trg_torrent_graph_set_nothing(priv->graph); + if (priv->graphNotebookIndex >= 0) + trg_torrent_graph_set_nothing(priv->graph); #endif - trg_torrent_model_remove_all(priv->torrentModel); + trg_torrent_model_remove_all(priv->torrentModel); - priv->timerId = 0; + priv->timerId = 0; } trg_client_status_change(tc, connected); connchange_whatever_statusicon(win, connected); } -static void trg_main_window_get_property(GObject * object, guint property_id, - GValue * value, GParamSpec * pspec) { +static void trg_main_window_get_property(GObject * object, + guint property_id, GValue * value, + GParamSpec * pspec) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(object); switch (property_id) { case PROP_CLIENT: - g_value_set_pointer(value, priv->client); - break; + g_value_set_pointer(value, priv->client); + break; case PROP_MINIMISE_ON_START: - g_value_set_boolean(value, priv->min_on_start); - break; + g_value_set_boolean(value, priv->min_on_start); + break; default: - G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); - break; + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); + break; } } -static void trg_main_window_set_property(GObject * object, guint property_id, - const GValue * value, GParamSpec * pspec) { +static void trg_main_window_set_property(GObject * object, + guint property_id, + const GValue * value, + GParamSpec * pspec) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(object); switch (property_id) { case PROP_CLIENT: - priv->client = g_value_get_pointer(value); - break; + priv->client = g_value_get_pointer(value); + break; case PROP_MINIMISE_ON_START: - priv->min_on_start = g_value_get_boolean(value); - break; + priv->min_on_start = g_value_get_boolean(value); + break; default: - G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); - break; + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); + break; } } -static void quit_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) { +static void quit_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) +{ gtk_widget_destroy(GTK_WIDGET(data)); } -static TrgMenuBar *trg_main_window_menu_bar_new(TrgMainWindow * win) { +static TrgMenuBar *trg_main_window_menu_bar_new(TrgMainWindow * win) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win); GObject *b_disconnect, *b_add, *b_resume, *b_pause, *b_verify, - *b_remove, *b_delete, *b_props, *b_local_prefs, *b_remote_prefs, - *b_about, *b_view_states, *b_view_notebook, *b_view_stats, - *b_add_url, *b_quit, *b_move, *b_reannounce, *b_pause_all, - *b_resume_all, *b_dir_filters, *b_tracker_filters, - *b_up_queue, *b_down_queue, *b_top_queue, *b_bottom_queue, + *b_remove, *b_delete, *b_props, *b_local_prefs, *b_remote_prefs, + *b_about, *b_view_states, *b_view_notebook, *b_view_stats, + *b_add_url, *b_quit, *b_move, *b_reannounce, *b_pause_all, + *b_resume_all, *b_dir_filters, *b_tracker_filters, + *b_up_queue, *b_down_queue, *b_top_queue, *b_bottom_queue, #ifndef TRG_NO_GRAPH - *b_show_graph, + *b_show_graph, #endif - *b_start_now; + *b_start_now; TrgMenuBar *menuBar; menuBar = trg_menu_bar_new(win, trg_client_get_prefs(priv->client)); g_object_get(menuBar, "disconnect-button", - &b_disconnect, "add-button", &b_add, "add-url-button", &b_add_url, - "resume-button", &b_resume, "resume-all-button", &b_resume_all, - "pause-button", &b_pause, "pause-all-button", &b_pause_all, - "delete-button", &b_delete, "remove-button", &b_remove, - "move-button", &b_move, "verify-button", &b_verify, - "reannounce-button", &b_reannounce, "props-button", &b_props, - "remote-prefs-button", &b_remote_prefs, "local-prefs-button", - &b_local_prefs, "view-notebook-button", &b_view_notebook, - "view-states-button", &b_view_states, "view-stats-button", - &b_view_stats, "about-button", &b_about, "quit-button", &b_quit, - "dir-filters", &b_dir_filters, "tracker-filters", - &b_tracker_filters, + &b_disconnect, "add-button", &b_add, "add-url-button", + &b_add_url, "resume-button", &b_resume, + "resume-all-button", &b_resume_all, "pause-button", + &b_pause, "pause-all-button", &b_pause_all, + "delete-button", &b_delete, "remove-button", &b_remove, + "move-button", &b_move, "verify-button", &b_verify, + "reannounce-button", &b_reannounce, "props-button", + &b_props, "remote-prefs-button", &b_remote_prefs, + "local-prefs-button", &b_local_prefs, + "view-notebook-button", &b_view_notebook, + "view-states-button", &b_view_states, "view-stats-button", + &b_view_stats, "about-button", &b_about, "quit-button", + &b_quit, "dir-filters", &b_dir_filters, "tracker-filters", + &b_tracker_filters, #ifndef TRG_NO_GRAPH - "show-graph", &b_show_graph, + "show-graph", &b_show_graph, #endif - "up-queue", &b_up_queue, "down-queue", &b_down_queue, "top-queue", - &b_top_queue, "bottom-queue", &b_bottom_queue, "start-now", - &b_start_now, NULL); + "up-queue", &b_up_queue, "down-queue", &b_down_queue, + "top-queue", &b_top_queue, "bottom-queue", + &b_bottom_queue, "start-now", &b_start_now, NULL); g_signal_connect(b_disconnect, "activate", - G_CALLBACK(disconnect_cb), win); + G_CALLBACK(disconnect_cb), win); g_signal_connect(b_add, "activate", G_CALLBACK(add_cb), win); g_signal_connect(b_add_url, "activate", G_CALLBACK(add_url_cb), win); g_signal_connect(b_resume, "activate", G_CALLBACK(resume_cb), win); g_signal_connect(b_resume_all, "activate", G_CALLBACK(resume_all_cb), - win); + win); g_signal_connect(b_pause, "activate", G_CALLBACK(pause_cb), win); g_signal_connect(b_pause_all, "activate", G_CALLBACK(pause_all_cb), - win); + win); g_signal_connect(b_verify, "activate", G_CALLBACK(verify_cb), win); g_signal_connect(b_reannounce, "activate", G_CALLBACK(reannounce_cb), - win); + win); g_signal_connect(b_delete, "activate", G_CALLBACK(delete_cb), win); g_signal_connect(b_remove, "activate", G_CALLBACK(remove_cb), win); g_signal_connect(b_up_queue, "activate", G_CALLBACK(up_queue_cb), win); - g_signal_connect(b_down_queue, "activate", G_CALLBACK(down_queue_cb), win); - g_signal_connect(b_top_queue, "activate", G_CALLBACK(top_queue_cb), win); - g_signal_connect(b_bottom_queue, "activate", G_CALLBACK(bottom_queue_cb), win); - g_signal_connect(b_start_now, "activate", G_CALLBACK(start_now_cb), win); + g_signal_connect(b_down_queue, "activate", G_CALLBACK(down_queue_cb), + win); + g_signal_connect(b_top_queue, "activate", G_CALLBACK(top_queue_cb), + win); + g_signal_connect(b_bottom_queue, "activate", + G_CALLBACK(bottom_queue_cb), win); + g_signal_connect(b_start_now, "activate", G_CALLBACK(start_now_cb), + win); g_signal_connect(b_move, "activate", G_CALLBACK(move_cb), win); g_signal_connect(b_about, "activate", G_CALLBACK(open_about_cb), win); g_signal_connect(b_local_prefs, "activate", - G_CALLBACK(open_local_prefs_cb), win); + G_CALLBACK(open_local_prefs_cb), win); g_signal_connect(b_remote_prefs, "activate", - G_CALLBACK(open_remote_prefs_cb), win); + G_CALLBACK(open_remote_prefs_cb), win); g_signal_connect(b_view_notebook, "toggled", - G_CALLBACK(view_notebook_toggled_cb), win); + G_CALLBACK(view_notebook_toggled_cb), win); g_signal_connect(b_dir_filters, "toggled", - G_CALLBACK(main_window_toggle_filter_dirs), win); + G_CALLBACK(main_window_toggle_filter_dirs), win); g_signal_connect(b_tracker_filters, "toggled", - G_CALLBACK(main_window_toggle_filter_trackers), win); + G_CALLBACK(main_window_toggle_filter_trackers), win); #ifndef TRG_NO_GRAPH g_signal_connect(b_tracker_filters, "toggled", - G_CALLBACK(trg_main_window_toggle_graph_cb), win); + G_CALLBACK(trg_main_window_toggle_graph_cb), win); #endif g_signal_connect(b_view_states, "toggled", - G_CALLBACK(view_states_toggled_cb), win); + G_CALLBACK(view_states_toggled_cb), win); g_signal_connect(b_view_stats, "activate", - G_CALLBACK(view_stats_toggled_cb), win); + G_CALLBACK(view_stats_toggled_cb), win); #ifndef TRG_NO_GRAPH g_signal_connect(b_show_graph, "toggled", - G_CALLBACK(trg_main_window_toggle_graph_cb), win); + G_CALLBACK(trg_main_window_toggle_graph_cb), win); #endif g_signal_connect(b_props, "activate", G_CALLBACK(open_props_cb), win); g_signal_connect(b_quit, "activate", G_CALLBACK(quit_cb), win); @@ -1398,23 +1619,27 @@ static TrgMenuBar *trg_main_window_menu_bar_new(TrgMainWindow * win) { } #ifndef HAVE_LIBAPPINDICATOR -static void status_icon_activated(GtkStatusIcon * icon G_GNUC_UNUSED, gpointer data) { +static void status_icon_activated(GtkStatusIcon * icon G_GNUC_UNUSED, + gpointer data) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data); gtk_window_deiconify(GTK_WINDOW(data)); gtk_window_present(GTK_WINDOW(data)); - if (priv->timerId > 0) - { - g_source_remove(priv->timerId); - dispatch_async(priv->client, torrent_get(TORRENT_GET_TAG_MODE_FULL), - on_torrent_get_first, data); + if (priv->timerId > 0) { + g_source_remove(priv->timerId); + dispatch_async(priv->client, + torrent_get(TORRENT_GET_TAG_MODE_FULL), + on_torrent_get_first, data); } } static gboolean trg_status_icon_popup_menu_cb(GtkStatusIcon * icon, - gpointer userdata) { - GtkMenu *menu = trg_status_icon_view_menu(TRG_MAIN_WINDOW(userdata), NULL); + gpointer userdata) +{ + GtkMenu *menu = + trg_status_icon_view_menu(TRG_MAIN_WINDOW(userdata), NULL); gtk_menu_popup(menu, NULL, NULL, NULL, NULL, 0, 0); @@ -1422,48 +1647,59 @@ static gboolean trg_status_icon_popup_menu_cb(GtkStatusIcon * icon, } static gboolean status_icon_button_press_event(GtkStatusIcon * icon, - GdkEventButton * event, gpointer data) { + GdkEventButton * event, + gpointer data) +{ if (event->type == GDK_BUTTON_PRESS && event->button == 3) { - GtkMenu *menu = trg_status_icon_view_menu(TRG_MAIN_WINDOW(data), NULL); - gtk_menu_popup(menu, NULL, NULL, NULL, NULL, (event != NULL) ? event->button : 0, gdk_event_get_time((GdkEvent *) event)); - return TRUE; + GtkMenu *menu = + trg_status_icon_view_menu(TRG_MAIN_WINDOW(data), NULL); + gtk_menu_popup(menu, NULL, NULL, NULL, NULL, + (event != NULL) ? event->button : 0, + gdk_event_get_time((GdkEvent *) event)); + return TRUE; } else { - return FALSE; + return FALSE; } } #endif -static void clear_filter_entry_cb(GtkEntry *entry, - GtkEntryIconPosition icon_pos, - GdkEvent *event, - gpointer user_data) +static void clear_filter_entry_cb(GtkEntry * entry, + GtkEntryIconPosition icon_pos, + GdkEvent * event, gpointer user_data) { gtk_entry_set_text(entry, ""); } -static gboolean torrent_tv_key_press_event(GtkWidget * w, GdkEventKey * key, - gpointer data) { +static gboolean torrent_tv_key_press_event(GtkWidget * w, + GdkEventKey * key, + gpointer data) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data); if (key->keyval == GDK_Delete) { - if (key->state & GDK_SHIFT_MASK) - delete_cb(w, data); - else - remove_cb(w, data); - } else if (priv->queuesEnabled && (key->state & GDK_MOD1_MASK) && key->keyval == GDK_Up) { - up_queue_cb(w, data); - } else if (priv->queuesEnabled && (key->state & GDK_MOD1_MASK) && key->keyval == GDK_Down) { - down_queue_cb(w, data); + if (key->state & GDK_SHIFT_MASK) + delete_cb(w, data); + else + remove_cb(w, data); + } else if (priv->queuesEnabled && (key->state & GDK_MOD1_MASK) + && key->keyval == GDK_Up) { + up_queue_cb(w, data); + } else if (priv->queuesEnabled && (key->state & GDK_MOD1_MASK) + && key->keyval == GDK_Down) { + down_queue_cb(w, data); } return FALSE; } -static GtkWidget *trg_imagemenuitem_new(GtkMenuShell * shell, const gchar *text, - char *stock_id, gboolean sensitive, GCallback cb, gpointer cbdata) { +static GtkWidget *trg_imagemenuitem_new(GtkMenuShell * shell, + const gchar * text, char *stock_id, + gboolean sensitive, GCallback cb, + gpointer cbdata) +{ GtkWidget *item = gtk_image_menu_item_new_with_label(stock_id); gtk_image_menu_item_set_use_stock(GTK_IMAGE_MENU_ITEM(item), TRUE); gtk_image_menu_item_set_always_show_image(GTK_IMAGE_MENU_ITEM - (item), TRUE); + (item), TRUE); gtk_menu_item_set_label(GTK_MENU_ITEM(item), text); g_signal_connect(item, "activate", cb, cbdata); gtk_widget_set_sensitive(item, sensitive); @@ -1472,7 +1708,8 @@ static GtkWidget *trg_imagemenuitem_new(GtkMenuShell * shell, const gchar *text, return item; } -static void set_limit_cb(GtkWidget * w, gpointer data) { +static void set_limit_cb(GtkWidget * w, gpointer data) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data); GtkWidget *parent = gtk_widget_get_parent(w); @@ -1486,38 +1723,41 @@ static void set_limit_cb(GtkWidget * w, gpointer data) { JsonObject *args; if (limitIds) - req = torrent_set((JsonArray *) limitIds); + req = torrent_set((JsonArray *) limitIds); else - req = session_set(); + req = session_set(); args = node_get_arguments(req); if (speed >= 0) - json_object_set_int_member(args, speedKey, speed); + json_object_set_int_member(args, speedKey, speed); json_object_set_boolean_member(args, enabledKey, speed >= 0); if (limitIds) - dispatch_async(priv->client, req, on_generic_interactive_action, data); + dispatch_async(priv->client, req, on_generic_interactive_action, + data); else - dispatch_async(priv->client, req, on_session_set, data); + dispatch_async(priv->client, req, on_session_set, data); } static GtkWidget *limit_item_new(TrgMainWindow * win, GtkWidget * menu, - gint64 currentLimit, gfloat limit) { + gint64 currentLimit, gfloat limit) +{ char speed[32]; GtkWidget *item; gboolean active = limit < 0 ? FALSE : (currentLimit == (gint64) limit); if (limit >= 1000) - g_snprintf(speed, sizeof(speed), "%.2f MB/s", limit / 1024); + g_snprintf(speed, sizeof(speed), "%.2f MB/s", limit / 1024); else - g_snprintf(speed, sizeof(speed), "%.0f KB/s", limit); + g_snprintf(speed, sizeof(speed), "%.0f KB/s", limit); item = gtk_check_menu_item_new_with_label(speed); /* Yeah, I know it's unsafe to cast from a float to an int, but its safe here */ - g_object_set_data(G_OBJECT(item), "limit", GINT_TO_POINTER((gint) limit)); + g_object_set_data(G_OBJECT(item), "limit", + GINT_TO_POINTER((gint) limit)); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), active); g_signal_connect(item, "activate", G_CALLBACK(set_limit_cb), win); @@ -1526,7 +1766,9 @@ static GtkWidget *limit_item_new(TrgMainWindow * win, GtkWidget * menu, } static GtkWidget *limit_menu_new(TrgMainWindow * win, gchar * title, - gchar * enabledKey, gchar * speedKey, JsonArray * ids) { + gchar * enabledKey, gchar * speedKey, + JsonArray * ids) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win); TrgClient *client = priv->client; JsonObject *current = NULL; @@ -1535,29 +1777,31 @@ static GtkWidget *limit_menu_new(TrgMainWindow * win, gchar * title, gint64 limit; if (ids) - get_torrent_data(trg_client_get_torrent_table(client), - priv->selectedTorrentId, ¤t, &iter); + get_torrent_data(trg_client_get_torrent_table(client), + priv->selectedTorrentId, ¤t, &iter); else - current = trg_client_get_session(client); + current = trg_client_get_session(client); limit - = json_object_get_boolean_member(current, enabledKey) ? json_object_get_int_member( - current, speedKey) - : -1; + = + json_object_get_boolean_member(current, + enabledKey) ? + json_object_get_int_member(current, speedKey) + : -1; toplevel = gtk_image_menu_item_new_with_label(GTK_STOCK_NETWORK); gtk_image_menu_item_set_use_stock(GTK_IMAGE_MENU_ITEM(toplevel), TRUE); gtk_image_menu_item_set_always_show_image(GTK_IMAGE_MENU_ITEM - (toplevel), TRUE); + (toplevel), TRUE); gtk_menu_item_set_label(GTK_MENU_ITEM(toplevel), title); menu = gtk_menu_new(); g_object_set_data_full(G_OBJECT(menu), "speedKey", g_strdup(speedKey), - g_free); - g_object_set_data_full(G_OBJECT(menu), "enabledKey", g_strdup(enabledKey), - g_free); + g_free); + g_object_set_data_full(G_OBJECT(menu), "enabledKey", + g_strdup(enabledKey), g_free); g_object_set_data_full(G_OBJECT(menu), "limit-ids", ids, - (GDestroyNotify) json_array_unref); + (GDestroyNotify) json_array_unref); item = gtk_check_menu_item_new_with_label(_("No Limit")); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), limit < 0); @@ -1565,7 +1809,8 @@ static GtkWidget *limit_menu_new(TrgMainWindow * win, gchar * title, g_signal_connect(item, "activate", G_CALLBACK(set_limit_cb), win); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); - gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new()); + gtk_menu_shell_append(GTK_MENU_SHELL(menu), + gtk_separator_menu_item_new()); limit_item_new(win, menu, limit, 0); limit_item_new(win, menu, limit, 5); @@ -1592,54 +1837,58 @@ static GtkWidget *limit_menu_new(TrgMainWindow * win, gchar * title, return toplevel; } -static void exec_cmd_cb(GtkWidget *w, gpointer data) { +static void exec_cmd_cb(GtkWidget * w, gpointer data) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data); - JsonObject *cmd_obj = (JsonObject*) g_object_get_data(G_OBJECT(w), - "cmd-object"); - GtkTreeSelection *selection = gtk_tree_view_get_selection( - GTK_TREE_VIEW(priv->torrentTreeView)); + JsonObject *cmd_obj = (JsonObject *) g_object_get_data(G_OBJECT(w), + "cmd-object"); + GtkTreeSelection *selection = + gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->torrentTreeView)); GtkTreeModel *model; - GList *selectedRows = gtk_tree_selection_get_selected_rows(selection, &model); + GList *selectedRows = + gtk_tree_selection_get_selected_rows(selection, &model); GError *cmd_error = NULL; gchar *cmd_line, **argv; - cmd_line = build_remote_exec_cmd( - priv->client, - model, - selectedRows, - json_object_get_string_member(cmd_obj, - TRG_PREFS_KEY_EXEC_COMMANDS_SUBKEY_CMD)); + cmd_line = build_remote_exec_cmd(priv->client, + model, + selectedRows, + json_object_get_string_member(cmd_obj, + TRG_PREFS_KEY_EXEC_COMMANDS_SUBKEY_CMD)); - g_debug("Exec: %s",cmd_line); + g_debug("Exec: %s", cmd_line); if (!cmd_line) - return; + return; //GTK has bug, won't let you pass a string here containing a quoted param, so use parse and then spawn // rather than g_spawn_command_line_async(cmd_line,&cmd_error); g_shell_parse_argv(cmd_line, NULL, &argv, NULL); g_spawn_async(NULL, argv, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL, NULL, - &cmd_error); + &cmd_error); - g_list_foreach (selectedRows, (GFunc) gtk_tree_path_free, NULL); + g_list_foreach(selectedRows, (GFunc) gtk_tree_path_free, NULL); g_list_free(selectedRows); g_strfreev(argv); g_free(cmd_line); if (cmd_error) { - GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(data), - GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "%s", - cmd_error->message); - gtk_window_set_title(GTK_WINDOW(dialog), _("Error")); - gtk_dialog_run(GTK_DIALOG(dialog)); - gtk_widget_destroy(dialog); - g_error_free(cmd_error); + GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(data), + GTK_DIALOG_MODAL, + GTK_MESSAGE_ERROR, + GTK_BUTTONS_OK, "%s", + cmd_error->message); + gtk_window_set_title(GTK_WINDOW(dialog), _("Error")); + gtk_dialog_run(GTK_DIALOG(dialog)); + gtk_widget_destroy(dialog); + g_error_free(cmd_error); } } static void trg_torrent_tv_view_menu(GtkWidget * treeview, - GdkEventButton * event, gpointer data) { + GdkEventButton * event, gpointer data) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data); TrgPrefs *prefs = trg_client_get_prefs(priv->client); GtkWidget *menu; @@ -1651,145 +1900,202 @@ static void trg_torrent_tv_view_menu(GtkWidget * treeview, ids = build_json_id_array(TRG_TORRENT_TREE_VIEW(treeview)); trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Properties"), - GTK_STOCK_PROPERTIES, TRUE, G_CALLBACK(open_props_cb), data); + GTK_STOCK_PROPERTIES, TRUE, + G_CALLBACK(open_props_cb), data); trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Resume"), - GTK_STOCK_MEDIA_PLAY, TRUE, G_CALLBACK(resume_cb), data); + GTK_STOCK_MEDIA_PLAY, TRUE, + G_CALLBACK(resume_cb), data); trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Pause"), - GTK_STOCK_MEDIA_PAUSE, TRUE, G_CALLBACK(pause_cb), data); - trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Verify"), GTK_STOCK_REFRESH, - TRUE, G_CALLBACK(verify_cb), data); + GTK_STOCK_MEDIA_PAUSE, TRUE, + G_CALLBACK(pause_cb), data); + trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Verify"), + GTK_STOCK_REFRESH, TRUE, G_CALLBACK(verify_cb), + data); trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Re-announce"), - GTK_STOCK_REFRESH, TRUE, G_CALLBACK(reannounce_cb), data); - trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Move"), GTK_STOCK_HARDDISK, - TRUE, G_CALLBACK(move_cb), data); - trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Remove"), GTK_STOCK_REMOVE, - TRUE, G_CALLBACK(remove_cb), data); + GTK_STOCK_REFRESH, TRUE, + G_CALLBACK(reannounce_cb), data); + trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Move"), + GTK_STOCK_HARDDISK, TRUE, G_CALLBACK(move_cb), + data); + trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Remove"), + GTK_STOCK_REMOVE, TRUE, G_CALLBACK(remove_cb), + data); trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Remove & Delete"), - GTK_STOCK_CLEAR, TRUE, G_CALLBACK(delete_cb), data); + GTK_STOCK_CLEAR, TRUE, G_CALLBACK(delete_cb), + data); - cmds = trg_prefs_get_array(prefs, TRG_PREFS_KEY_EXEC_COMMANDS, TRG_PREFS_CONNECTION); + cmds = + trg_prefs_get_array(prefs, TRG_PREFS_KEY_EXEC_COMMANDS, + TRG_PREFS_CONNECTION); n_cmds = json_array_get_length(cmds); if (n_cmds > 0) { - GList *cmds_list = json_array_get_elements(cmds); - GtkMenuShell *cmds_shell; - GList *cmds_li; - - if (n_cmds < 3) { - gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new()); - cmds_shell = GTK_MENU_SHELL(menu); - } else { - GtkImageMenuItem *cmds_menu = GTK_IMAGE_MENU_ITEM(gtk_image_menu_item_new_with_label(GTK_STOCK_EXECUTE)); - gtk_image_menu_item_set_use_stock(cmds_menu, TRUE); - gtk_image_menu_item_set_always_show_image(cmds_menu, TRUE); - gtk_menu_item_set_label(GTK_MENU_ITEM(cmds_menu), _("Actions")); - - cmds_shell = GTK_MENU_SHELL(gtk_menu_new()); - gtk_menu_item_set_submenu(GTK_MENU_ITEM(cmds_menu), GTK_WIDGET(cmds_shell)); - gtk_menu_shell_append(GTK_MENU_SHELL(menu), GTK_WIDGET(cmds_menu)); - } - - for (cmds_li = cmds_list; cmds_li; cmds_li = g_list_next(cmds_li)) - { - JsonObject *cmd_obj = json_node_get_object((JsonNode*)cmds_li->data); - const gchar *cmd_label = json_object_get_string_member(cmd_obj, "label"); - GtkWidget *item = trg_imagemenuitem_new(cmds_shell, cmd_label, - GTK_STOCK_EXECUTE, TRUE, G_CALLBACK(exec_cmd_cb), data); - g_object_set_data(G_OBJECT(item), "cmd-object", cmd_obj); - } - - g_list_free(cmds_list); + GList *cmds_list = json_array_get_elements(cmds); + GtkMenuShell *cmds_shell; + GList *cmds_li; + + if (n_cmds < 3) { + gtk_menu_shell_append(GTK_MENU_SHELL(menu), + gtk_separator_menu_item_new()); + cmds_shell = GTK_MENU_SHELL(menu); + } else { + GtkImageMenuItem *cmds_menu = + GTK_IMAGE_MENU_ITEM(gtk_image_menu_item_new_with_label + (GTK_STOCK_EXECUTE)); + gtk_image_menu_item_set_use_stock(cmds_menu, TRUE); + gtk_image_menu_item_set_always_show_image(cmds_menu, TRUE); + gtk_menu_item_set_label(GTK_MENU_ITEM(cmds_menu), + _("Actions")); + + cmds_shell = GTK_MENU_SHELL(gtk_menu_new()); + gtk_menu_item_set_submenu(GTK_MENU_ITEM(cmds_menu), + GTK_WIDGET(cmds_shell)); + gtk_menu_shell_append(GTK_MENU_SHELL(menu), + GTK_WIDGET(cmds_menu)); + } + + for (cmds_li = cmds_list; cmds_li; cmds_li = g_list_next(cmds_li)) { + JsonObject *cmd_obj = + json_node_get_object((JsonNode *) cmds_li->data); + const gchar *cmd_label = + json_object_get_string_member(cmd_obj, "label"); + GtkWidget *item = trg_imagemenuitem_new(cmds_shell, cmd_label, + GTK_STOCK_EXECUTE, + TRUE, + G_CALLBACK + (exec_cmd_cb), data); + g_object_set_data(G_OBJECT(item), "cmd-object", cmd_obj); + } + + g_list_free(cmds_list); } - gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new()); + gtk_menu_shell_append(GTK_MENU_SHELL(menu), + gtk_separator_menu_item_new()); if (priv->queuesEnabled) { - trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Start Now"), - GTK_STOCK_MEDIA_PLAY, TRUE, G_CALLBACK(start_now_cb), data); - trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Move Up Queue"), - GTK_STOCK_GO_UP, TRUE, G_CALLBACK(up_queue_cb), data); - trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Move Down Queue"), - GTK_STOCK_GO_DOWN, TRUE, G_CALLBACK(down_queue_cb), data); - trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Bottom Of Queue"), - GTK_STOCK_GOTO_BOTTOM, TRUE, G_CALLBACK(bottom_queue_cb), data); - trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Top Of Queue"), - GTK_STOCK_GOTO_TOP, TRUE, G_CALLBACK(top_queue_cb), data); - gtk_menu_shell_append(GTK_MENU_SHELL(menu), - gtk_separator_menu_item_new()); + trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Start Now"), + GTK_STOCK_MEDIA_PLAY, TRUE, + G_CALLBACK(start_now_cb), data); + trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Move Up Queue"), + GTK_STOCK_GO_UP, TRUE, + G_CALLBACK(up_queue_cb), data); + trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Move Down Queue"), + GTK_STOCK_GO_DOWN, TRUE, + G_CALLBACK(down_queue_cb), data); + trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Bottom Of Queue"), + GTK_STOCK_GOTO_BOTTOM, TRUE, + G_CALLBACK(bottom_queue_cb), data); + trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Top Of Queue"), + GTK_STOCK_GOTO_TOP, TRUE, + G_CALLBACK(top_queue_cb), data); + gtk_menu_shell_append(GTK_MENU_SHELL(menu), + gtk_separator_menu_item_new()); } - gtk_menu_shell_append( - GTK_MENU_SHELL(menu), - limit_menu_new(TRG_MAIN_WINDOW(data), _("Down Limit"), - FIELD_DOWNLOAD_LIMITED, FIELD_DOWNLOAD_LIMIT, ids)); - gtk_menu_shell_append( - GTK_MENU_SHELL(menu), - limit_menu_new(TRG_MAIN_WINDOW(data), _("Up Limit"), - FIELD_UPLOAD_LIMITED, FIELD_UPLOAD_LIMIT, ids)); + gtk_menu_shell_append(GTK_MENU_SHELL(menu), + limit_menu_new(TRG_MAIN_WINDOW(data), + _("Down Limit"), + FIELD_DOWNLOAD_LIMITED, + FIELD_DOWNLOAD_LIMIT, ids)); + gtk_menu_shell_append(GTK_MENU_SHELL(menu), + limit_menu_new(TRG_MAIN_WINDOW(data), + _("Up Limit"), + FIELD_UPLOAD_LIMITED, + FIELD_UPLOAD_LIMIT, ids)); gtk_widget_show_all(menu); gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, - (event != NULL) ? event->button : 0, - gdk_event_get_time((GdkEvent *) event)); + (event != NULL) ? event->button : 0, + gdk_event_get_time((GdkEvent *) event)); } -static GtkMenu *trg_status_icon_view_menu(TrgMainWindow *win, const gchar *msg) { +static GtkMenu *trg_status_icon_view_menu(TrgMainWindow * win, + const gchar * msg) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win); TrgPrefs *prefs = trg_client_get_prefs(priv->client); gboolean connected = trg_client_is_connected(priv->client); GtkWidget *menu, *connect; - + menu = gtk_menu_new(); #ifdef HAVE_LIBAPPINDICATOR if (msg) { - priv->appIndicatorStatusItem = gtk_menu_item_new_with_label(msg); - gtk_widget_set_sensitive(priv->appIndicatorStatusItem, FALSE); - gtk_menu_shell_append(GTK_MENU_SHELL(menu), priv->appIndicatorStatusItem); + priv->appIndicatorStatusItem = gtk_menu_item_new_with_label(msg); + gtk_widget_set_sensitive(priv->appIndicatorStatusItem, FALSE); + gtk_menu_shell_append(GTK_MENU_SHELL(menu), + priv->appIndicatorStatusItem); + + if (connected) { + priv->appIndicatorDownloadingItem = gtk_menu_item_new(); + gtk_widget_set_visible(priv->appIndicatorDownloadingItem, + FALSE); + gtk_widget_set_sensitive(priv->appIndicatorDownloadingItem, + FALSE); + gtk_menu_shell_append(GTK_MENU_SHELL(menu), + priv->appIndicatorDownloadingItem); + + priv->appIndicatorSeedingItem = gtk_menu_item_new(); + gtk_widget_set_visible(priv->appIndicatorSeedingItem, FALSE); + gtk_widget_set_sensitive(priv->appIndicatorSeedingItem, FALSE); + gtk_menu_shell_append(GTK_MENU_SHELL(menu), + priv->appIndicatorSeedingItem); + } + + priv->appIndicatorSepItem = gtk_separator_menu_item_new(); + gtk_widget_set_sensitive(priv->appIndicatorSepItem, FALSE); + gtk_menu_shell_append(GTK_MENU_SHELL(menu), + priv->appIndicatorSepItem); } #endif - + connect = gtk_image_menu_item_new_with_label(GTK_STOCK_CONNECT); gtk_image_menu_item_set_use_stock(GTK_IMAGE_MENU_ITEM(connect), TRUE); - gtk_image_menu_item_set_always_show_image(GTK_IMAGE_MENU_ITEM(connect), TRUE); + gtk_image_menu_item_set_always_show_image(GTK_IMAGE_MENU_ITEM(connect), + TRUE); gtk_menu_item_set_label(GTK_MENU_ITEM(connect), _("Connect")); - gtk_menu_item_set_submenu(GTK_MENU_ITEM(connect), trg_menu_bar_file_connect_menu_new(win, prefs)); + gtk_menu_item_set_submenu(GTK_MENU_ITEM(connect), + trg_menu_bar_file_connect_menu_new(win, + prefs)); gtk_menu_shell_append(GTK_MENU_SHELL(menu), connect); if (connected) { - trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Disconnect"), - GTK_STOCK_DISCONNECT, connected, G_CALLBACK(disconnect_cb), - win); - - trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Add"), GTK_STOCK_ADD, - connected, G_CALLBACK(add_cb), win); - - trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Add from URL"), - GTK_STOCK_ADD, connected, G_CALLBACK(add_url_cb), win); - - gtk_menu_shell_append( - GTK_MENU_SHELL(menu), - limit_menu_new(win, _("Down Limit"), - SGET_SPEED_LIMIT_DOWN_ENABLED, SGET_SPEED_LIMIT_DOWN, - NULL)); - gtk_menu_shell_append( - GTK_MENU_SHELL(menu), - limit_menu_new(win, _("Up Limit"), - SGET_SPEED_LIMIT_UP_ENABLED, SGET_SPEED_LIMIT_UP, NULL)); - - trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Resume All"), - GTK_STOCK_MEDIA_PLAY, connected, G_CALLBACK(resume_all_cb), - win); - - trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Pause All"), - GTK_STOCK_MEDIA_PAUSE, connected, G_CALLBACK(pause_all_cb), - win); + trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Disconnect"), + GTK_STOCK_DISCONNECT, connected, + G_CALLBACK(disconnect_cb), win); + + trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Add"), + GTK_STOCK_ADD, connected, G_CALLBACK(add_cb), + win); + + trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Add from URL"), + GTK_STOCK_ADD, connected, + G_CALLBACK(add_url_cb), win); + + gtk_menu_shell_append(GTK_MENU_SHELL(menu), + limit_menu_new(win, _("Down Limit"), + SGET_SPEED_LIMIT_DOWN_ENABLED, + SGET_SPEED_LIMIT_DOWN, NULL)); + gtk_menu_shell_append(GTK_MENU_SHELL(menu), + limit_menu_new(win, _("Up Limit"), + SGET_SPEED_LIMIT_UP_ENABLED, + SGET_SPEED_LIMIT_UP, NULL)); + + trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Resume All"), + GTK_STOCK_MEDIA_PLAY, connected, + G_CALLBACK(resume_all_cb), win); + + trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Pause All"), + GTK_STOCK_MEDIA_PAUSE, connected, + G_CALLBACK(pause_all_cb), win); } - gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new()); + gtk_menu_shell_append(GTK_MENU_SHELL(menu), + gtk_separator_menu_item_new()); trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Quit"), GTK_STOCK_QUIT, - TRUE, G_CALLBACK(quit_cb), win); + TRUE, G_CALLBACK(quit_cb), win); gtk_widget_show_all(menu); @@ -1797,49 +2103,56 @@ static GtkMenu *trg_status_icon_view_menu(TrgMainWindow *win, const gchar *msg) } static gboolean torrent_tv_button_pressed_cb(GtkWidget * treeview, - GdkEventButton * event, gpointer userdata) { + GdkEventButton * event, + gpointer userdata) +{ GtkTreeSelection *selection; GtkTreePath *path; if (event->type == GDK_BUTTON_PRESS && event->button == 3) { - selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)); + selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)); - if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(treeview), - (gint) event->x, (gint) event->y, &path, NULL, NULL, NULL)) { - if (!gtk_tree_selection_path_is_selected(selection, path)) { - gtk_tree_selection_unselect_all(selection); - gtk_tree_selection_select_path(selection, path); - } + if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(treeview), + (gint) event->x, (gint) event->y, + &path, NULL, NULL, NULL)) { + if (!gtk_tree_selection_path_is_selected(selection, path)) { + gtk_tree_selection_unselect_all(selection); + gtk_tree_selection_select_path(selection, path); + } - gtk_tree_path_free(path); + gtk_tree_path_free(path); - trg_torrent_tv_view_menu(treeview, event, userdata); - return TRUE; - } + trg_torrent_tv_view_menu(treeview, event, userdata); + return TRUE; + } } return FALSE; } static gboolean torrent_tv_popup_menu_cb(GtkWidget * treeview, - gpointer userdata) { + gpointer userdata) +{ trg_torrent_tv_view_menu(treeview, NULL, userdata); return TRUE; } static gboolean window_state_event(GtkWidget * widget, - GdkEventWindowState * event, gpointer trayIcon) { + GdkEventWindowState * event, + gpointer trayIcon) +{ #ifndef HAVE_LIBAPPINDICATOR TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(widget); TrgPrefs *prefs = trg_client_get_prefs(priv->client); - if (priv->statusIcon && event->changed_mask == GDK_WINDOW_STATE_ICONIFIED - && (event->new_window_state == GDK_WINDOW_STATE_ICONIFIED - || event->new_window_state == (GDK_WINDOW_STATE_ICONIFIED - | GDK_WINDOW_STATE_MAXIMIZED)) - && trg_prefs_get_bool(prefs, TRG_PREFS_KEY_SYSTEM_TRAY_MINIMISE, - TRG_PREFS_GLOBAL)) { - gtk_widget_hide(GTK_WIDGET(widget)); + if (priv->statusIcon + && event->changed_mask == GDK_WINDOW_STATE_ICONIFIED + && (event->new_window_state == GDK_WINDOW_STATE_ICONIFIED + || event->new_window_state == + (GDK_WINDOW_STATE_ICONIFIED | GDK_WINDOW_STATE_MAXIMIZED)) + && trg_prefs_get_bool(prefs, TRG_PREFS_KEY_SYSTEM_TRAY_MINIMISE, + TRG_PREFS_GLOBAL)) { + gtk_widget_hide(GTK_WIDGET(widget)); } return TRUE; @@ -1848,107 +2161,125 @@ static gboolean window_state_event(GtkWidget * widget, #endif } -void trg_main_window_remove_status_icon(TrgMainWindow * win) { +void trg_main_window_remove_status_icon(TrgMainWindow * win) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win); #ifdef HAVE_LIBAPPINDICATOR if (priv->appIndicator) - g_object_unref(G_OBJECT(priv->appIndicator)); + g_object_unref(G_OBJECT(priv->appIndicator)); priv->appIndicator = NULL; #else if (priv->statusIcon) - g_object_unref(G_OBJECT(priv->statusIcon)); + g_object_unref(G_OBJECT(priv->statusIcon)); priv->statusIcon = NULL; #endif } #ifndef TRG_NO_GRAPH -void trg_main_window_add_graph(TrgMainWindow * win, gboolean show) { +void trg_main_window_add_graph(TrgMainWindow * win, gboolean show) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win); - priv->graph = trg_torrent_graph_new(gtk_widget_get_style(priv->notebook)); - priv->graphNotebookIndex = gtk_notebook_append_page( - GTK_NOTEBOOK(priv->notebook), GTK_WIDGET(priv->graph), - gtk_label_new(_("Graph"))); + priv->graph = + trg_torrent_graph_new(gtk_widget_get_style(priv->notebook)); + priv->graphNotebookIndex = + gtk_notebook_append_page(GTK_NOTEBOOK(priv->notebook), + GTK_WIDGET(priv->graph), + gtk_label_new(_("Graph"))); if (show) - gtk_widget_show_all(priv->notebook); + gtk_widget_show_all(priv->notebook); trg_torrent_graph_start(priv->graph); } -void trg_main_window_remove_graph(TrgMainWindow * win) { +void trg_main_window_remove_graph(TrgMainWindow * win) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win); if (priv->graphNotebookIndex >= 0) { - gtk_notebook_remove_page(GTK_NOTEBOOK(priv->notebook), - priv->graphNotebookIndex); - priv->graphNotebookIndex = -1; + gtk_notebook_remove_page(GTK_NOTEBOOK(priv->notebook), + priv->graphNotebookIndex); + priv->graphNotebookIndex = -1; } } #endif -void trg_main_window_add_status_icon(TrgMainWindow * win) { +void trg_main_window_add_status_icon(TrgMainWindow * win) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win); #ifdef HAVE_LIBAPPINDICATOR - if (priv->appIndicator = app_indicator_new(PACKAGE_NAME, PACKAGE_NAME, APP_INDICATOR_CATEGORY_APPLICATION_STATUS)) { - app_indicator_set_status(priv->appIndicator, APP_INDICATOR_STATUS_ACTIVE); - app_indicator_set_menu(priv->appIndicator, trg_status_icon_view_menu(win, NULL)); + if ((priv->appIndicator = + app_indicator_new(PACKAGE_NAME, PACKAGE_NAME, + APP_INDICATOR_CATEGORY_APPLICATION_STATUS))) { + app_indicator_set_status(priv->appIndicator, + APP_INDICATOR_STATUS_ACTIVE); + app_indicator_set_menu(priv->appIndicator, + trg_status_icon_view_menu(win, NULL)); } #else if (!priv->icon) - return; + return; priv->statusIcon = gtk_status_icon_new_from_pixbuf(priv->icon); gtk_status_icon_set_screen(priv->statusIcon, - gtk_window_get_screen(GTK_WINDOW(win))); + gtk_window_get_screen(GTK_WINDOW(win))); g_signal_connect(priv->statusIcon, "activate", - G_CALLBACK(status_icon_activated), win); + G_CALLBACK(status_icon_activated), win); g_signal_connect(priv->statusIcon, "button-press-event", - G_CALLBACK(status_icon_button_press_event), win); + G_CALLBACK(status_icon_button_press_event), win); g_signal_connect(priv->statusIcon, "popup-menu", - G_CALLBACK(trg_status_icon_popup_menu_cb), win); + G_CALLBACK(trg_status_icon_popup_menu_cb), win); gtk_status_icon_set_visible(priv->statusIcon, TRUE); #endif - connchange_whatever_statusicon(win, trg_client_is_connected(priv->client)); + connchange_whatever_statusicon(win, + trg_client_is_connected(priv->client)); } -TrgStateSelector *trg_main_window_get_state_selector(TrgMainWindow * win) { +TrgStateSelector *trg_main_window_get_state_selector(TrgMainWindow * win) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win); return priv->stateSelector; } -static gboolean trg_main_window_config_event(GtkWidget *widget, - GdkEvent *event, gpointer user_data G_GNUC_UNUSED) { +static gboolean trg_main_window_config_event(GtkWidget * widget, + GdkEvent * event, + gpointer user_data + G_GNUC_UNUSED) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(widget); priv->width = event->configure.width; priv->height = event->configure.height; return FALSE; } -static void trg_client_session_updated_cb(TrgClient *tc, JsonObject *session, - gpointer data) { +static void trg_client_session_updated_cb(TrgClient * tc, + JsonObject * session, + gpointer data) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data); gboolean queuesEnabled; trg_status_bar_session_update(priv->statusBar, session); if (json_object_has_member(session, SGET_DOWNLOAD_QUEUE_ENABLED)) { - queuesEnabled = json_object_get_boolean_member(session, - SGET_DOWNLOAD_QUEUE_ENABLED) || json_object_get_boolean_member( - session, SGET_SEED_QUEUE_ENABLED); + queuesEnabled = json_object_get_boolean_member(session, + SGET_DOWNLOAD_QUEUE_ENABLED) + || json_object_get_boolean_member(session, + SGET_SEED_QUEUE_ENABLED); } else { - queuesEnabled = FALSE; + queuesEnabled = FALSE; } if (priv->queuesEnabled != queuesEnabled) { - trg_menu_bar_set_supports_queues(priv->menuBar, queuesEnabled); - trg_state_selector_set_queues_enabled(priv->stateSelector, - queuesEnabled); + trg_menu_bar_set_supports_queues(priv->menuBar, queuesEnabled); + trg_state_selector_set_queues_enabled(priv->stateSelector, + queuesEnabled); } priv->queuesEnabled = queuesEnabled; @@ -1956,40 +2287,46 @@ static void trg_client_session_updated_cb(TrgClient *tc, JsonObject *session, /* Drag & Drop support */ static GtkTargetEntry target_list[] = { - /* datatype (string), restrictions on DnD (GtkTargetFlags), datatype (int) */ - { "text/uri-list", GTK_TARGET_OTHER_APP | GTK_TARGET_OTHER_WIDGET, 0 } + /* datatype (string), restrictions on DnD (GtkTargetFlags), datatype (int) */ + {"text/uri-list", GTK_TARGET_OTHER_APP | GTK_TARGET_OTHER_WIDGET, 0} }; -static guint n_targets = G_N_ELEMENTS (target_list); -static void on_dropped_file( - GtkWidget *widget, GdkDragContext *context, gint x, gint y, - GtkSelectionData *data, guint info, guint time, gpointer user_data) { +static guint n_targets = G_N_ELEMENTS(target_list); + +static void on_dropped_file(GtkWidget * widget, GdkDragContext * context, + gint x, gint y, GtkSelectionData * data, + guint info, guint time, gpointer user_data) +{ TrgMainWindow *win = user_data; - if ((gtk_selection_data_get_length(data) >= 0) && (gtk_selection_data_get_format(data) == 8)) - { - if (gdk_drag_context_get_actions(context) == GDK_ACTION_MOVE) { - g_debug ("GDK_ACTION_MOVE"); - gchar **uri_list = gtk_selection_data_get_uris(data); - guint num_files = g_strv_length(uri_list); - gchar **file_list = g_new0(gchar *,num_files+1); - int i; - for (i = 0; i < num_files; i++) { - file_list[i] = g_filename_from_uri( uri_list[i], NULL, NULL ); - g_debug ("to be added: %s",file_list[i]); - } - g_strfreev(uri_list); - gtk_drag_finish (context, TRUE, FALSE, time); - trg_add_from_filename(win,file_list); - return; - } + if ((gtk_selection_data_get_length(data) >= 0) + && (gtk_selection_data_get_format(data) == 8)) { + if (gdk_drag_context_get_actions(context) == GDK_ACTION_MOVE) { + g_debug("GDK_ACTION_MOVE"); + gchar **uri_list = gtk_selection_data_get_uris(data); + guint num_files = g_strv_length(uri_list); + gchar **file_list = g_new0(gchar *, num_files + 1); + int i; + for (i = 0; i < num_files; i++) { + file_list[i] = + g_filename_from_uri(uri_list[i], NULL, NULL); + g_debug("to be added: %s", file_list[i]); + } + g_strfreev(uri_list); + gtk_drag_finish(context, TRUE, FALSE, time); + trg_add_from_filename(win, file_list); + return; + } } - gtk_drag_finish (context, FALSE, FALSE, time); + gtk_drag_finish(context, FALSE, FALSE, time); } static GObject *trg_main_window_constructor(GType type, - guint n_construct_properties, GObjectConstructParam * construct_params) { + guint n_construct_properties, + GObjectConstructParam * + construct_params) +{ TrgMainWindow *self; TrgMainWindowPrivate *priv; GtkWidget *w; @@ -2001,9 +2338,9 @@ static GObject *trg_main_window_constructor(GType type, TrgPrefs *prefs; self = TRG_MAIN_WINDOW(G_OBJECT_CLASS - (trg_main_window_parent_class)->constructor - (type, n_construct_properties, - construct_params)); + (trg_main_window_parent_class)->constructor + (type, n_construct_properties, + construct_params)); priv = TRG_MAIN_WINDOW_GET_PRIVATE(self); priv->queuesEnabled = TRUE; @@ -2012,83 +2349,88 @@ static GObject *trg_main_window_constructor(GType type, theme = gtk_icon_theme_get_default(); priv->icon = gtk_icon_theme_load_icon(theme, PACKAGE_NAME, 48, - GTK_ICON_LOOKUP_USE_BUILTIN, NULL); + GTK_ICON_LOOKUP_USE_BUILTIN, + NULL); #ifdef HAVE_LIBNOTIFY notify_init(PACKAGE_NAME); #endif if (priv->icon) - gtk_window_set_default_icon(priv->icon); + gtk_window_set_default_icon(priv->icon); gtk_window_set_title(GTK_WINDOW(self), _("Transmission Remote")); gtk_window_set_default_size(GTK_WINDOW(self), 1000, 600); g_signal_connect(G_OBJECT(self), "delete-event", - G_CALLBACK(delete_event), NULL); + G_CALLBACK(delete_event), NULL); g_signal_connect(G_OBJECT(self), "destroy", G_CALLBACK(destroy_window), - NULL); + NULL); g_signal_connect(G_OBJECT(self), "window-state-event", - G_CALLBACK(window_state_event), NULL); + G_CALLBACK(window_state_event), NULL); g_signal_connect(G_OBJECT(self), "configure-event", - G_CALLBACK(trg_main_window_config_event), NULL); + G_CALLBACK(trg_main_window_config_event), NULL); priv->torrentModel = trg_torrent_model_new(); trg_client_set_torrent_table(priv->client, - get_torrent_table(priv->torrentModel)); + get_torrent_table(priv->torrentModel)); g_signal_connect(priv->torrentModel, "torrent-completed", - G_CALLBACK(on_torrent_completed), self); + G_CALLBACK(on_torrent_completed), self); g_signal_connect(priv->torrentModel, "torrent-added", - G_CALLBACK(on_torrent_added), self); + G_CALLBACK(on_torrent_added), self); g_signal_connect(priv->torrentModel, "update-filters", - G_CALLBACK(on_update_filters), self); + G_CALLBACK(on_update_filters), self); - priv->sortedTorrentModel = gtk_tree_model_sort_new_with_model( - GTK_TREE_MODEL(priv->torrentModel)); + priv->sortedTorrentModel = + gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL + (priv->torrentModel)); - priv->filteredTorrentModel = trg_sortable_filtered_model_new( - GTK_TREE_SORTABLE(priv->sortedTorrentModel), NULL); + priv->filteredTorrentModel = + trg_sortable_filtered_model_new(GTK_TREE_SORTABLE + (priv->sortedTorrentModel), NULL); gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER - (priv->filteredTorrentModel), trg_torrent_tree_view_visible_func, - self, NULL); + (priv->filteredTorrentModel), + trg_torrent_tree_view_visible_func, + self, NULL); priv->torrentTreeView = trg_main_window_torrent_tree_view_new(self, - priv->filteredTorrentModel); + priv-> + filteredTorrentModel); g_signal_connect(priv->torrentTreeView, "key-press-event", - G_CALLBACK(torrent_tv_key_press_event), self); + G_CALLBACK(torrent_tv_key_press_event), self); g_signal_connect(priv->torrentTreeView, "popup-menu", - G_CALLBACK(torrent_tv_popup_menu_cb), self); + G_CALLBACK(torrent_tv_popup_menu_cb), self); g_signal_connect(priv->torrentTreeView, "button-press-event", - G_CALLBACK(torrent_tv_button_pressed_cb), self); + G_CALLBACK(torrent_tv_button_pressed_cb), self); g_signal_connect(priv->torrentTreeView, "row-activated", - G_CALLBACK(torrent_tv_onRowActivated), self); + G_CALLBACK(torrent_tv_onRowActivated), self); outerVbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(self), outerVbox); priv->menuBar = trg_main_window_menu_bar_new(self); - gtk_box_pack_start(GTK_BOX(outerVbox), GTK_WIDGET(priv->menuBar), FALSE, - FALSE, 0); + gtk_box_pack_start(GTK_BOX(outerVbox), GTK_WIDGET(priv->menuBar), + FALSE, FALSE, 0); toolbarHbox = gtk_hbox_new(FALSE, 0); priv->toolBar = trg_main_window_toolbar_new(self); - gtk_box_pack_start(GTK_BOX(toolbarHbox), GTK_WIDGET(priv->toolBar), TRUE, - TRUE, 0); + gtk_box_pack_start(GTK_BOX(toolbarHbox), GTK_WIDGET(priv->toolBar), + TRUE, TRUE, 0); w = gtk_entry_new(); gtk_entry_set_icon_from_stock(GTK_ENTRY(w), GTK_ENTRY_ICON_SECONDARY, - GTK_STOCK_CLEAR); + GTK_STOCK_CLEAR); g_signal_connect(w, "icon-release", - G_CALLBACK(clear_filter_entry_cb), NULL); + G_CALLBACK(clear_filter_entry_cb), NULL); gtk_box_pack_start(GTK_BOX(toolbarHbox), w, FALSE, FALSE, 0); g_object_set(w, "secondary-icon-sensitive", FALSE, NULL); priv->filterEntry = w; g_signal_connect(G_OBJECT(priv->filterEntry), "changed", - G_CALLBACK(entry_filter_changed_cb), self); + G_CALLBACK(entry_filter_changed_cb), self); gtk_box_pack_start(GTK_BOX(outerVbox), GTK_WIDGET(toolbarHbox), FALSE, - FALSE, 0); + FALSE, 0); priv->vpaned = gtk_vpaned_new(); priv->hpaned = gtk_hpaned_new(); @@ -2096,83 +2438,89 @@ static GObject *trg_main_window_constructor(GType type, gtk_paned_pack1(GTK_PANED(priv->vpaned), priv->hpaned, TRUE, TRUE); priv->stateSelector = trg_state_selector_new(priv->client); - priv->stateSelectorScroller = my_scrolledwin_new( - GTK_WIDGET(priv->stateSelector)); + priv->stateSelectorScroller = + my_scrolledwin_new(GTK_WIDGET(priv->stateSelector)); gtk_paned_pack1(GTK_PANED(priv->hpaned), priv->stateSelectorScroller, - FALSE, FALSE); + FALSE, FALSE); gtk_paned_pack2(GTK_PANED(priv->hpaned), my_scrolledwin_new(GTK_WIDGET - (priv->torrentTreeView)), TRUE, TRUE); + (priv-> + torrentTreeView)), + TRUE, TRUE); g_signal_connect(G_OBJECT(priv->stateSelector), - "torrent-state-changed", - G_CALLBACK(torrent_state_selection_changed), - priv->filteredTorrentModel); + "torrent-state-changed", + G_CALLBACK(torrent_state_selection_changed), + priv->filteredTorrentModel); priv->notebook = trg_main_window_notebook_new(self); gtk_paned_pack2(GTK_PANED(priv->vpaned), priv->notebook, FALSE, FALSE); tray = trg_prefs_get_bool(prefs, TRG_PREFS_KEY_SYSTEM_TRAY, - TRG_PREFS_GLOBAL); + TRG_PREFS_GLOBAL); if (tray) - trg_main_window_add_status_icon(self); + trg_main_window_add_status_icon(self); else - trg_main_window_remove_status_icon(self); + trg_main_window_remove_status_icon(self); priv->statusBar = trg_status_bar_new(); g_signal_connect(priv->client, "session-updated", - G_CALLBACK(trg_client_session_updated_cb), self); + G_CALLBACK(trg_client_session_updated_cb), self); - gtk_box_pack_start(GTK_BOX(outerVbox), GTK_WIDGET(priv->statusBar), FALSE, - FALSE, 2); + gtk_box_pack_start(GTK_BOX(outerVbox), GTK_WIDGET(priv->statusBar), + FALSE, FALSE, 2); width = trg_prefs_get_int(prefs, TRG_PREFS_KEY_WINDOW_WIDTH, - TRG_PREFS_GLOBAL); + TRG_PREFS_GLOBAL); height = trg_prefs_get_int(prefs, TRG_PREFS_KEY_WINDOW_HEIGHT, - TRG_PREFS_GLOBAL); + TRG_PREFS_GLOBAL); if (width > 0 && height > 0) - gtk_window_set_default_size(GTK_WINDOW(self), width, height); + gtk_window_set_default_size(GTK_WINDOW(self), width, height); gtk_widget_show_all(GTK_WIDGET(self)); - trg_widget_set_visible( - priv->stateSelectorScroller, - trg_prefs_get_bool(prefs, TRG_PREFS_KEY_SHOW_STATE_SELECTOR, - TRG_PREFS_GLOBAL)); - trg_widget_set_visible( - priv->notebook, - trg_prefs_get_bool(prefs, TRG_PREFS_KEY_SHOW_NOTEBOOK, - TRG_PREFS_GLOBAL)); - - pos = trg_prefs_get_int(prefs, TRG_PREFS_KEY_NOTEBOOK_PANED_POS, TRG_PREFS_GLOBAL); + trg_widget_set_visible(priv->stateSelectorScroller, + trg_prefs_get_bool(prefs, + TRG_PREFS_KEY_SHOW_STATE_SELECTOR, + TRG_PREFS_GLOBAL)); + trg_widget_set_visible(priv->notebook, + trg_prefs_get_bool(prefs, + TRG_PREFS_KEY_SHOW_NOTEBOOK, + TRG_PREFS_GLOBAL)); + + pos = + trg_prefs_get_int(prefs, TRG_PREFS_KEY_NOTEBOOK_PANED_POS, + TRG_PREFS_GLOBAL); if (pos > 0) - gtk_paned_set_position(GTK_PANED(priv->vpaned), pos); + gtk_paned_set_position(GTK_PANED(priv->vpaned), pos); - pos = trg_prefs_get_int(prefs, TRG_PREFS_KEY_STATES_PANED_POS, TRG_PREFS_GLOBAL); + pos = + trg_prefs_get_int(prefs, TRG_PREFS_KEY_STATES_PANED_POS, + TRG_PREFS_GLOBAL); if (pos > 0) - gtk_paned_set_position(GTK_PANED(priv->hpaned), pos); + gtk_paned_set_position(GTK_PANED(priv->hpaned), pos); if (tray && priv->min_on_start) - gtk_widget_hide(GTK_WIDGET(self)); + gtk_widget_hide(GTK_WIDGET(self)); /* Drag and Drop */ - gtk_drag_dest_set - ( - GTK_WIDGET (self), // widget that will accept a drop - GTK_DEST_DEFAULT_ALL, // default actions for dest on DnD - target_list, // lists of target to support - n_targets, // size of list - GDK_ACTION_MOVE // what to do with data after dropped - // | GDK_ACTION_COPY ... seems that file managers only need ACTION_MOVE, not ACTION_COPY - ); + gtk_drag_dest_set(GTK_WIDGET(self), // widget that will accept a drop + GTK_DEST_DEFAULT_ALL, // default actions for dest on DnD + target_list, // lists of target to support + n_targets, // size of list + GDK_ACTION_MOVE // what to do with data after dropped + // | GDK_ACTION_COPY ... seems that file managers only need ACTION_MOVE, not ACTION_COPY + ); //g_signal_connect (priv->torrentTreeView, "drag-motion",G_CALLBACK (drag_motion_handl), NULL); - g_signal_connect (self, "drag-data-received",G_CALLBACK (on_dropped_file), self); + g_signal_connect(self, "drag-data-received", + G_CALLBACK(on_dropped_file), self); return G_OBJECT(self); } -static void trg_main_window_class_init(TrgMainWindowClass * klass) { +static void trg_main_window_class_init(TrgMainWindowClass * klass) +{ GObjectClass *object_class = G_OBJECT_CLASS(klass); g_type_class_add_private(klass, sizeof(TrgMainWindowPrivate)); @@ -2181,52 +2529,63 @@ static void trg_main_window_class_init(TrgMainWindowClass * klass) { object_class->get_property = trg_main_window_get_property; object_class->set_property = trg_main_window_set_property; - g_object_class_install_property( - object_class, - PROP_CLIENT, - g_param_spec_pointer( - "trg-client", - "TClient", - "Client", - G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY - | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK - | G_PARAM_STATIC_BLURB)); - - g_object_class_install_property( - object_class, - PROP_MINIMISE_ON_START, - g_param_spec_boolean( - "min-on-start", - "Min On Start", - "Min On Start", - FALSE, - G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY - | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK - | G_PARAM_STATIC_BLURB)); -} - -void auto_connect_if_required(TrgMainWindow * win, gchar **args) { + g_object_class_install_property(object_class, + PROP_CLIENT, + g_param_spec_pointer("trg-client", + "TClient", + "Client", + G_PARAM_READWRITE + | + G_PARAM_CONSTRUCT_ONLY + | + G_PARAM_STATIC_NAME + | + G_PARAM_STATIC_NICK + | + G_PARAM_STATIC_BLURB)); + + g_object_class_install_property(object_class, + PROP_MINIMISE_ON_START, + g_param_spec_boolean("min-on-start", + "Min On Start", + "Min On Start", + FALSE, + G_PARAM_READWRITE + | + G_PARAM_CONSTRUCT_ONLY + | + G_PARAM_STATIC_NAME + | + G_PARAM_STATIC_NICK + | + G_PARAM_STATIC_BLURB)); +} + +void auto_connect_if_required(TrgMainWindow * win, gchar ** args) +{ TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win); TrgPrefs *prefs = trg_client_get_prefs(priv->client); gchar *host = trg_prefs_get_string(prefs, TRG_PREFS_KEY_HOSTNAME, - TRG_PREFS_PROFILE); + TRG_PREFS_PROFILE); if (host) { - gint len = strlen(host); - g_free(host); - if (len > 0 && trg_prefs_get_bool(prefs, TRG_PREFS_KEY_AUTO_CONNECT, - TRG_PREFS_PROFILE)) { - priv->args = args; - connect_cb(NULL, win); - return; - } + gint len = strlen(host); + g_free(host); + if (len > 0 + && trg_prefs_get_bool(prefs, TRG_PREFS_KEY_AUTO_CONNECT, + TRG_PREFS_PROFILE)) { + priv->args = args; + connect_cb(NULL, win); + return; + } } if (args) - g_strfreev(args); + g_strfreev(args); } -TrgMainWindow *trg_main_window_new(TrgClient * tc, gboolean minonstart) { - return g_object_new(TRG_TYPE_MAIN_WINDOW, "trg-client", tc, "min-on-start", - minonstart, NULL); +TrgMainWindow *trg_main_window_new(TrgClient * tc, gboolean minonstart) +{ + return g_object_new(TRG_TYPE_MAIN_WINDOW, "trg-client", tc, + "min-on-start", minonstart, NULL); } -- cgit v1.2.3