ROX-Filer/src/gtksavebox.c

   1 /*
   2  * $Id$
   3  *
   4  * SaveBox widget for the ROX desktop project
   5  * Copyright (C) 2005 Thomas Leonard.
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the Free
   9  * Software Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful, but WITHOUT
  13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  15  * more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along with
  18  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  19  * Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 /* gtksavebox.c - ROX-style savebox widget */
  23
  24 /*
  25  * Note: This file is formatted like the Gtk+ sources, as it is/was hoped
  26  * to include it in Gtk+ at some point.
  27  */
  28
  29 #include "config.h"
  30
  31 #include <unistd.h>
  32 #include <string.h>
  33 #include <errno.h>
  34
  35 #include "gdk/gdkkeysyms.h"
  36
  37 #include "gtksavebox.h"
  38 #include "gtk/gtkwidget.h"
  39 #include "gtk/gtkalignment.h"
  40 #include "gtk/gtkdnd.h"
  41 #include "gtk/gtkbutton.h"
  42 #include "gtk/gtksignal.h"
  43 #include "gtk/gtkhbox.h"
  44 #include "gtk/gtkeventbox.h"
  45 #include "gtk/gtkentry.h"
  46 #include "gtk/gtkmessagedialog.h"
  47 #include "gtk/gtkhseparator.h"
  48 #include "gtk/gtkvbox.h"
  49 #include "gtk/gtkdialog.h"
  50 #include "gtk/gtklabel.h"
  51 #include "gtk/gtkstock.h"
  52
  53 #include "global.h"
  54 #include "support.h"
  55 #include "gui_support.h"
  56
  57 /*
  58  * Behaviour:
  59  *
  60  * - Clicking Save or pressing Return:
  61  *      - Emits 'save_to_file',
  62  *      - Emits 'saved_to_uri' (with the same pathname),
  63  *      - Destroys the widget.
  64  *
  65  * - Clicking Cancel or pressing Escape:
  66  *      - Destroys the widget.
  67  *
  68  * - Dragging the data somewhere:
  69  *      - Will either emit 'save_to_file' or get the selection,
  70  *      - Emits 'saved_to_uri' (possibly with a NULL URI),
  71  *      - Destroys the widget.
  72  *
  73  * - Clicking Discard:
  74  *      - Emits 'saved_to_uri' with a NULL URI,
  75  *      - Destroys the widget.
  76  *
  77  * To clarify: 'saved_to_uri' indicates that the save was successful. A
  78  * NULL URI just means that the data was saved to another application rather
  79  * than a fixed address. Data should only be marked unmodified when
  80  * saved_to_uri is called with a non-NULL URI.
  81  *
  82  * Discard is a bit like a successful save to a null device. The data should
  83  * be discarded when saved_to_uri is called, whatever URI is set to.
  84  *
  85  *
  86  * Signals:
  87  *
  88  * gint save_to_file (GtkSavebox *savebox, const gchar *pathname)
  89  *      Save the data to disk using this pathname. Return GTK_XDS_SAVED
  90  *      on success, or GTK_XDS_SAVE_ERROR on failure (and report the error
  91  *      to the user somehow). DO NOT mark the data unmodified or change
  92  *      the pathname for the file - this might be a scrap file transfer.
  93  *
  94  * void saved_to_uri (GtkSavebox *savebox, const gchar *uri)
  95  *      The data is saved. If 'uri' is non-NULL, mark the file as unmodified
  96  *      and update the pathname/uri for the file to the one given.
  97  *      The URI is UTF-8 (not escaped).
  98  */
  99
 100 enum {
 101   PROP_0,
 102   PROP_HAS_DISCARD
 103 };
 104
 105 enum
 106 {
 107   SAVE_TO_FILE,
 108   SAVED_TO_URI,
 109
 110   LAST_SIGNAL
 111 };
 112
 113 static gpointer parent_class;
 114 static guint savebox_signals[LAST_SIGNAL];
 115
 116 /* Longest possible XdndDirectSave0 property value */
 117 #define XDS_MAXURILEN 4096
 118
 119 static GdkAtom XdndDirectSave;
 120 static GdkAtom text_plain;
 121 static GdkAtom xa_string;
 122
 123 static void gtk_savebox_class_init (GtkSaveboxClass   *klass);
 124 static void gtk_savebox_init       (GtkSavebox        *savebox);
 125 static void button_press_over_icon (GtkWidget         *drag_box,
 126                                     GdkEventButton    *event,
 127                                     GtkSavebox        *savebox);
 128 static void drag_data_get          (GtkWidget         *widget,
 129                                     GdkDragContext    *context,
 130                                     GtkSelectionData  *selection_data,
 131                                     guint             info,
 132                                     guint32           time);
 133 static guchar *read_xds_property   (GdkDragContext    *context,
 134                                     gboolean          delete);
 135 static void write_xds_property     (GdkDragContext    *context,
 136                                     const guchar      *value);
 137 static void drag_end               (GtkWidget         *widget,
 138                                     GdkDragContext    *context);
 139 static void gtk_savebox_response   (GtkDialog         *savebox,
 140                                     gint              response);
 141 static void discard_clicked        (GtkWidget         *button,
 142                                     GtkWidget         *savebox);
 143 static void do_save                (GtkSavebox        *savebox);
 144 static void gtk_savebox_set_property (GObject         *object,
 145                                       guint           prop_id,
 146                                       const GValue    *value,
 147                                       GParamSpec      *pspec);
 148 static void gtk_savebox_get_property (GObject         *object,
 149                                       guint           prop_id,
 150                                       GValue          *value,
 151                                       GParamSpec      *pspec);
 152
 153 void
 154 marshal_INT__STRING (GClosure     *closure,
 155                      GValue       *return_value,
 156                      guint         n_param_values,
 157                      const GValue *param_values,
 158                      gpointer      invocation_hint,
 159                      gpointer      marshal_data);
 160
 161 GType
 162 gtk_savebox_get_type (void)
 163 {
 164   static GType my_type = 0;
 165
 166   if (!my_type)
 167     {
 168       static const GTypeInfo info =
 169       {
 170         sizeof (GtkSaveboxClass),
 171         NULL,                   /* base_init */
 172         NULL,                   /* base_finalise */
 173         (GClassInitFunc) gtk_savebox_class_init,
 174         NULL,                   /* class_finalise */
 175         NULL,                   /* class_data */
 176         sizeof(GtkSavebox),
 177         0,                      /* n_preallocs */
 178         (GInstanceInitFunc) gtk_savebox_init
 179       };
 180
 181       my_type = g_type_register_static(GTK_TYPE_DIALOG, "GtkSavebox", &info, 0);
 182     }
 183
 184   return my_type;
 185 }
 186
 187 static void
 188 gtk_savebox_class_init (GtkSaveboxClass *class)
 189 {
 190   GObjectClass   *object_class;
 191   GtkDialogClass *dialog = (GtkDialogClass *) class;
 192
 193   XdndDirectSave = gdk_atom_intern ("XdndDirectSave0", FALSE);
 194   text_plain = gdk_atom_intern ("text/plain", FALSE);
 195   xa_string = gdk_atom_intern ("STRING", FALSE);
 196
 197   parent_class = g_type_class_peek_parent (class);
 198
 199   class->saved_to_uri = NULL;
 200   class->save_to_file = NULL;
 201   dialog->response = gtk_savebox_response;
 202
 203   object_class = G_OBJECT_CLASS(class);
 204
 205   savebox_signals[SAVE_TO_FILE] = g_signal_new(
 206                                         "save_to_file",
 207                                         G_TYPE_FROM_CLASS(object_class),
 208                                         G_SIGNAL_RUN_LAST,
 209                                         G_STRUCT_OFFSET(GtkSaveboxClass,
 210                                                         save_to_file),
 211                                         NULL, NULL,
 212                                         marshal_INT__STRING,
 213                                         G_TYPE_INT, 1,
 214                                         G_TYPE_STRING);
 215
 216   savebox_signals[SAVED_TO_URI] = g_signal_new(
 217                                         "saved_to_uri",
 218                                         G_TYPE_FROM_CLASS(object_class),
 219                                         G_SIGNAL_RUN_LAST,
 220                                         G_STRUCT_OFFSET(GtkSaveboxClass,
 221                                                         saved_to_uri),
 222                                         NULL, NULL,
 223                                         g_cclosure_marshal_VOID__STRING,
 224                                         G_TYPE_NONE, 1,
 225                                         G_TYPE_STRING);
 226
 227   object_class->set_property = gtk_savebox_set_property;
 228   object_class->get_property = gtk_savebox_get_property;
 229
 230   g_object_class_install_property(object_class, PROP_HAS_DISCARD,
 231                                   g_param_spec_boolean("has_discard",
 232                                          "Has Discard",
 233                                          "The dialog has a Discard button",
 234                                          TRUE,
 235                                          G_PARAM_READWRITE));
 236 }
 237
 238 static void
 239 gtk_savebox_init (GtkSavebox *savebox)
 240 {
 241   GtkWidget *alignment, *button;
 242   GtkDialog *dialog = (GtkDialog *) savebox;
 243   GtkTargetEntry targets[] = { {"XdndDirectSave0", 0, GTK_TARGET_XDS} };
 244
 245   gtk_dialog_set_has_separator (dialog, FALSE);
 246
 247   savebox->targets = gtk_target_list_new (targets,
 248                                           sizeof (targets) / sizeof (*targets));
 249   savebox->icon = NULL;
 250
 251   gtk_window_set_title (GTK_WINDOW (savebox), _("Save As:"));
 252   gtk_window_set_position (GTK_WINDOW (savebox), GTK_WIN_POS_MOUSE);
 253   gtk_window_set_wmclass (GTK_WINDOW (savebox), "savebox", "Savebox");
 254
 255   alignment = gtk_alignment_new (0.5, 0.5, 0, 0);
 256   gtk_box_pack_start (GTK_BOX (dialog->vbox), alignment, TRUE, TRUE, 0);
 257
 258   savebox->drag_box = gtk_event_box_new ();
 259   gtk_container_set_border_width (GTK_CONTAINER (savebox->drag_box), 4);
 260   gtk_widget_add_events (savebox->drag_box, GDK_BUTTON_PRESS_MASK);
 261   g_signal_connect (savebox->drag_box, "button_press_event",
 262                       G_CALLBACK (button_press_over_icon), savebox);
 263   g_signal_connect (savebox, "drag_end",
 264                       G_CALLBACK (drag_end), savebox);
 265   g_signal_connect (savebox, "drag_data_get",
 266                       G_CALLBACK (drag_data_get), savebox);
 267   gtk_container_add (GTK_CONTAINER (alignment), savebox->drag_box);
 268
 269   savebox->entry = gtk_entry_new ();
 270   g_signal_connect_swapped (savebox->entry, "activate",
 271                              G_CALLBACK (do_save), savebox);
 272   gtk_box_pack_start (GTK_BOX (dialog->vbox), savebox->entry, FALSE, TRUE, 4);
 273
 274   gtk_widget_show_all (dialog->vbox);
 275   gtk_widget_grab_focus (savebox->entry);
 276
 277   savebox->discard_area = gtk_hbutton_box_new();
 278
 279   button = button_new_mixed (GTK_STOCK_DELETE, "_Discard");
 280   gtk_box_pack_start (GTK_BOX (savebox->discard_area), button, FALSE, TRUE, 2);
 281   g_signal_connect (button, "clicked", G_CALLBACK (discard_clicked), savebox);
 282   GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS);
 283   GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 284
 285   gtk_box_pack_end (GTK_BOX (dialog->vbox), savebox->discard_area,
 286                       FALSE, TRUE, 0);
 287   gtk_box_reorder_child (GTK_BOX (dialog->vbox), savebox->discard_area, 0);
 288
 289   savebox->dnd_action = GDK_ACTION_COPY;
 290 }
 291
 292 void
 293 gtk_savebox_set_action (GtkSavebox *savebox, GdkDragAction action)
 294 {
 295   g_return_if_fail (savebox != NULL);
 296   g_return_if_fail (GTK_IS_SAVEBOX (savebox));
 297
 298   savebox->dnd_action = action;
 299 }
 300
 301 GtkWidget*
 302 gtk_savebox_new (const gchar *action)
 303 {
 304   GtkWidget *button;
 305   GtkDialog *dialog;
 306   GList     *list, *next;
 307
 308   dialog = GTK_DIALOG (gtk_widget_new (gtk_savebox_get_type(), NULL));
 309
 310   gtk_dialog_add_button (dialog, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
 311
 312   button = button_new_mixed (GTK_STOCK_SAVE, action);
 313   GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 314   gtk_widget_show (button);
 315   gtk_dialog_add_action_widget (dialog, button, GTK_RESPONSE_OK);
 316
 317   gtk_dialog_set_default_response (dialog, GTK_RESPONSE_OK);
 318
 319   list = gtk_container_get_children (GTK_CONTAINER (dialog->action_area));
 320   for (next = list; next; next = next->next)
 321     GTK_WIDGET_UNSET_FLAGS (GTK_WIDGET(next->data), GTK_CAN_FOCUS);
 322   g_list_free(list);
 323
 324   return GTK_WIDGET(dialog);
 325 }
 326
 327 void
 328 gtk_savebox_set_icon (GtkSavebox *savebox, GdkPixbuf *pixbuf)
 329 {
 330   g_return_if_fail (savebox != NULL);
 331   g_return_if_fail (GTK_IS_SAVEBOX (savebox));
 332   g_return_if_fail (pixbuf != NULL);
 333
 334   if (savebox->icon)
 335     gtk_image_set_from_pixbuf (GTK_IMAGE (savebox->icon), pixbuf);
 336   else
 337     {
 338       savebox->icon = gtk_image_new_from_pixbuf (pixbuf);
 339       gtk_container_add (GTK_CONTAINER (savebox->drag_box), savebox->icon);
 340       gtk_widget_show(savebox->icon);
 341     }
 342 }
 343
 344 void
 345 gtk_savebox_set_pathname (GtkSavebox *savebox, const gchar *pathname)
 346 {
 347   const gchar *slash, *dot;
 348   gint  leaf;
 349
 350   g_return_if_fail (savebox != NULL);
 351   g_return_if_fail (GTK_IS_SAVEBOX (savebox));
 352   g_return_if_fail (pathname != NULL);
 353
 354   gtk_entry_set_text (GTK_ENTRY (savebox->entry), pathname);
 355
 356   slash = strrchr (pathname, '/');
 357
 358   leaf = slash ? g_utf8_pointer_to_offset(pathname, slash) + 1 : 0;
 359   dot = strchr(pathname + leaf, '.');
 360
 361   gtk_editable_select_region (GTK_EDITABLE (savebox->entry), leaf,
 362                               dot ? g_utf8_pointer_to_offset (pathname, dot)
 363                                   : -1);
 364 }
 365
 366 void
 367 gtk_savebox_set_has_discard (GtkSavebox *savebox, gboolean setting)
 368 {
 369   if (setting)
 370     gtk_widget_show_all (savebox->discard_area);
 371   else
 372     gtk_widget_hide (savebox->discard_area);
 373 }
 374
 375 static void
 376 button_press_over_icon (GtkWidget *drag_box, GdkEventButton *event,
 377                         GtkSavebox *savebox)
 378 {
 379   GdkDragContext  *context;
 380   const gchar     *uri = NULL, *leafname;
 381
 382   g_return_if_fail (savebox != NULL);
 383   g_return_if_fail (GTK_IS_SAVEBOX (savebox));
 384   g_return_if_fail (event != NULL);
 385   g_return_if_fail (savebox->icon != NULL);
 386
 387   savebox->using_xds = FALSE;
 388   savebox->data_sent = FALSE;
 389   context = gtk_drag_begin (GTK_WIDGET (savebox),
 390                             savebox->targets, savebox->dnd_action,
 391                             event->button, (GdkEvent *) event);
 392
 393   uri = gtk_entry_get_text (GTK_ENTRY (savebox->entry));
 394   if (uri && *uri)
 395     leafname = g_basename (uri);
 396   else
 397     leafname = _("Unnamed");
 398
 399   write_xds_property (context, leafname);
 400
 401   gtk_drag_set_icon_pixbuf (context,
 402                             gtk_image_get_pixbuf (GTK_IMAGE (savebox->icon)),
 403                             event->x, event->y);
 404
 405 }
 406
 407 static void
 408 drag_data_get (GtkWidget        *widget,
 409                GdkDragContext   *context,
 410                GtkSelectionData *selection_data,
 411                guint            info,
 412                guint32          time)
 413 {
 414   GtkSavebox  *savebox;
 415   guchar      to_send = 'E';
 416   gchar       *uri;
 417   gchar       *pathname;
 418
 419   g_return_if_fail (widget != NULL);
 420   g_return_if_fail (GTK_IS_SAVEBOX (widget));
 421   g_return_if_fail (context != NULL);
 422   g_return_if_fail (selection_data != NULL);
 423
 424   savebox = GTK_SAVEBOX (widget);
 425
 426   /* We're only concerned with the XDS protocol. Responding to other requests
 427    * (including application/octet-stream) is the job of the application.
 428    */
 429   if (info != GTK_TARGET_XDS)
 430   {
 431     /* Assume that the data will be/has been sent */
 432     savebox->data_sent = TRUE;
 433     return;
 434   }
 435
 436   uri = read_xds_property (context, FALSE);
 437
 438   if (uri)
 439   {
 440     gint result = GTK_XDS_NO_HANDLER;
 441     EscapedPath *escaped_uri;
 442
 443     /* Escape and then unescape. A little inefficient. */
 444     escaped_uri = escape_uri_path (uri);
 445     pathname = get_local_path (escaped_uri);
 446 #if 0
 447     g_print("[ asked to save as '%s' (%s escaped) ]\n",
 448                     pathname, (char *) escaped_uri);
 449 #endif
 450     g_free (escaped_uri);
 451
 452     if (!pathname)
 453       to_send = 'F';    /* Not on the local machine */
 454     else
 455       {
 456         g_signal_emit (widget, savebox_signals[SAVE_TO_FILE], 0,
 457                        pathname, &result);
 458         g_free (pathname);
 459
 460         if (result == GTK_XDS_SAVED)
 461           {
 462             savebox->data_sent = TRUE;
 463             to_send = 'S';
 464           }
 465         else if (result != GTK_XDS_SAVE_ERROR)
 466           g_warning ("No handler for saving to a file.\n");
 467
 468         g_free (uri);
 469       }
 470   }
 471   else
 472   {
 473     g_warning (_("Remote application wants to use Direct Save, but I can't "
 474                "read the XdndDirectSave0 (type text/plain) property.\n"));
 475   }
 476
 477   if (to_send != 'E')
 478     savebox->using_xds = TRUE;
 479   gtk_selection_data_set (selection_data, xa_string, 8, &to_send, 1);
 480 }
 481
 482 /* Result is a UTF-8 encoded path. Not escaped. g_free() the result. */
 483 static guchar *
 484 read_xds_property (GdkDragContext *context, gboolean delete)
 485 {
 486   guchar  *prop_text;
 487   guint   length;
 488   guchar  *retval = NULL;
 489
 490   g_return_val_if_fail (context != NULL, NULL);
 491
 492   if (gdk_property_get (context->source_window, XdndDirectSave, text_plain,
 493                        0, XDS_MAXURILEN, delete,
 494                        NULL, NULL, &length, &prop_text)
 495             && prop_text)
 496   {
 497     /* Terminate the string */
 498     retval = g_realloc (prop_text, length + 1);
 499     retval[length] = '\0';
 500   }
 501
 502   /* Should really do a character set conversation here, but assume UTF-8 */
 503
 504   return retval;
 505 }
 506
 507 static void
 508 write_xds_property (GdkDragContext *context, const guchar *value)
 509 {
 510   /* XXX: Should set character set to UTF-8 here. Spec says default is
 511    * ISO-8859-1!
 512    */
 513
 514   if (value)
 515     {
 516       gdk_property_change (context->source_window, XdndDirectSave,
 517                            text_plain, 8, GDK_PROP_MODE_REPLACE,
 518                            value, strlen (value));
 519     }
 520   else
 521     gdk_property_delete (context->source_window, XdndDirectSave);
 522 }
 523
 524 static void drag_end (GtkWidget *widget, GdkDragContext *context)
 525 {
 526   g_return_if_fail (widget != NULL);
 527   g_return_if_fail (GTK_IS_SAVEBOX (widget));
 528   g_return_if_fail (context != NULL);
 529
 530   if (GTK_SAVEBOX (widget)->using_xds)
 531     {
 532       guchar  *uri;
 533       uri = read_xds_property (context, TRUE);
 534
 535       if (uri)
 536         {
 537           gchar  *path;
 538           EscapedPath *escaped_uri;
 539
 540           escaped_uri = escape_uri_path (uri);
 541           path = get_local_path (escaped_uri);
 542           g_free(escaped_uri);
 543
 544           g_signal_emit (widget, savebox_signals[SAVED_TO_URI], 0,
 545                          path ? path : (const gchar *) uri);
 546           if (path)
 547             g_free (path);
 548           g_free(uri);
 549
 550           gtk_widget_destroy (widget);
 551
 552           return;
 553         }
 554     }
 555   else
 556       write_xds_property (context, NULL);
 557
 558   if (GTK_SAVEBOX (widget)->data_sent)
 559     {
 560       g_signal_emit (widget, savebox_signals[SAVED_TO_URI], 0, NULL);
 561       gtk_widget_destroy (widget);
 562     }
 563 }
 564
 565 static void discard_clicked (GtkWidget *button, GtkWidget *savebox)
 566 {
 567   g_signal_emit (savebox, savebox_signals[SAVED_TO_URI], 0, NULL);
 568   gtk_widget_destroy (savebox);
 569 }
 570
 571 /* User has clicked Save or pressed Return... */
 572 static void do_save (GtkSavebox *savebox)
 573 {
 574   gint  result = GTK_XDS_NO_HANDLER;
 575   const gchar  *uri;
 576   gchar        *pathname;
 577
 578   g_return_if_fail (savebox != NULL);
 579   g_return_if_fail (GTK_IS_SAVEBOX (savebox));
 580
 581   uri = gtk_entry_get_text (GTK_ENTRY (savebox->entry));
 582
 583   /* This is a bit inefficient... */ {
 584           EscapedPath *escaped_uri;
 585
 586           escaped_uri = escape_uri_path (uri);
 587           pathname = get_local_path (escaped_uri);
 588           g_free(escaped_uri);
 589   }
 590
 591   if (!pathname)
 592     {
 593       GtkWidget *dialog;
 594
 595       dialog = gtk_message_dialog_new (GTK_WINDOW (savebox),
 596                         GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
 597                         GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
 598                         _("Drag the icon to a directory viewer\n"
 599                                 "(or enter a full pathname)"));
 600
 601       gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER);
 602
 603       gtk_dialog_run (GTK_DIALOG (dialog));
 604       gtk_widget_destroy (dialog);
 605
 606       return;
 607     }
 608
 609   g_signal_emit (savebox, savebox_signals[SAVE_TO_FILE], 0, pathname, &result);
 610
 611   if (result == GTK_XDS_SAVED)
 612     {
 613       g_signal_emit (savebox, savebox_signals[SAVED_TO_URI], 0, pathname);
 614
 615       gtk_widget_destroy (GTK_WIDGET (savebox));
 616     }
 617   else if (result == GTK_XDS_NO_HANDLER)
 618     g_warning ("No handler for saving to a file.\n");
 619
 620   g_free(pathname);
 621 }
 622
 623 static void
 624 gtk_savebox_response (GtkDialog *savebox, gint response)
 625 {
 626         if (response == GTK_RESPONSE_OK)
 627         {
 628                 do_save(GTK_SAVEBOX(savebox));
 629                 return;
 630         }
 631         else if (response == GTK_RESPONSE_CANCEL)
 632                 gtk_widget_destroy (GTK_WIDGET (savebox));
 633 }
 634
 635 static void
 636 gtk_savebox_set_property (GObject      *object,
 637                           guint         prop_id,
 638                           const GValue *value,
 639                           GParamSpec   *pspec)
 640 {
 641   GtkSavebox *savebox;
 642
 643   savebox = GTK_SAVEBOX (object);
 644
 645   switch (prop_id)
 646     {
 647     case PROP_HAS_DISCARD:
 648       gtk_savebox_set_has_discard (GTK_SAVEBOX(object),
 649                                    g_value_get_boolean (value));
 650       break;
 651
 652     default:
 653       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 654       break;
 655     }
 656 }
 657
 658 static void
 659 gtk_savebox_get_property (GObject     *object,
 660                           guint        prop_id,
 661                           GValue      *value,
 662                           GParamSpec  *pspec)
 663 {
 664   GtkSavebox *savebox;
 665
 666   savebox = GTK_SAVEBOX (object);
 667
 668   switch (prop_id)
 669     {
 670     case PROP_HAS_DISCARD:
 671       g_value_set_boolean (value, GTK_WIDGET_VISIBLE(savebox->discard_area));
 672       break;
 673
 674     default:
 675       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 676       break;
 677     }
 678 }
 679
 680 void
 681 marshal_INT__STRING (GClosure     *closure,
 682                      GValue       *return_value,
 683                      guint         n_param_values,
 684                      const GValue *param_values,
 685                      gpointer      invocation_hint,
 686                      gpointer      marshal_data)
 687 {
 688   typedef gint (*GMarshalFunc_INT__STRING) (gpointer     data1,
 689                                             gpointer     arg_1,
 690                                             gpointer     data2);
 691   register GMarshalFunc_INT__STRING callback;
 692   register GCClosure *cc = (GCClosure*) closure;
 693   register gpointer data1, data2;
 694   gint v_return;
 695
 696   g_return_if_fail (return_value != NULL);
 697   g_return_if_fail (n_param_values == 2);
 698
 699   if (G_CCLOSURE_SWAP_DATA (closure))
 700     {
 701       data1 = closure->data;
 702       data2 = g_value_peek_pointer (param_values + 0);
 703     }
 704   else
 705     {
 706       data1 = g_value_peek_pointer (param_values + 0);
 707       data2 = closure->data;
 708     }
 709   callback = (GMarshalFunc_INT__STRING)
 710                 (marshal_data ? marshal_data : cc->callback);
 711
 712   v_return = callback (data1, param_values[1].data[0].v_pointer, data2);
 713
 714   g_value_set_int (return_value, v_return);
 715 }