release/src/router/transmission/gtk/util.c

   1 /*
   2  * This file Copyright (C) Mnemosyne LLC
   3  *
   4  * This file is licensed by the GPL version 2. Works owned by the
   5  * Transmission project are granted a special exemption to clause 2 (b)
   6  * so that the bulk of its code can remain under the MIT license.
   7  * This exemption does not extend to derived works not owned by
   8  * the Transmission project.
   9  *
  10  * $Id: util.c 14143 2013-07-24 17:11:21Z jordan $
  11  */
  12
  13 #include <ctype.h> /* isxdigit () */
  14 #include <errno.h>
  15 #include <stdarg.h>
  16 #include <string.h> /* strchr (), strrchr (), strlen (), strstr () */
  17
  18 #include <gtk/gtk.h>
  19 #include <glib/gi18n.h>
  20 #include <gio/gio.h> /* g_file_trash () */
  21
  22 #include <libtransmission/transmission.h> /* TR_RATIO_NA, TR_RATIO_INF */
  23 #include <libtransmission/utils.h> /* tr_strratio () */
  24 #include <libtransmission/web.h> /* tr_webResponseStr () */
  25 #include <libtransmission/version.h> /* SHORT_VERSION_STRING */
  26
  27 #include "conf.h"
  28 #include "hig.h"
  29 #include "tr-core.h"
  30 #include "tr-prefs.h"
  31 #include "util.h"
  32
  33 /***
  34 ****  UNITS
  35 ***/
  36
  37 const int mem_K = 1024;
  38 const char * mem_K_str = N_("KiB");
  39 const char * mem_M_str = N_("MiB");
  40 const char * mem_G_str = N_("GiB");
  41 const char * mem_T_str = N_("TiB");
  42
  43 const int disk_K = 1000;
  44 const char * disk_K_str = N_("kB");
  45 const char * disk_M_str = N_("MB");
  46 const char * disk_G_str = N_("GB");
  47 const char * disk_T_str = N_("TB");
  48
  49 const int speed_K = 1000;
  50 const char * speed_K_str = N_("kB/s");
  51 const char * speed_M_str = N_("MB/s");
  52 const char * speed_G_str = N_("GB/s");
  53 const char * speed_T_str = N_("TB/s");
  54
  55 /***
  56 ****
  57 ***/
  58
  59 const char*
  60 gtr_get_unicode_string (int i)
  61 {
  62   switch (i)
  63     {
  64       case GTR_UNICODE_UP:      return "\xE2\x96\xB4";
  65       case GTR_UNICODE_DOWN:    return "\xE2\x96\xBE";
  66       case GTR_UNICODE_INF:     return "\xE2\x88\x9E";
  67       case GTR_UNICODE_BULLET:  return "\xE2\x88\x99";
  68       default:                  return "err";
  69     }
  70 }
  71
  72 char*
  73 tr_strlratio (char * buf, double ratio, size_t buflen)
  74 {
  75   return tr_strratio (buf, buflen, ratio, gtr_get_unicode_string (GTR_UNICODE_INF));
  76 }
  77
  78 char*
  79 tr_strlpercent (char * buf, double x, size_t buflen)
  80 {
  81   return tr_strpercent (buf, x, buflen);
  82 }
  83
  84 char*
  85 tr_strlsize (char * buf, guint64 bytes, size_t buflen)
  86 {
  87   if (!bytes)
  88     g_strlcpy (buf, Q_("None"), buflen);
  89   else
  90     tr_formatter_size_B (buf, bytes, buflen);
  91
  92   return buf;
  93 }
  94
  95 char*
  96 tr_strltime (char * buf, int seconds, size_t buflen)
  97 {
  98   int days, hours, minutes;
  99   char d[128], h[128], m[128], s[128];
 100
 101   if (seconds < 0)
 102     seconds = 0;
 103
 104   days = seconds / 86400;
 105   hours = (seconds % 86400) / 3600;
 106   minutes = (seconds % 3600) / 60;
 107   seconds = (seconds % 3600) % 60;
 108
 109   g_snprintf (d, sizeof (d), ngettext ("%'d day", "%'d days", days), days);
 110   g_snprintf (h, sizeof (h), ngettext ("%'d hour", "%'d hours", hours), hours);
 111   g_snprintf (m, sizeof (m), ngettext ("%'d minute", "%'d minutes", minutes), minutes);
 112   g_snprintf (s, sizeof (s), ngettext ("%'d second", "%'d seconds", seconds), seconds);
 113
 114   if (days)
 115     {
 116       if (days >= 4 || !hours)
 117         g_strlcpy (buf, d, buflen);
 118       else
 119         g_snprintf (buf, buflen, "%s, %s", d, h);
 120     }
 121   else if (hours)
 122     {
 123       if (hours >= 4 || !minutes)
 124         g_strlcpy (buf, h, buflen);
 125       else
 126         g_snprintf (buf, buflen, "%s, %s", h, m);
 127     }
 128   else if (minutes)
 129     {
 130       if (minutes >= 4 || !seconds)
 131         g_strlcpy (buf, m, buflen);
 132       else
 133         g_snprintf (buf, buflen, "%s, %s", m, s);
 134     }
 135   else
 136     {
 137       g_strlcpy (buf, s, buflen);
 138     }
 139
 140   return buf;
 141 }
 142
 143 /* pattern-matching text; ie, legaltorrents.com */
 144 void
 145 gtr_get_host_from_url (char * buf, size_t buflen, const char * url)
 146 {
 147   char host[1024];
 148   const char * pch;
 149
 150   if ((pch = strstr (url, "://")))
 151     {
 152       const size_t hostlen = strcspn (pch+3, ":/");
 153       const size_t copylen = MIN (hostlen, sizeof (host)-1);
 154       memcpy (host, pch+3, copylen);
 155       host[copylen] = '\0';
 156     }
 157   else
 158     {
 159       *host = '\0';
 160     }
 161
 162   if (tr_addressIsIP (host))
 163     {
 164       g_strlcpy (buf, url, buflen);
 165     }
 166   else
 167     {
 168       const char * first_dot = strchr (host, '.');
 169       const char * last_dot = strrchr (host, '.');
 170       if ((first_dot) && (last_dot) && (first_dot != last_dot))
 171         g_strlcpy (buf, first_dot + 1, buflen);
 172       else
 173         g_strlcpy (buf, host, buflen);
 174     }
 175 }
 176
 177 static gboolean
 178 gtr_is_supported_url (const char * str)
 179 {
 180   return ((str != NULL) &&
 181            (g_str_has_prefix (str, "ftp://") ||
 182             g_str_has_prefix (str, "http://") ||
 183             g_str_has_prefix (str, "https://")));
 184 }
 185
 186 gboolean
 187 gtr_is_magnet_link (const char * str)
 188 {
 189   return (str != NULL) && (g_str_has_prefix (str, "magnet:?"));
 190 }
 191
 192 gboolean
 193 gtr_is_hex_hashcode (const char * str)
 194 {
 195   int i;
 196
 197   if (!str || (strlen (str) != 40))
 198     return FALSE;
 199
 200   for (i=0; i<40; ++i)
 201     if (!isxdigit (str[i]))
 202       return FALSE;
 203
 204   return TRUE;
 205 }
 206
 207 static GtkWindow *
 208 getWindow (GtkWidget * w)
 209 {
 210   if (w == NULL)
 211     return NULL;
 212
 213   if (GTK_IS_WINDOW (w))
 214     return GTK_WINDOW (w);
 215
 216   return GTK_WINDOW (gtk_widget_get_ancestor (w, GTK_TYPE_WINDOW));
 217 }
 218
 219 void
 220 gtr_add_torrent_error_dialog (GtkWidget   * child,
 221                               int           err,
 222                               tr_torrent  * duplicate_torrent,
 223                               const char  * filename)
 224 {
 225   char * secondary;
 226   GtkWidget * w;
 227   GtkWindow * win = getWindow (child);
 228
 229   if (err == TR_PARSE_ERR)
 230     secondary = g_strdup_printf (_("The torrent file \"%s\" contains invalid data."), filename);
 231   else if (err == TR_PARSE_DUPLICATE)
 232     secondary = g_strdup_printf (_("The torrent file \"%s\" is already in use by \"%s.\""), filename, tr_torrentName (duplicate_torrent));
 233   else
 234     secondary = g_strdup_printf (_("The torrent file \"%s\" encountered an unknown error."), filename);
 235
 236   w = gtk_message_dialog_new (win,
 237                               GTK_DIALOG_DESTROY_WITH_PARENT,
 238                               GTK_MESSAGE_ERROR,
 239                               GTK_BUTTONS_CLOSE,
 240                               "%s", _("Error opening torrent"));
 241   gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (w),
 242                                             "%s", secondary);
 243   g_signal_connect_swapped (w, "response",
 244                             G_CALLBACK (gtk_widget_destroy), w);
 245   gtk_widget_show_all (w);
 246   g_free (secondary);
 247 }
 248
 249 typedef void (PopupFunc)(GtkWidget*, GdkEventButton*);
 250
 251 /* pop up the context menu if a user right-clicks.
 252    if the row they right-click on isn't selected, select it. */
 253
 254 gboolean
 255 on_tree_view_button_pressed (GtkWidget *      view,
 256                              GdkEventButton * event,
 257                              gpointer         func)
 258 {
 259   GtkTreeView * tv = GTK_TREE_VIEW (view);
 260
 261   if (event->type == GDK_BUTTON_PRESS  &&  event->button == 3)
 262     {
 263       GtkTreePath * path;
 264       GtkTreeSelection * selection = gtk_tree_view_get_selection (tv);
 265
 266       if (gtk_tree_view_get_path_at_pos (tv,
 267                                          (gint) event->x,
 268                                          (gint) event->y,
 269                                          &path, NULL, NULL, NULL))
 270         {
 271           if (!gtk_tree_selection_path_is_selected (selection, path))
 272             {
 273               gtk_tree_selection_unselect_all (selection);
 274               gtk_tree_selection_select_path (selection, path);
 275             }
 276           gtk_tree_path_free (path);
 277         }
 278
 279       if (func != NULL)
 280         ((PopupFunc*)func)(view, event);
 281
 282       return TRUE;
 283     }
 284
 285   return FALSE;
 286 }
 287
 288 /* if the user clicked in an empty area of the list,
 289  * clear all the selections. */
 290 gboolean
 291 on_tree_view_button_released (GtkWidget *      view,
 292                               GdkEventButton * event,
 293                               gpointer         unused UNUSED)
 294 {
 295   GtkTreeView * tv = GTK_TREE_VIEW (view);
 296
 297   if (!gtk_tree_view_get_path_at_pos (tv,
 298                                       (gint) event->x,
 299                                       (gint) event->y,
 300                                       NULL, NULL, NULL, NULL))
 301     {
 302       GtkTreeSelection * selection = gtk_tree_view_get_selection (tv);
 303       gtk_tree_selection_unselect_all (selection);
 304     }
 305
 306   return FALSE;
 307 }
 308
 309 int
 310 gtr_file_trash_or_remove (const char * filename)
 311 {
 312   GFile * file;
 313   gboolean trashed = FALSE;
 314
 315   g_return_val_if_fail (filename && *filename, 0);
 316
 317   file = g_file_new_for_path (filename);
 318
 319   if (gtr_pref_flag_get (TR_KEY_trash_can_enabled))
 320     {
 321       GError * err = NULL;
 322       trashed = g_file_trash (file, NULL, &err);
 323       if (err)
 324         {
 325           g_message ("Unable to trash file \"%s\": %s", filename, err->message);
 326           g_clear_error (&err);
 327         }
 328     }
 329
 330   if (!trashed)
 331     {
 332       GError * err = NULL;
 333       g_file_delete (file, NULL, &err);
 334       if (err)
 335         {
 336           g_message ("Unable to delete file \"%s\": %s", filename, err->message);
 337           g_clear_error (&err);
 338         }
 339     }
 340
 341   g_object_unref (G_OBJECT (file));
 342   return 0;
 343 }
 344
 345 const char*
 346 gtr_get_help_uri (void)
 347 {
 348   static char * uri = NULL;
 349
 350   if (!uri)
 351     {
 352       int major, minor;
 353       const char * fmt = "http://www.transmissionbt.com/help/gtk/%d.%dx";
 354       sscanf (SHORT_VERSION_STRING, "%d.%d", &major, &minor);
 355       uri = g_strdup_printf (fmt, major, minor / 10);
 356     }
 357
 358   return uri;
 359 }
 360
 361 void
 362 gtr_open_file (const char * path)
 363 {
 364   GFile * file = g_file_new_for_path (path);
 365   gchar * uri = g_file_get_uri (file);
 366   gtr_open_uri (uri);
 367   g_free (uri);
 368   g_object_unref (file);
 369 }
 370
 371 void
 372 gtr_open_uri (const char * uri)
 373 {
 374   if (uri)
 375     {
 376       gboolean opened = FALSE;
 377
 378       if (!opened)
 379         opened = gtk_show_uri (NULL, uri, GDK_CURRENT_TIME, NULL);
 380
 381       if (!opened)
 382         opened = g_app_info_launch_default_for_uri (uri, NULL, NULL);
 383
 384       if (!opened)
 385         {
 386           char * argv[] = { (char*)"xdg-open", (char*)uri, NULL };
 387           opened = g_spawn_async (NULL, argv, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL, NULL, NULL);
 388         }
 389
 390       if (!opened)
 391         g_message ("Unable to open \"%s\"", uri);
 392     }
 393 }
 394
 395 /***
 396 ****
 397 ***/
 398
 399 void
 400 gtr_combo_box_set_active_enum (GtkComboBox * combo_box, int value)
 401 {
 402   int i;
 403   int currentValue;
 404   const int column = 0;
 405   GtkTreeIter iter;
 406   GtkTreeModel * model = gtk_combo_box_get_model (combo_box);
 407
 408   /* do the value and current value match? */
 409   if (gtk_combo_box_get_active_iter (combo_box, &iter))
 410     {
 411       gtk_tree_model_get (model, &iter, column, &currentValue, -1);
 412       if (currentValue == value)
 413         return;
 414     }
 415
 416   /* find the one to select */
 417   i = 0;
 418   while ((gtk_tree_model_iter_nth_child (model, &iter, NULL, i++)))
 419     {
 420       gtk_tree_model_get (model, &iter, column, &currentValue, -1);
 421       if (currentValue == value)
 422         {
 423           gtk_combo_box_set_active_iter (combo_box, &iter);
 424           return;
 425         }
 426     }
 427 }
 428
 429
 430 GtkWidget *
 431 gtr_combo_box_new_enum (const char * text_1, ...)
 432 {
 433   GtkWidget * w;
 434   GtkCellRenderer * r;
 435   GtkListStore * store;
 436   va_list vl;
 437   const char * text;
 438   va_start (vl, text_1);
 439
 440   store = gtk_list_store_new (2, G_TYPE_INT, G_TYPE_STRING);
 441
 442   text = text_1;
 443   if (text != NULL) do
 444     {
 445       const int val = va_arg (vl, int);
 446       gtk_list_store_insert_with_values (store, NULL, INT_MAX, 0, val, 1, text, -1);
 447       text = va_arg (vl, const char *);
 448     }
 449   while (text != NULL);
 450
 451   w = gtk_combo_box_new_with_model (GTK_TREE_MODEL (store));
 452   r = gtk_cell_renderer_text_new ();
 453   gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (w), r, TRUE);
 454   gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (w), r, "text", 1, NULL);
 455
 456   /* cleanup */
 457   g_object_unref (store);
 458   return w;
 459 }
 460
 461 int
 462 gtr_combo_box_get_active_enum (GtkComboBox * combo_box)
 463 {
 464   int value = 0;
 465   GtkTreeIter iter;
 466
 467   if (gtk_combo_box_get_active_iter (combo_box, &iter))
 468     gtk_tree_model_get (gtk_combo_box_get_model (combo_box), &iter, 0, &value, -1);
 469
 470   return value;
 471 }
 472
 473 GtkWidget *
 474 gtr_priority_combo_new (void)
 475 {
 476   return gtr_combo_box_new_enum (_("High"),   TR_PRI_HIGH,
 477                                  _("Normal"), TR_PRI_NORMAL,
 478                                  _("Low"),    TR_PRI_LOW,
 479                                  NULL);
 480 }
 481
 482 /***
 483 ****
 484 ***/
 485
 486 #define GTR_CHILD_HIDDEN "gtr-child-hidden"
 487
 488 void
 489 gtr_widget_set_visible (GtkWidget * w, gboolean b)
 490 {
 491   /* toggle the transient children, too */
 492   if (GTK_IS_WINDOW (w))
 493     {
 494       GList * l;
 495       GList * windows = gtk_window_list_toplevels ();
 496       GtkWindow * window = GTK_WINDOW (w);
 497
 498       for (l=windows; l!=NULL; l=l->next)
 499         {
 500           if (!GTK_IS_WINDOW (l->data))
 501             continue;
 502           if (gtk_window_get_transient_for (GTK_WINDOW (l->data)) != window)
 503             continue;
 504           if (gtk_widget_get_visible (GTK_WIDGET (l->data)) == b)
 505             continue;
 506
 507           if (b && g_object_get_data (G_OBJECT (l->data), GTR_CHILD_HIDDEN) != NULL)
 508             {
 509               g_object_steal_data (G_OBJECT (l->data), GTR_CHILD_HIDDEN);
 510               gtr_widget_set_visible (GTK_WIDGET (l->data), TRUE);
 511             }
 512           else if (!b)
 513             {
 514               g_object_set_data (G_OBJECT (l->data), GTR_CHILD_HIDDEN, GINT_TO_POINTER (1));
 515               gtr_widget_set_visible (GTK_WIDGET (l->data), FALSE);
 516             }
 517         }
 518
 519       g_list_free (windows);
 520     }
 521
 522   gtk_widget_set_visible (w, b);
 523 }
 524
 525 void
 526 gtr_dialog_set_content (GtkDialog * dialog, GtkWidget * content)
 527 {
 528   GtkWidget * vbox = gtk_dialog_get_content_area (dialog);
 529   gtk_box_pack_start (GTK_BOX (vbox), content, TRUE, TRUE, 0);
 530   gtk_widget_show_all (content);
 531 }
 532
 533 /***
 534 ****
 535 ***/
 536
 537 void
 538 gtr_http_failure_dialog (GtkWidget * parent, const char * url, long response_code)
 539 {
 540   GtkWindow * window = getWindow (parent);
 541
 542   GtkWidget * w = gtk_message_dialog_new (window, 0,
 543                                           GTK_MESSAGE_ERROR,
 544                                           GTK_BUTTONS_CLOSE,
 545                                           _("Error opening \"%s\""), url);
 546
 547   gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (w),
 548                                             _("Server returned \"%1$ld %2$s\""),
 549                                             response_code,
 550                                             tr_webGetResponseStr (response_code));
 551
 552   g_signal_connect_swapped (w, "response", G_CALLBACK (gtk_widget_destroy), w);
 553   gtk_widget_show (w);
 554 }
 555
 556 void
 557 gtr_unrecognized_url_dialog (GtkWidget * parent, const char * url)
 558 {
 559   const char * xt = "xt=urn:btih";
 560
 561   GtkWindow * window = getWindow (parent);
 562
 563   GString * gstr = g_string_new (NULL);
 564
 565   GtkWidget * w = gtk_message_dialog_new (window, 0,
 566                                           GTK_MESSAGE_ERROR,
 567                                           GTK_BUTTONS_CLOSE,
 568                                           "%s", _("Unrecognized URL"));
 569
 570   g_string_append_printf (gstr, _("Transmission doesn't know how to use \"%s\""), url);
 571
 572   if (gtr_is_magnet_link (url) && (strstr (url, xt) == NULL))
 573     {
 574       g_string_append_printf (gstr, "\n \n");
 575       g_string_append_printf (gstr, _("This magnet link appears to be intended for something other than BitTorrent. BitTorrent magnet links have a section containing \"%s\"."), xt);
 576     }
 577
 578   gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (w), "%s", gstr->str);
 579   g_signal_connect_swapped (w, "response", G_CALLBACK (gtk_widget_destroy), w);
 580   gtk_widget_show (w);
 581   g_string_free (gstr, TRUE);
 582 }
 583
 584 /***
 585 ****
 586 ***/
 587
 588 void
 589 gtr_paste_clipboard_url_into_entry (GtkWidget * e)
 590 {
 591   size_t i;
 592
 593   char * text[] =
 594     {
 595       g_strstrip (gtk_clipboard_wait_for_text (gtk_clipboard_get (GDK_SELECTION_PRIMARY))),
 596       g_strstrip (gtk_clipboard_wait_for_text (gtk_clipboard_get (GDK_SELECTION_CLIPBOARD)))
 597     };
 598
 599   for (i=0; i<G_N_ELEMENTS (text); ++i)
 600     {
 601       char * s = text[i];
 602       if (s && (gtr_is_supported_url (s) || gtr_is_magnet_link (s) || gtr_is_hex_hashcode (s)))
 603         {
 604           gtk_entry_set_text (GTK_ENTRY (e), s);
 605           break;
 606         }
 607     }
 608
 609   for (i=0; i<G_N_ELEMENTS (text); ++i)
 610     g_free (text[i]);
 611 }
 612
 613 /***
 614 ****
 615 ***/
 616
 617 void
 618 gtr_label_set_text (GtkLabel * lb, const char * newstr)
 619 {
 620   const char * oldstr = gtk_label_get_text (lb);
 621
 622   if (g_strcmp0 (oldstr, newstr))
 623     gtk_label_set_text (lb, newstr);
 624 }
 625
 626 /***
 627 ****
 628 ***/
 629
 630 struct freespace_label_data
 631 {
 632   guint timer_id;
 633   TrCore * core;
 634   GtkLabel * label;
 635   char * dir;
 636 };
 637
 638 static void on_freespace_label_core_destroyed (gpointer gdata, GObject * dead_core);
 639 static void on_freespace_label_destroyed      (gpointer gdata, GObject * dead_label);
 640
 641 static void
 642 freespace_label_data_free (gpointer gdata)
 643 {
 644   struct freespace_label_data * data = gdata;
 645
 646   if (data->core != NULL)
 647     g_object_weak_unref (G_OBJECT(data->core), on_freespace_label_core_destroyed, data);
 648
 649   if (data->label != NULL)
 650     g_object_weak_ref (G_OBJECT(data->label), on_freespace_label_destroyed, data);
 651
 652   g_source_remove (data->timer_id);
 653   g_free (data->dir);
 654   g_free (data);
 655 }
 656
 657 static TR_DEFINE_QUARK (freespace_label_data, freespace_label_data)
 658
 659 static void
 660 on_freespace_label_core_destroyed (gpointer gdata, GObject * dead_core G_GNUC_UNUSED)
 661 {
 662   struct freespace_label_data * data = gdata;
 663   data->core = NULL;
 664   freespace_label_data_free (data);
 665 }
 666
 667 static void
 668 on_freespace_label_destroyed (gpointer gdata, GObject * dead_label G_GNUC_UNUSED)
 669 {
 670   struct freespace_label_data * data = gdata;
 671   data->label = NULL;
 672   freespace_label_data_free (data);
 673 }
 674
 675 static gboolean
 676 on_freespace_timer (gpointer gdata)
 677 {
 678   char text[128];
 679   char markup[128];
 680   int64_t bytes;
 681   tr_session * session;
 682   struct freespace_label_data * data = gdata;
 683
 684   session = gtr_core_session (data->core);
 685   bytes = tr_sessionGetDirFreeSpace (session, data->dir);
 686
 687   if (bytes < 0)
 688     {
 689       g_snprintf (text, sizeof(text), _("Error"));
 690     }
 691   else
 692     {
 693       char size[128];
 694       tr_strlsize (size, bytes, sizeof(size));
 695       g_snprintf (text, sizeof(text), _("%s free"), size);
 696     }
 697
 698   g_snprintf (markup, sizeof(markup), "<i>%s</i>", text);
 699   gtk_label_set_markup (data->label, markup);
 700
 701   return G_SOURCE_CONTINUE;
 702 }
 703
 704 GtkWidget *
 705 gtr_freespace_label_new (struct _TrCore * core, const char * dir)
 706 {
 707   struct freespace_label_data * data;
 708
 709   data = g_new0 (struct freespace_label_data, 1);
 710   data->timer_id = g_timeout_add_seconds (3, on_freespace_timer, data);
 711   data->core = core;
 712   data->label = GTK_LABEL (gtk_label_new (NULL));
 713   data->dir = g_strdup (dir);
 714
 715   /* when either the core or the label is destroyed, stop updating */
 716   g_object_weak_ref (G_OBJECT(core), on_freespace_label_core_destroyed, data);
 717   g_object_weak_ref (G_OBJECT(data->label), on_freespace_label_destroyed, data);
 718
 719   g_object_set_qdata (G_OBJECT(data->label), freespace_label_data_quark (), data);
 720   on_freespace_timer (data);
 721   return GTK_WIDGET (data->label);
 722 }
 723
 724 void
 725 gtr_freespace_label_set_dir (GtkWidget * label, const char * dir)
 726 {
 727   struct freespace_label_data * data;
 728
 729   data = g_object_get_qdata (G_OBJECT(label), freespace_label_data_quark ());
 730
 731   tr_free (data->dir);
 732   data->dir = g_strdup (dir);
 733   on_freespace_timer (data);
 734 }