mirror/transmission
1
0
Fork 0
mirror of https://github.com/transmission/transmission synced 2024-12-25 17:17:31 +00:00
Code Issues Releases Wiki Activity
transmission/gtk/main.c
Mike Gelfand 440f482d01 Replace tabs with spaces; remove trailing spaces
2015-01-02 11:15:31 +00:00

1667 lines
50 KiB
C
Raw Blame History

/******************************************************************************
* $Id$
*
* Copyright (c) Transmission authors and contributors
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*****************************************************************************/
#include <locale.h>
#include <signal.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h> /* exit () */
#include <time.h>
#include <glib/gi18n.h>
#include <glib/gstdio.h>
#include <gio/gio.h>
#include <gtk/gtk.h>
#include <libtransmission/transmission.h>
#include <libtransmission/rpcimpl.h>
#include <libtransmission/utils.h>
#include <libtransmission/version.h>
#include "actions.h"
#include "conf.h"
#include "details.h"
#include "dialogs.h"
#include "hig.h"
#include "makemeta-ui.h"
#include "msgwin.h"
#include "notify.h"
#include "open-dialog.h"
#include "relocate.h"
#include "stats.h"
#include "tr-core.h"
#include "tr-icon.h"
#include "tr-prefs.h"
#include "tr-window.h"
#include "util.h"
#define MY_CONFIG_NAME "transmission"
#define MY_READABLE_NAME "transmission-gtk"
#define TR_RESOURCE_PATH "/com/transmissionbt/transmission/"
#define SHOW_LICENSE
static const char * LICENSE =
"Copyright 2005-2014. All code is copyrighted by the respective authors.\n"
"\n"
"Transmission can be redistributed and/or modified under the terms of the "
"GNU GPL versions 2 or 3 or by any future license endorsed by Mnemosyne LLC.\n"
"\n"
"In addition, linking to and/or using OpenSSL is allowed.\n"
"\n"
"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.\n"
"\n"
"Some of Transmission's source files have more permissive licenses. "
"Those files may, of course, be used on their own under their own terms.\n";
struct cbdata
{
char * config_dir;
gboolean start_paused;
gboolean is_iconified;
gboolean is_closing;
guint activation_count;
guint timer;
guint update_model_soon_tag;
guint refresh_actions_tag;
gpointer icon;
GtkWindow * wind;
TrCore * core;
GtkWidget * msgwin;
GtkWidget * prefs;
GSList * error_list;
GSList * duplicates_list;
GSList * details;
GtkTreeSelection * sel;
};
static void
gtr_window_present (GtkWindow * window)
{
gtk_window_present_with_time (window, gtk_get_current_event_time ());
}
/***
****
**** DETAILS DIALOGS MANAGEMENT
****
***/
static int
compare_integers (gconstpointer a, gconstpointer b)
{
return GPOINTER_TO_INT (a) - GPOINTER_TO_INT (b);
}
static char*
get_details_dialog_key (GSList * id_list)
{
GSList * l;
GSList * tmp = g_slist_sort (g_slist_copy (id_list), compare_integers);
GString * gstr = g_string_new (NULL);
for (l=tmp; l!=NULL; l=l->next)
g_string_append_printf (gstr, "%d ", GPOINTER_TO_INT (l->data));
g_slist_free (tmp);
return g_string_free (gstr, FALSE);
}
static void
get_selected_torrent_ids_foreach (GtkTreeModel * model,
GtkTreePath * p UNUSED,
GtkTreeIter * iter,
gpointer gdata)
{
int id;
GSList ** ids = gdata;
gtk_tree_model_get (model, iter, MC_TORRENT_ID, &id, -1);
*ids = g_slist_append (*ids, GINT_TO_POINTER (id));
}
static GSList*
get_selected_torrent_ids (struct cbdata * data)
{
GSList * ids = NULL;
gtk_tree_selection_selected_foreach (data->sel,
get_selected_torrent_ids_foreach,
&ids);
return ids;
}
static void
on_details_dialog_closed (gpointer gdata, GObject * dead)
{
struct cbdata * data = gdata;
data->details = g_slist_remove (data->details, dead);
}
static void
show_details_dialog_for_selected_torrents (struct cbdata * data)
{
GtkWidget * dialog = NULL;
GSList * l;
GSList * ids = get_selected_torrent_ids (data);
char * key = get_details_dialog_key (ids);
for (l=data->details; dialog==NULL && l!=NULL; l=l->next)
if (!g_strcmp0 (key, g_object_get_data (l->data, "key")))
dialog = l->data;
if (dialog == NULL)
{
dialog = gtr_torrent_details_dialog_new (GTK_WINDOW (data->wind), data->core);
gtr_torrent_details_dialog_set_torrents (dialog, ids);
g_object_set_data_full (G_OBJECT (dialog), "key", g_strdup (key), g_free);
g_object_weak_ref (G_OBJECT (dialog), on_details_dialog_closed, data);
data->details = g_slist_append (data->details, dialog);
gtk_widget_show (dialog);
}
gtr_window_present (GTK_WINDOW (dialog));
g_free (key);
g_slist_free (ids);
}
/****
*****
***** ON SELECTION CHANGED
*****
****/
struct counts_data
{
int total_count;
int queued_count;
int stopped_count;
};
static void
get_selected_torrent_counts_foreach (GtkTreeModel * model, GtkTreePath * path UNUSED,
GtkTreeIter * iter, gpointer user_data)
{
int activity = 0;
struct counts_data * counts = user_data;
++counts->total_count;
gtk_tree_model_get (model, iter, MC_ACTIVITY, &activity, -1);
if ((activity == TR_STATUS_DOWNLOAD_WAIT) || (activity == TR_STATUS_SEED_WAIT))
++counts->queued_count;
if (activity == TR_STATUS_STOPPED)
++counts->stopped_count;
}
static void
get_selected_torrent_counts (struct cbdata * data, struct counts_data * counts)
{
counts->total_count = 0;
counts->queued_count = 0;
counts->stopped_count = 0;
gtk_tree_selection_selected_foreach (data->sel, get_selected_torrent_counts_foreach, counts);
}
static void
count_updatable_foreach (GtkTreeModel * model, GtkTreePath * path UNUSED,
GtkTreeIter * iter, gpointer accumulated_status)
{
tr_torrent * tor;
gtk_tree_model_get (model, iter, MC_TORRENT, &tor, -1);
*(int*)accumulated_status |= tr_torrentCanManualUpdate (tor);
}
static gboolean
refresh_actions (gpointer gdata)
{
struct cbdata * data = gdata;
if (!data->is_closing)
{
int canUpdate;
struct counts_data sel_counts;
const size_t total = gtr_core_get_torrent_count (data->core);
const size_t active = gtr_core_get_active_torrent_count (data->core);
const int torrent_count = gtk_tree_model_iter_n_children (gtr_core_model (data->core), NULL);
bool has_selection;
get_selected_torrent_counts (data, &sel_counts);
has_selection = sel_counts.total_count > 0;
gtr_action_set_sensitive ("select-all", torrent_count != 0);
gtr_action_set_sensitive ("deselect-all", torrent_count != 0);
gtr_action_set_sensitive ("pause-all-torrents", active != 0);
gtr_action_set_sensitive ("start-all-torrents", active != total);
gtr_action_set_sensitive ("torrent-stop", (sel_counts.stopped_count < sel_counts.total_count));
gtr_action_set_sensitive ("torrent-start", (sel_counts.stopped_count) > 0);
gtr_action_set_sensitive ("torrent-start-now", (sel_counts.stopped_count + sel_counts.queued_count) > 0);
gtr_action_set_sensitive ("torrent-verify", has_selection);
gtr_action_set_sensitive ("remove-torrent", has_selection);
gtr_action_set_sensitive ("delete-torrent", has_selection);
gtr_action_set_sensitive ("relocate-torrent", has_selection);
gtr_action_set_sensitive ("queue-move-top", has_selection);
gtr_action_set_sensitive ("queue-move-up", has_selection);
gtr_action_set_sensitive ("queue-move-down", has_selection);
gtr_action_set_sensitive ("queue-move-bottom", has_selection);
gtr_action_set_sensitive ("show-torrent-properties", has_selection);
gtr_action_set_sensitive ("open-torrent-folder", sel_counts.total_count == 1);
gtr_action_set_sensitive ("copy-magnet-link-to-clipboard", sel_counts.total_count == 1);
canUpdate = 0;
gtk_tree_selection_selected_foreach (data->sel, count_updatable_foreach, &canUpdate);
gtr_action_set_sensitive ("torrent-reannounce", canUpdate != 0);
}
data->refresh_actions_tag = 0;
return G_SOURCE_REMOVE;
}
static void
refresh_actions_soon (gpointer gdata)
{
struct cbdata * data = gdata;
if (!data->is_closing && !data->refresh_actions_tag)
data->refresh_actions_tag = gdk_threads_add_idle (refresh_actions, data);
}
static void
on_selection_changed (GtkTreeSelection * s UNUSED, gpointer gdata)
{
refresh_actions_soon (gdata);
}
/***
****
***/
static gboolean
has_magnet_link_handler (void)
{
GAppInfo * app_info = g_app_info_get_default_for_uri_scheme ("magnet");
const gboolean has_handler = app_info != NULL;
g_clear_object (&app_info);
return has_handler;
}
static void
register_magnet_link_handler (void)
{
GError * error;
GAppInfo * app;
const char * const content_type = "x-scheme-handler/magnet";
error = NULL;
app = g_app_info_create_from_commandline ("transmission-gtk",
"transmission-gtk",
G_APP_INFO_CREATE_SUPPORTS_URIS,
&error);
g_app_info_set_as_default_for_type (app, content_type, &error);
if (error != NULL)
{
g_warning (_("Error registering Transmission as a %s handler: %s"),
content_type,
error->message);
g_error_free (error);
}
g_clear_object (&app);
}
static void
ensure_magnet_handler_exists (void)
{
if (!has_magnet_link_handler ())
register_magnet_link_handler ();
}
static void
on_main_window_size_allocated (GtkWidget * gtk_window,
GtkAllocation * alloc UNUSED,
gpointer gdata UNUSED)
{
GdkWindow * gdk_window = gtk_widget_get_window (gtk_window);
const gboolean isMaximized = (gdk_window != NULL)
&& (gdk_window_get_state (gdk_window) & GDK_WINDOW_STATE_MAXIMIZED);
gtr_pref_int_set (TR_KEY_main_window_is_maximized, isMaximized);
if (!isMaximized)
{
int x, y, w, h;
gtk_window_get_position (GTK_WINDOW (gtk_window), &x, &y);
gtk_window_get_size (GTK_WINDOW (gtk_window), &w, &h);
gtr_pref_int_set (TR_KEY_main_window_x, x);
gtr_pref_int_set (TR_KEY_main_window_y, y);
gtr_pref_int_set (TR_KEY_main_window_width, w);
gtr_pref_int_set (TR_KEY_main_window_height, h);
}
}
/***
**** listen to changes that come from RPC
***/
struct on_rpc_changed_struct
{
TrCore * core;
tr_rpc_callback_type type;
int torrent_id;
};
static gboolean
on_rpc_changed_idle (gpointer gdata)
{
tr_torrent * tor;
struct on_rpc_changed_struct * data = gdata;
switch (data->type)
{
case TR_RPC_SESSION_CLOSE:
gtr_action_activate ("quit");
break;
case TR_RPC_TORRENT_ADDED:
if ((tor = gtr_core_find_torrent (data->core, data->torrent_id)))
gtr_core_add_torrent (data->core, tor, true);
break;
case TR_RPC_TORRENT_REMOVING:
gtr_core_remove_torrent (data->core, data->torrent_id, false);
break;
case TR_RPC_TORRENT_TRASHING:
gtr_core_remove_torrent (data->core, data->torrent_id, true);
break;
case TR_RPC_SESSION_CHANGED: {
int i;
tr_variant tmp;
tr_variant * newval;
tr_variant * oldvals = gtr_pref_get_all ();
tr_quark key;
GSList * l;
GSList * changed_keys = NULL;
tr_session * session = gtr_core_session (data->core);
tr_variantInitDict (&tmp, 100);
tr_sessionGetSettings (session, &tmp);
for (i=0; tr_variantDictChild (&tmp, i, &key, &newval); ++i)
{
bool changed;
tr_variant * oldval = tr_variantDictFind (oldvals, key);
if (!oldval)
{
changed = true;
}
else
{
char * a = tr_variantToStr (oldval, TR_VARIANT_FMT_BENC, NULL);
char * b = tr_variantToStr (newval, TR_VARIANT_FMT_BENC, NULL);
changed = g_strcmp0 (a, b) != 0;
tr_free (b);
tr_free (a);
}
if (changed)
changed_keys = g_slist_append (changed_keys, GINT_TO_POINTER(key));
}
tr_sessionGetSettings (session, oldvals);
for (l=changed_keys; l!=NULL; l=l->next)
gtr_core_pref_changed (data->core, GPOINTER_TO_INT(l->data));
g_slist_free (changed_keys);
tr_variantFree (&tmp);
break;
}
case TR_RPC_TORRENT_CHANGED:
case TR_RPC_TORRENT_MOVED:
case TR_RPC_TORRENT_STARTED:
case TR_RPC_TORRENT_STOPPED:
case TR_RPC_SESSION_QUEUE_POSITIONS_CHANGED:
/* nothing interesting to do here */
break;
}
g_free (data);
return G_SOURCE_REMOVE;
}
static tr_rpc_callback_status
on_rpc_changed (tr_session * session G_GNUC_UNUSED,
tr_rpc_callback_type type,
struct tr_torrent * tor,
void * gdata)
{
struct cbdata * cbdata = gdata;
struct on_rpc_changed_struct * data;
data = g_new (struct on_rpc_changed_struct, 1);
data->core = cbdata->core;
data->type = type;
data->torrent_id = tr_torrentId (tor);
gdk_threads_add_idle (on_rpc_changed_idle, data);
return TR_RPC_NOREMOVE;
}
/***
**** signal handling
***/
static sig_atomic_t global_sigcount = 0;
static struct cbdata * sighandler_cbdata = NULL;
static void
signal_handler (int sig)
{
if (++global_sigcount > 1)
{
signal (sig, SIG_DFL);
raise (sig);
}
else if ((sig == SIGINT) || (sig == SIGTERM))
{
g_message (_("Got signal %d; trying to shut down cleanly. Do it again if it gets stuck."), sig);
gtr_actions_handler ("quit", sighandler_cbdata);
}
}
/****
*****
*****
****/
static void app_setup (GtkWindow * wind, struct cbdata * cbdata);
static void
on_startup (GApplication * application, gpointer user_data)
{
GError * error;
const char * str;
GtkWindow * win;
GtkUIManager * ui_manager;
tr_session * session;
struct cbdata * cbdata = user_data;
signal (SIGINT, signal_handler);
signal (SIGTERM, signal_handler);
sighandler_cbdata = cbdata;
/* ensure the directories are created */
if ((str = gtr_pref_string_get (TR_KEY_download_dir)))
g_mkdir_with_parents (str, 0777);
if ((str = gtr_pref_string_get (TR_KEY_incomplete_dir)))
g_mkdir_with_parents (str, 0777);
/* initialize the libtransmission session */
session = tr_sessionInit ("gtk", cbdata->config_dir, TRUE, gtr_pref_get_all ());
gtr_pref_flag_set (TR_KEY_alt_speed_enabled, tr_sessionUsesAltSpeed (session));
gtr_pref_int_set (TR_KEY_peer_port, tr_sessionGetPeerPort (session));
cbdata->core = gtr_core_new (session);
/* init the ui manager */
error = NULL;
ui_manager = gtk_ui_manager_new ();
gtr_actions_init (ui_manager, cbdata);
gtk_ui_manager_add_ui_from_resource (ui_manager, TR_RESOURCE_PATH "transmission-ui.xml", &error);
g_assert_no_error (error);
gtk_ui_manager_ensure_update (ui_manager);
/* create main window now to be a parent to any error dialogs */
win = GTK_WINDOW (gtr_window_new (GTK_APPLICATION (application), ui_manager, cbdata->core));
g_signal_connect (win, "size-allocate", G_CALLBACK (on_main_window_size_allocated), cbdata);
g_application_hold (application);
g_object_weak_ref (G_OBJECT (win), (GWeakNotify)g_application_release, application);
app_setup (win, cbdata);
tr_sessionSetRPCCallback (session, on_rpc_changed, cbdata);
/* check & see if it's time to update the blocklist */
if (gtr_pref_flag_get (TR_KEY_blocklist_enabled))
{
if (gtr_pref_flag_get (TR_KEY_blocklist_updates_enabled))
{
const int64_t last_time = gtr_pref_int_get (TR_KEY_blocklist_date);
const int SECONDS_IN_A_WEEK = 7 * 24 * 60 * 60;
const time_t now = time (NULL);
if (last_time + SECONDS_IN_A_WEEK < now)
gtr_core_blocklist_update (cbdata->core);
}
}
/* if there's no magnet link handler registered, register us */
ensure_magnet_handler_exists ();
}
static void
on_activate (GApplication * app UNUSED, struct cbdata * cbdata)
{
cbdata->activation_count++;
/* GApplication emits an 'activate' signal when bootstrapping the primary.
* Ordinarily we handle that by presenting the main window, but if the user
* user started Transmission minimized, ignore that initial signal... */
if (cbdata->is_iconified && (cbdata->activation_count == 1))
return;
gtr_action_activate ("present-main-window");
}
static void
open_files (GSList * files, gpointer gdata)
{
struct cbdata * cbdata = gdata;
const gboolean do_start = gtr_pref_flag_get (TR_KEY_start_added_torrents) && !cbdata->start_paused;
const gboolean do_prompt = gtr_pref_flag_get (TR_KEY_show_options_window);
const gboolean do_notify = TRUE;
gtr_core_add_files (cbdata->core, files, do_start, do_prompt, do_notify);
}
static void
on_open (GApplication * application UNUSED,
GFile ** f,
gint file_count,
gchar * hint UNUSED,
gpointer gdata)
{
int i;
GSList * files = NULL;
for (i=0; i<file_count; i++)
files = g_slist_prepend (files, f[i]);
open_files (files, gdata);
g_slist_free (files);
}
/***
****
***/
int
main (int argc, char ** argv)
{
int ret;
struct stat sb;
char * application_id;
GtkApplication * app;
GOptionContext * option_context;
bool show_version = false;
GError * error = NULL;
struct cbdata cbdata;
GOptionEntry option_entries[] = {
{ "config-dir", 'g', 0, G_OPTION_ARG_FILENAME, &cbdata.config_dir, _("Where to look for configuration files"), NULL },
{ "paused", 'p', 0, G_OPTION_ARG_NONE, &cbdata.start_paused, _("Start with all torrents paused"), NULL },
{ "minimized", 'm', 0, G_OPTION_ARG_NONE, &cbdata.is_iconified, _("Start minimized in notification area"), NULL },
{ "version", 'v', 0, G_OPTION_ARG_NONE, &show_version, _("Show version number and exit"), NULL },
{ NULL, 0, 0, 0, NULL, NULL, NULL }
};
/* default settings */
memset (&cbdata, 0, sizeof (struct cbdata));
cbdata.config_dir = (char*) tr_getDefaultConfigDir (MY_CONFIG_NAME);
/* init i18n */
setlocale (LC_ALL, "");
bindtextdomain (MY_READABLE_NAME, TRANSMISSIONLOCALEDIR);
bind_textdomain_codeset (MY_READABLE_NAME, "UTF-8");
textdomain (MY_READABLE_NAME);
/* init glib/gtk */
#if !GLIB_CHECK_VERSION(2,35,4)
g_type_init ();
#endif
gtk_init (&argc, &argv);
g_set_application_name (_("Transmission"));
gtk_window_set_default_icon_name (MY_CONFIG_NAME);
/* parse the command line */
option_context = g_option_context_new (_("[torrent files or urls]"));
g_option_context_add_main_entries (option_context, option_entries, GETTEXT_PACKAGE);
g_option_context_set_translation_domain (option_context, GETTEXT_PACKAGE);
if (!g_option_context_parse (option_context, &argc, &argv, &error))
{
g_print (_("%s\nRun '%s --help' to see a full list of available command line options.\n"), error->message, argv[0]);
g_error_free (error);
g_option_context_free (option_context);
return 1;
}
g_option_context_free (option_context);
/* handle the trivial "version" option */
if (show_version)
{
fprintf (stderr, "%s %s\n", MY_READABLE_NAME, LONG_VERSION_STRING);
return 0;
}
/* init the unit formatters */
tr_formatter_mem_init (mem_K, _ (mem_K_str), _ (mem_M_str), _ (mem_G_str), _ (mem_T_str));
tr_formatter_size_init (disk_K, _ (disk_K_str), _ (disk_M_str), _ (disk_G_str), _ (disk_T_str));
tr_formatter_speed_init (speed_K, _ (speed_K_str), _ (speed_M_str), _ (speed_G_str), _ (speed_T_str));
/* set up the config dir */
gtr_pref_init (cbdata.config_dir);
g_mkdir_with_parents (cbdata.config_dir, 0755);
/* init notifications */
gtr_notify_init ();
/* init the application for the specified config dir */
stat (cbdata.config_dir, &sb);
application_id = g_strdup_printf ("com.transmissionbt.transmission_%lu_%lu", (unsigned long)sb.st_dev, (unsigned long)sb.st_ino);
app = gtk_application_new (application_id, G_APPLICATION_HANDLES_OPEN);
g_signal_connect (app, "open", G_CALLBACK (on_open), &cbdata);
g_signal_connect (app, "startup", G_CALLBACK (on_startup), &cbdata);
g_signal_connect (app, "activate", G_CALLBACK (on_activate), &cbdata);
ret = g_application_run (G_APPLICATION (app), argc, argv);
g_object_unref (app);
g_free (application_id);
return ret;
}
static void
on_core_busy (TrCore * core UNUSED, gboolean busy, struct cbdata * c)
{
gtr_window_set_busy (c->wind, busy);
}
static void on_core_error (TrCore *, guint, const char *, struct cbdata *);
static void on_add_torrent (TrCore *, tr_ctor *, gpointer);
static void on_prefs_changed (TrCore * core, const tr_quark key, gpointer);
static void main_window_setup (struct cbdata * cbdata, GtkWindow * wind);
static gboolean update_model_loop (gpointer gdata);
static gboolean update_model_once (gpointer gdata);
static void
app_setup (GtkWindow * wind, struct cbdata * cbdata)
{
if (cbdata->is_iconified)
gtr_pref_flag_set (TR_KEY_show_notification_area_icon, TRUE);
gtr_actions_set_core (cbdata->core);
/* set up core handlers */
g_signal_connect (cbdata->core, "busy", G_CALLBACK (on_core_busy), cbdata);
g_signal_connect (cbdata->core, "add-error", G_CALLBACK (on_core_error), cbdata);
g_signal_connect (cbdata->core, "add-prompt", G_CALLBACK (on_add_torrent), cbdata);
g_signal_connect (cbdata->core, "prefs-changed", G_CALLBACK (on_prefs_changed), cbdata);
/* add torrents from command-line and saved state */
gtr_core_load (cbdata->core, cbdata->start_paused);
gtr_core_torrents_added (cbdata->core);
/* set up main window */
main_window_setup (cbdata, wind);
/* set up the icon */
on_prefs_changed (cbdata->core, TR_KEY_show_notification_area_icon, cbdata);
/* start model update timer */
cbdata->timer = gdk_threads_add_timeout_seconds (MAIN_WINDOW_REFRESH_INTERVAL_SECONDS, update_model_loop, cbdata);
update_model_once (cbdata);
/* either show the window or iconify it */
if (!cbdata->is_iconified)
{
gtk_widget_show (GTK_WIDGET (wind));
}
else
{
gtk_window_set_skip_taskbar_hint (cbdata->wind,
cbdata->icon != NULL);
cbdata->is_iconified = FALSE; // ensure that the next toggle iconifies
gtr_action_set_toggled ("toggle-main-window", FALSE);
}
if (!gtr_pref_flag_get (TR_KEY_user_has_given_informed_consent))
{
GtkWidget * w = gtk_message_dialog_new (GTK_WINDOW (wind),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_OTHER,
GTK_BUTTONS_NONE,
"%s",
_("Transmission is a file sharing program. When you run a torrent, its data will be made available to others by means of upload. Any content you share is your sole responsibility."));
gtk_dialog_add_button (GTK_DIALOG (w), GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT);
gtk_dialog_add_button (GTK_DIALOG (w), _("I _Agree"), GTK_RESPONSE_ACCEPT);
gtk_dialog_set_default_response (GTK_DIALOG (w), GTK_RESPONSE_ACCEPT);
switch (gtk_dialog_run (GTK_DIALOG (w)))
{
case GTK_RESPONSE_ACCEPT:
/* only show it once */
gtr_pref_flag_set (TR_KEY_user_has_given_informed_consent, TRUE);
gtk_widget_destroy (w);
break;
default:
exit (0);
}
}
}
static void
presentMainWindow (struct cbdata * cbdata)
{
GtkWindow * window = cbdata->wind;
if (cbdata->is_iconified)
{
cbdata->is_iconified = false;
gtk_window_set_skip_taskbar_hint (window, FALSE);
}
if (!gtk_widget_get_visible (GTK_WIDGET (window)))
{
gtk_window_resize (window, gtr_pref_int_get (TR_KEY_main_window_width),
gtr_pref_int_get (TR_KEY_main_window_height));
gtk_window_move (window, gtr_pref_int_get (TR_KEY_main_window_x),
gtr_pref_int_get (TR_KEY_main_window_y));
gtr_widget_set_visible (GTK_WIDGET (window), TRUE);
}
gtr_window_present (window);
gdk_window_raise (gtk_widget_get_window (GTK_WIDGET(window)));
}
static void
hideMainWindow (struct cbdata * cbdata)
{
GtkWindow * window = cbdata->wind;
gtk_window_set_skip_taskbar_hint (window, TRUE);
gtr_widget_set_visible (GTK_WIDGET (window), FALSE);
cbdata->is_iconified = true;
}
static void
toggleMainWindow (struct cbdata * cbdata)
{
if (cbdata->is_iconified)
presentMainWindow (cbdata);
else
hideMainWindow (cbdata);
}
static void on_app_exit (gpointer vdata);
static gboolean
winclose (GtkWidget * w UNUSED,
GdkEvent * event UNUSED,
gpointer gdata)
{
struct cbdata * cbdata = gdata;
if (cbdata->icon != NULL)
gtr_action_activate ("toggle-main-window");
else
on_app_exit (cbdata);
return TRUE; /* don't propagate event further */
}
static void
rowChangedCB (GtkTreeModel * model UNUSED,
GtkTreePath * path,
GtkTreeIter * iter UNUSED,
gpointer gdata)
{
struct cbdata * data = gdata;
if (gtk_tree_selection_path_is_selected (data->sel, path))
refresh_actions_soon (data);
}
static void
on_drag_data_received (GtkWidget * widget UNUSED,
GdkDragContext * drag_context,
gint x UNUSED,
gint y UNUSED,
GtkSelectionData * selection_data,
guint info UNUSED,
guint time_,
gpointer gdata)
{
guint i;
char ** uris = gtk_selection_data_get_uris (selection_data);
const guint file_count = g_strv_length (uris);
GSList * files = NULL;
for (i=0; i<file_count; ++i)
files = g_slist_prepend (files, g_file_new_for_uri (uris[i]));
open_files (files, gdata);
/* cleanup */
g_slist_foreach (files, (GFunc)g_object_unref, NULL);
g_slist_free (files);
g_strfreev (uris);
gtk_drag_finish (drag_context, true, FALSE, time_);
}
static void
main_window_setup (struct cbdata * cbdata, GtkWindow * wind)
{
GtkWidget * w;
GtkTreeModel * model;
GtkTreeSelection * sel;
g_assert (NULL == cbdata->wind);
cbdata->wind = wind;
cbdata->sel = sel = GTK_TREE_SELECTION (gtr_window_get_selection (cbdata->wind));
g_signal_connect (sel, "changed", G_CALLBACK (on_selection_changed), cbdata);
on_selection_changed (sel, cbdata);
model = gtr_core_model (cbdata->core);
g_signal_connect (model, "row-changed", G_CALLBACK (rowChangedCB), cbdata);
g_signal_connect (wind, "delete-event", G_CALLBACK (winclose), cbdata);
refresh_actions (cbdata);
/* register to handle URIs that get dragged onto our main window */
w = GTK_WIDGET (wind);
gtk_drag_dest_set (w, GTK_DEST_DEFAULT_ALL, NULL, 0, GDK_ACTION_COPY);
gtk_drag_dest_add_uri_targets (w);
g_signal_connect (w, "drag-data-received", G_CALLBACK (on_drag_data_received), cbdata);
}
static gboolean
on_session_closed (gpointer gdata)
{
GSList * tmp;
struct cbdata * cbdata = gdata;
tmp = g_slist_copy (cbdata->details);
g_slist_foreach (tmp, (GFunc)gtk_widget_destroy, NULL);
g_slist_free (tmp);
if (cbdata->prefs)
gtk_widget_destroy (GTK_WIDGET (cbdata->prefs));
if (cbdata->wind)
gtk_widget_destroy (GTK_WIDGET (cbdata->wind));
g_object_unref (cbdata->core);
if (cbdata->icon)
g_object_unref (cbdata->icon);
g_slist_foreach (cbdata->error_list, (GFunc)g_free, NULL);
g_slist_free (cbdata->error_list);
g_slist_foreach (cbdata->duplicates_list, (GFunc)g_free, NULL);
g_slist_free (cbdata->duplicates_list);
return G_SOURCE_REMOVE;
}
struct session_close_struct
{
tr_session * session;
struct cbdata * cbdata;
};
/* since tr_sessionClose () is a blocking function,
* delegate its call to another thread here... when it's done,
* punt the GUI teardown back to the GTK+ thread */
static gpointer
session_close_threadfunc (gpointer gdata)
{
struct session_close_struct * data = gdata;
tr_sessionClose (data->session);
gdk_threads_add_idle (on_session_closed, data->cbdata);
g_free (data);
return NULL;
}
static void
exit_now_cb (GtkWidget *w UNUSED, gpointer data UNUSED)
{
exit (0);
}
static void
on_app_exit (gpointer vdata)
{
GtkWidget *r, *p, *b, *w, *c;
struct cbdata * cbdata = vdata;
struct session_close_struct * session_close_data;
if (cbdata->is_closing)
return;
cbdata->is_closing = true;
/* stop the update timer */
if (cbdata->timer)
{
g_source_remove (cbdata->timer);
cbdata->timer = 0;
}
/* stop the refresh-actions timer */
if (cbdata->refresh_actions_tag)
{
g_source_remove (cbdata->refresh_actions_tag);
cbdata->refresh_actions_tag = 0;
}
c = GTK_WIDGET (cbdata->wind);
gtk_container_remove (GTK_CONTAINER (c), gtk_bin_get_child (GTK_BIN (c)));
r = gtk_alignment_new (0.5, 0.5, 0.01, 0.01);
gtk_container_add (GTK_CONTAINER (c), r);
p = gtk_grid_new ();
gtk_grid_set_column_spacing (GTK_GRID (p), GUI_PAD_BIG);
gtk_container_add (GTK_CONTAINER (r), p);
w = gtk_image_new_from_stock (GTK_STOCK_NETWORK, GTK_ICON_SIZE_DIALOG);
gtk_grid_attach (GTK_GRID (p), w, 0, 0, 1, 2);
w = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (w), _("<b>Closing Connections</b>"));
gtk_misc_set_alignment (GTK_MISC (w), 0.0, 0.5);
gtk_grid_attach (GTK_GRID (p), w, 1, 0, 1, 1);
w = gtk_label_new (_("Sending upload/download totals to tracker…"));
gtk_misc_set_alignment (GTK_MISC (w), 0.0, 0.5);
gtk_grid_attach (GTK_GRID (p), w, 1, 1, 1, 1);
b = gtk_alignment_new (0.0, 1.0, 0.01, 0.01);
w = gtk_button_new_with_mnemonic (_("_Quit Now"));
g_signal_connect (w, "clicked", G_CALLBACK (exit_now_cb), NULL);
gtk_container_add (GTK_CONTAINER (b), w);
gtk_grid_attach (GTK_GRID (p), b, 1, 2, 1, 1);
gtk_widget_show_all (r);
gtk_widget_grab_focus (w);
/* clear the UI */
gtr_core_clear (cbdata->core);
/* ensure the window is in its previous position & size.
* this seems to be necessary because changing the main window's
* child seems to unset the size */
gtk_window_resize (cbdata->wind, gtr_pref_int_get (TR_KEY_main_window_width),
gtr_pref_int_get (TR_KEY_main_window_height));
gtk_window_move (cbdata->wind, gtr_pref_int_get (TR_KEY_main_window_x),
gtr_pref_int_get (TR_KEY_main_window_y));
/* shut down libT */
session_close_data = g_new (struct session_close_struct, 1);
session_close_data->cbdata = cbdata;
session_close_data->session = gtr_core_close (cbdata->core);
g_thread_new ("shutdown-thread", session_close_threadfunc, session_close_data);
}
static void
show_torrent_errors (GtkWindow * window, const char * primary, GSList ** files)
{
GSList * l;
GtkWidget * w;
GString * s = g_string_new (NULL);
const char * leader = g_slist_length (*files) > 1
? gtr_get_unicode_string (GTR_UNICODE_BULLET)
: "";
for (l=*files; l!=NULL; l=l->next)
g_string_append_printf (s, "%s %s\n", leader, (const char*)l->data);
w = gtk_message_dialog_new (window,
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"%s", primary);
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (w),
"%s", s->str);
g_signal_connect_swapped (w, "response",
G_CALLBACK (gtk_widget_destroy), w);
gtk_widget_show (w);
g_string_free (s, TRUE);
g_slist_foreach (*files, (GFunc)g_free, NULL);
g_slist_free (*files);
*files = NULL;
}
static void
flush_torrent_errors (struct cbdata * cbdata)
{
if (cbdata->error_list)
show_torrent_errors (cbdata->wind,
ngettext ("Couldn't add corrupt torrent",
"Couldn't add corrupt torrents",
g_slist_length (cbdata->error_list)),
&cbdata->error_list);
if (cbdata->duplicates_list)
show_torrent_errors (cbdata->wind,
ngettext ("Couldn't add duplicate torrent",
"Couldn't add duplicate torrents",
g_slist_length (cbdata->duplicates_list)),
&cbdata->duplicates_list);
}
static void
on_core_error (TrCore * core UNUSED, guint code, const char * msg, struct cbdata * c)
{
switch (code)
{
case TR_PARSE_ERR:
c->error_list = g_slist_append (c->error_list, g_path_get_basename (msg));
break;
case TR_PARSE_DUPLICATE:
c->duplicates_list = g_slist_append (c->duplicates_list, g_strdup (msg));
break;
case TR_CORE_ERR_NO_MORE_TORRENTS:
flush_torrent_errors (c);
break;
default:
g_assert_not_reached ();
break;
}
}
static gboolean
on_main_window_focus_in (GtkWidget * widget UNUSED,
GdkEventFocus * event UNUSED,
gpointer gdata)
{
struct cbdata * cbdata = gdata;
if (cbdata->wind)
gtk_window_set_urgency_hint (cbdata->wind, FALSE);
return FALSE;
}
static void
on_add_torrent (TrCore * core, tr_ctor * ctor, gpointer gdata)
{
struct cbdata * cbdata = gdata;
GtkWidget * w = gtr_torrent_options_dialog_new (cbdata->wind, core, ctor);
g_signal_connect (w, "focus-in-event",
G_CALLBACK (on_main_window_focus_in), cbdata);
if (cbdata->wind)
gtk_window_set_urgency_hint (cbdata->wind, TRUE);
gtk_widget_show (w);
}
static void
on_prefs_changed (TrCore * core UNUSED, const tr_quark key, gpointer data)
{
struct cbdata * cbdata = data;
tr_session * tr = gtr_core_session (cbdata->core);
switch (key)
{
case TR_KEY_encryption:
tr_sessionSetEncryption (tr, gtr_pref_int_get (key));
break;
case TR_KEY_download_dir:
tr_sessionSetDownloadDir (tr, gtr_pref_string_get (key));
break;
case TR_KEY_message_level:
tr_logSetLevel (gtr_pref_int_get (key));
break;
case TR_KEY_peer_port:
tr_sessionSetPeerPort (tr, gtr_pref_int_get (key));
break;
case TR_KEY_blocklist_enabled:
tr_blocklistSetEnabled (tr, gtr_pref_flag_get (key));
break;
case TR_KEY_blocklist_url:
tr_blocklistSetURL (tr, gtr_pref_string_get (key));
break;
case TR_KEY_show_notification_area_icon:
{
const bool show = gtr_pref_flag_get (key);
if (show && !cbdata->icon)
cbdata->icon = gtr_icon_new (cbdata->core);
else if (!show && cbdata->icon)
g_clear_object (&cbdata->icon);
break;
}
case TR_KEY_speed_limit_down_enabled:
tr_sessionLimitSpeed (tr, TR_DOWN, gtr_pref_flag_get (key));
break;
case TR_KEY_speed_limit_down:
tr_sessionSetSpeedLimit_KBps (tr, TR_DOWN, gtr_pref_int_get (key));
break;
case TR_KEY_speed_limit_up_enabled:
tr_sessionLimitSpeed (tr, TR_UP, gtr_pref_flag_get (key));
break;
case TR_KEY_speed_limit_up:
tr_sessionSetSpeedLimit_KBps (tr, TR_UP, gtr_pref_int_get (key));
break;
case TR_KEY_ratio_limit_enabled:
tr_sessionSetRatioLimited (tr, gtr_pref_flag_get (key));
break;
case TR_KEY_ratio_limit:
tr_sessionSetRatioLimit (tr, gtr_pref_double_get (key));
break;
case TR_KEY_idle_seeding_limit:
tr_sessionSetIdleLimit (tr, gtr_pref_int_get (key));
break;
case TR_KEY_idle_seeding_limit_enabled:
tr_sessionSetIdleLimited (tr, gtr_pref_flag_get (key));
break;
case TR_KEY_port_forwarding_enabled:
tr_sessionSetPortForwardingEnabled (tr, gtr_pref_flag_get (key));
break;
case TR_KEY_pex_enabled:
tr_sessionSetPexEnabled (tr, gtr_pref_flag_get (key));
break;
case TR_KEY_rename_partial_files:
tr_sessionSetIncompleteFileNamingEnabled (tr, gtr_pref_flag_get (key));
break;
case TR_KEY_download_queue_size:
tr_sessionSetQueueSize (tr, TR_DOWN, gtr_pref_int_get (key));
break;
case TR_KEY_queue_stalled_minutes:
tr_sessionSetQueueStalledMinutes (tr, gtr_pref_int_get (key));
break;
case TR_KEY_dht_enabled:
tr_sessionSetDHTEnabled (tr, gtr_pref_flag_get (key));
break;
case TR_KEY_utp_enabled:
tr_sessionSetUTPEnabled (tr, gtr_pref_flag_get (key));
break;
case TR_KEY_lpd_enabled:
tr_sessionSetLPDEnabled (tr, gtr_pref_flag_get (key));
break;
case TR_KEY_rpc_port:
tr_sessionSetRPCPort (tr, gtr_pref_int_get (key));
break;
case TR_KEY_rpc_enabled:
tr_sessionSetRPCEnabled (tr, gtr_pref_flag_get (key));
break;
case TR_KEY_rpc_whitelist:
tr_sessionSetRPCWhitelist (tr, gtr_pref_string_get (key));
break;
case TR_KEY_rpc_whitelist_enabled:
tr_sessionSetRPCWhitelistEnabled (tr, gtr_pref_flag_get (key));
break;
case TR_KEY_rpc_username:
tr_sessionSetRPCUsername (tr, gtr_pref_string_get (key));
break;
case TR_KEY_rpc_password:
tr_sessionSetRPCPassword (tr, gtr_pref_string_get (key));
break;
case TR_KEY_rpc_authentication_required:
tr_sessionSetRPCPasswordEnabled (tr, gtr_pref_flag_get (key));
break;
case TR_KEY_alt_speed_up:
tr_sessionSetAltSpeed_KBps (tr, TR_UP, gtr_pref_int_get (key));
break;
case TR_KEY_alt_speed_down:
tr_sessionSetAltSpeed_KBps (tr, TR_DOWN, gtr_pref_int_get (key));
break;
case TR_KEY_alt_speed_enabled:
{
const bool b = gtr_pref_flag_get (key);
tr_sessionUseAltSpeed (tr, b);
gtr_action_set_toggled (tr_quark_get_string(key,NULL), b);
break;
}
case TR_KEY_alt_speed_time_begin:
tr_sessionSetAltSpeedBegin (tr, gtr_pref_int_get (key));
break;
case TR_KEY_alt_speed_time_end:
tr_sessionSetAltSpeedEnd (tr, gtr_pref_int_get (key));
break;
case TR_KEY_alt_speed_time_enabled:
tr_sessionUseAltSpeedTime (tr, gtr_pref_flag_get (key));
break;
case TR_KEY_alt_speed_time_day:
tr_sessionSetAltSpeedDay (tr, gtr_pref_int_get (key));
break;
case TR_KEY_peer_port_random_on_start:
tr_sessionSetPeerPortRandomOnStart (tr, gtr_pref_flag_get (key));
break;
case TR_KEY_incomplete_dir:
tr_sessionSetIncompleteDir (tr, gtr_pref_string_get (key));
break;
case TR_KEY_incomplete_dir_enabled:
tr_sessionSetIncompleteDirEnabled (tr, gtr_pref_flag_get (key));
break;
case TR_KEY_script_torrent_done_enabled:
tr_sessionSetTorrentDoneScriptEnabled (tr, gtr_pref_flag_get (key));
break;
case TR_KEY_script_torrent_done_filename:
tr_sessionSetTorrentDoneScript (tr, gtr_pref_string_get (key));
break;
case TR_KEY_start_added_torrents:
tr_sessionSetPaused (tr, !gtr_pref_flag_get (key));
break;
case TR_KEY_trash_original_torrent_files:
tr_sessionSetDeleteSource (tr, gtr_pref_flag_get (key));
break;
default:
break;
}
}
static gboolean
update_model_once (gpointer gdata)
{
struct cbdata *data = gdata;
/* update the torrent data in the model */
gtr_core_update (data->core);
/* refresh the main window's statusbar and toolbar buttons */
if (data->wind != NULL)
gtr_window_refresh (data->wind);
/* update the actions */
refresh_actions (data);
/* update the status tray icon */
if (data->icon != NULL)
gtr_icon_refresh (data->icon);
data->update_model_soon_tag = 0;
return G_SOURCE_REMOVE;
}
static void
update_model_soon (gpointer gdata)
{
struct cbdata *data = gdata;
if (data->update_model_soon_tag == 0)
data->update_model_soon_tag = gdk_threads_add_idle (update_model_once, data);
}
static gboolean
update_model_loop (gpointer gdata)
{
const gboolean done = global_sigcount;
if (!done)
update_model_once (gdata);
return !done;
}
static void
show_about_dialog (GtkWindow * parent)
{
const char * uri = "http://www.transmissionbt.com/";
const char * authors[] = { "Jordan Lee (Backend; GTK+)",
"Mitchell Livingston (Backend; OS X)",
NULL };
gtk_show_about_dialog (parent,
"authors", authors,
"comments", _("A fast and easy BitTorrent client"),
"copyright", _("Copyright (c) The Transmission Project"),
"logo-icon-name", MY_CONFIG_NAME,
"name", g_get_application_name (),
/* Translators: translate "translator-credits" as your name
to have it appear in the credits in the "About"
dialog */
"translator-credits", _("translator-credits"),
"version", LONG_VERSION_STRING,
"website", uri,
"website-label", uri,
#ifdef SHOW_LICENSE
"license", LICENSE,
"wrap-license", TRUE,
#endif
NULL);
}
static void
append_id_to_benc_list (GtkTreeModel * m, GtkTreePath * path UNUSED,
GtkTreeIter * iter, gpointer list)
{
tr_torrent * tor = NULL;
gtk_tree_model_get (m, iter, MC_TORRENT, &tor, -1);
tr_variantListAddInt (list, tr_torrentId (tor));
}
static gboolean
call_rpc_for_selected_torrents (struct cbdata * data, const char * method)
{
tr_variant top, *args, *ids;
gboolean invoked = FALSE;
GtkTreeSelection * s = data->sel;
tr_session * session = gtr_core_session (data->core);
tr_variantInitDict (&top, 2);
tr_variantDictAddStr (&top, TR_KEY_method, method);
args = tr_variantDictAddDict (&top, TR_KEY_arguments, 1);
ids = tr_variantDictAddList (args, TR_KEY_ids, 0);
gtk_tree_selection_selected_foreach (s, append_id_to_benc_list, ids);
if (tr_variantListSize (ids) != 0)
{
int json_len;
char * json = tr_variantToStr (&top, TR_VARIANT_FMT_JSON_LEAN, &json_len);
tr_rpc_request_exec_json (session, json, json_len, NULL, NULL);
g_free (json);
invoked = TRUE;
}
tr_variantFree (&top);
return invoked;
}
static void
open_folder_foreach (GtkTreeModel * model, GtkTreePath * path UNUSED,
GtkTreeIter * iter, gpointer core)
{
int id;
gtk_tree_model_get (model, iter, MC_TORRENT_ID, &id, -1);
gtr_core_open_folder (core, id);
}
static gboolean
on_message_window_closed (void)
{
gtr_action_set_toggled ("toggle-message-log", FALSE);
return FALSE;
}
static void
accumulate_selected_torrents (GtkTreeModel * model, GtkTreePath * path UNUSED,
GtkTreeIter * iter, gpointer gdata)
{
int id;
GSList ** data = gdata;
gtk_tree_model_get (model, iter, MC_TORRENT_ID, &id, -1);
*data = g_slist_append (*data, GINT_TO_POINTER (id));
}
static void
remove_selected (struct cbdata * data, gboolean delete_files)
{
GSList * l = NULL;
gtk_tree_selection_selected_foreach (data->sel, accumulate_selected_torrents, &l);
if (l != NULL)
gtr_confirm_remove (data->wind, data->core, l, delete_files);
}
static void
start_all_torrents (struct cbdata * data)
{
tr_session * session = gtr_core_session (data->core);
const char * cmd = "{ \"method\": \"torrent-start\" }";
tr_rpc_request_exec_json (session, cmd, strlen (cmd), NULL, NULL);
}
static void
pause_all_torrents (struct cbdata * data)
{
tr_session * session = gtr_core_session (data->core);
const char * cmd = "{ \"method\": \"torrent-stop\" }";
tr_rpc_request_exec_json (session, cmd, strlen (cmd), NULL, NULL);
}
static tr_torrent*
get_first_selected_torrent (struct cbdata * data)
{
tr_torrent * tor = NULL;
GtkTreeModel * m;
GList * l = gtk_tree_selection_get_selected_rows (data->sel, &m);
if (l != NULL)
{
GtkTreePath * p = l->data;
GtkTreeIter i;
if (gtk_tree_model_get_iter (m, &i, p))
gtk_tree_model_get (m, &i, MC_TORRENT, &tor, -1);
}
g_list_foreach (l, (GFunc)gtk_tree_path_free, NULL);
g_list_free (l);
return tor;
}
static void
copy_magnet_link_to_clipboard (GtkWidget * w, tr_torrent * tor)
{
char * magnet = tr_torrentGetMagnetLink (tor);
GdkDisplay * display = gtk_widget_get_display (w);
GdkAtom selection;
GtkClipboard * clipboard;
/* this is The Right Thing for copy/paste... */
selection = GDK_SELECTION_CLIPBOARD;
clipboard = gtk_clipboard_get_for_display (display, selection);
gtk_clipboard_set_text (clipboard, magnet, -1);
/* ...but people using plain ol' X need this instead */
selection = GDK_SELECTION_PRIMARY;
clipboard = gtk_clipboard_get_for_display (display, selection);
gtk_clipboard_set_text (clipboard, magnet, -1);
/* cleanup */
tr_free (magnet);
}
void
gtr_actions_handler (const char * action_name, gpointer user_data)
{
gboolean changed = FALSE;
struct cbdata * data = user_data;
if (!g_strcmp0 (action_name, "open-torrent-from-url"))
{
GtkWidget * w = gtr_torrent_open_from_url_dialog_new (data->wind, data->core);
gtk_widget_show (w);
}
else if (!g_strcmp0 (action_name, "open-torrent-menu")
|| !g_strcmp0 (action_name, "open-torrent-toolbar"))
{
GtkWidget * w = gtr_torrent_open_from_file_dialog_new (data->wind, data->core);
gtk_widget_show (w);
}
else if (!g_strcmp0 (action_name, "show-stats"))
{
GtkWidget * dialog = gtr_stats_dialog_new (data->wind, data->core);
gtk_widget_show (dialog);
}
else if (!g_strcmp0 (action_name, "donate"))
{
gtr_open_uri ("http://www.transmissionbt.com/donate.php");
}
else if (!g_strcmp0 (action_name, "pause-all-torrents"))
{
pause_all_torrents (data);
}
else if (!g_strcmp0 (action_name, "start-all-torrents"))
{
start_all_torrents (data);
}
else if (!g_strcmp0 (action_name, "copy-magnet-link-to-clipboard"))
{
tr_torrent * tor = get_first_selected_torrent (data);
if (tor != NULL)
{
copy_magnet_link_to_clipboard (GTK_WIDGET (data->wind), tor);
}
}
else if (!g_strcmp0 (action_name, "relocate-torrent"))
{
GSList * ids = get_selected_torrent_ids (data);
if (ids != NULL)
{
GtkWindow * parent = data->wind;
GtkWidget * w = gtr_relocate_dialog_new (parent, data->core, ids);
gtk_widget_show (w);
}
}
else if (!g_strcmp0 (action_name, "torrent-start")
|| !g_strcmp0 (action_name, "torrent-start-now")
|| !g_strcmp0 (action_name, "torrent-stop")
|| !g_strcmp0 (action_name, "torrent-reannounce")
|| !g_strcmp0 (action_name, "torrent-verify")
|| !g_strcmp0 (action_name, "queue-move-top")
|| !g_strcmp0 (action_name, "queue-move-up")
|| !g_strcmp0 (action_name, "queue-move-down")
|| !g_strcmp0 (action_name, "queue-move-bottom"))
{
changed |= call_rpc_for_selected_torrents (data, action_name);
}
else if (!g_strcmp0 (action_name, "open-torrent-folder"))
{
gtk_tree_selection_selected_foreach (data->sel, open_folder_foreach, data->core);
}
else if (!g_strcmp0 (action_name, "show-torrent-properties"))
{
show_details_dialog_for_selected_torrents (data);
}
else if (!g_strcmp0 (action_name, "new-torrent"))
{
GtkWidget * w = gtr_torrent_creation_dialog_new (data->wind, data->core);
gtk_widget_show (w);
}
else if (!g_strcmp0 (action_name, "remove-torrent"))
{
remove_selected (data, FALSE);
}
else if (!g_strcmp0 (action_name, "delete-torrent"))
{
remove_selected (data, TRUE);
}
else if (!g_strcmp0 (action_name, "quit"))
{
on_app_exit (data);
}
else if (!g_strcmp0 (action_name, "select-all"))
{
gtk_tree_selection_select_all (data->sel);
}
else if (!g_strcmp0 (action_name, "deselect-all"))
{
gtk_tree_selection_unselect_all (data->sel);
}
else if (!g_strcmp0 (action_name, "edit-preferences"))
{
if (NULL == data->prefs)
{
data->prefs = gtr_prefs_dialog_new (data->wind, G_OBJECT (data->core));
g_signal_connect (data->prefs, "destroy",
G_CALLBACK (gtk_widget_destroyed), &data->prefs);
}
gtr_window_present (GTK_WINDOW (data->prefs));
}
else if (!g_strcmp0 (action_name, "toggle-message-log"))
{
if (!data->msgwin)
{
GtkWidget * win = gtr_message_log_window_new (data->wind, data->core);
g_signal_connect (win, "destroy", G_CALLBACK (on_message_window_closed), NULL);
data->msgwin = win;
}
else
{
gtr_action_set_toggled ("toggle-message-log", FALSE);
gtk_widget_destroy (data->msgwin);
data->msgwin = NULL;
}
}
else if (!g_strcmp0 (action_name, "show-about-dialog"))
{
show_about_dialog (data->wind);
}
else if (!g_strcmp0 (action_name, "help"))
{
gtr_open_uri (gtr_get_help_uri ());
}
else if (!g_strcmp0 (action_name, "toggle-main-window"))
{
toggleMainWindow (data);
}
else if (!g_strcmp0 (action_name, "present-main-window"))
{
presentMainWindow (data);
}
else
{
g_error ("Unhandled action: %s", action_name);
}
if (changed)
update_model_soon (data);
}
Reference in a new issue View git blame Copy permalink