ROX-Filer/src/gtksavebox.c

   1 /*
   2  * $Id$
   3  *
   4  * SaveBox widget for the ROX desktop project
   5  * Copyright (C) 2003 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  */
  98
  99 enum {
 100   PROP_0,
 101   PROP_HAS_DISCARD
 102 };
 103
 104 enum
 105 {
 106   SAVE_TO_FILE,
 107   SAVED_TO_URI,
 108
 109   LAST_SIGNAL
 110 };
 111
 112 static gpointer parent_class;
 113 static guint savebox_signals[LAST_SIGNAL];
 114
 115 /* Longest possible XdndDirectSave0 property value */
 116 #define XDS_MAXURILEN 4096
 117
 118 static GdkAtom XdndDirectSave;
 119 static GdkAtom text_plain;
 120 static GdkAtom xa_string;
 121
 122 static void gtk_savebox_class_init (GtkSaveboxClass   *klass);
 123 static void gtk_savebox_init       (GtkSavebox        *savebox);
 124 static void button_press_over_icon (GtkWidget         *drag_box,
 125                                     GdkEventButton    *event,
 126                                     GtkSavebox        *savebox);
 127 static void drag_data_get          (GtkWidget         *widget,
 128                                     GdkDragContext    *context,
 129                                     GtkSelectionData  *selection_data,
 130                                     guint             info,
 131                                     guint32           time);
 132 static guchar *read_xds_property   (GdkDragContext    *context,
 133                                     gboolean          delete);
 134 static void write_xds_property     (GdkDragContext    *context,
 135                                     const guchar      *value);
 136 static void drag_end               (GtkWidget         *widget,
 137                                     GdkDragContext    *context);
 138 static void gtk_savebox_response   (GtkDialog         *savebox,
 139                                     gint              response);
 140 static void discard_clicked        (GtkWidget         *button,
 141                                     GtkWidget         *savebox);
 142 static void do_save                (GtkSavebox        *savebox);
 143 static void gtk_savebox_set_property (GObject         *object,
 144                                       guint           prop_id,
 145                                       const GValue    *value,
 146                                       GParamSpec      *pspec);
 147 static void gtk_savebox_get_property (GObject         *object,
 148                                       guint           prop_id,
 149                                       GValue          *value,
 150                                       GParamSpec      *pspec);
 151
 152 void
 153 marshal_INT__STRING (GClosure     *closure,
 154                      GValue       *return_value,
 155                      guint         n_param_values,
 156                      const GValue *param_values,
 157                      gpointer      invocation_hint,
 158                      gpointer      marshal_data);
 159
 160 GType
 161 gtk_savebox_get_type (void)
 162 {
 163   static GType my_type = 0;
 164
 165   if (!my_type)
 166     {
 167       static const GTypeInfo info =
 168       {
 169         sizeof (GtkSaveboxClass),
 170         NULL,                   /* base_init */
 171         NULL,                   /* base_finalise */
 172         (GClassInitFunc) gtk_savebox_class_init,
 173         NULL,                   /* class_finalise */
 174         NULL,                   /* class_data */
 175         sizeof(GtkSavebox),
 176         0,                      /* n_preallocs */
 177         (GInstanceInitFunc) gtk_savebox_init
 178       };
 179
 180       my_type = g_type_register_static(GTK_TYPE_DIALOG, "GtkSavebox", &info, 0);
 181     }
 182
 183   return my_type;
 184 }
 185
 186 static void
 187 gtk_savebox_class_init (GtkSaveboxClass *class)
 188 {
 189   GObjectClass   *object_class;
 190   GtkDialogClass *dialog = (GtkDialogClass *) class;
 191
 192   XdndDirectSave = gdk_atom_intern ("XdndDirectSave0", FALSE);
 193   text_plain = gdk_atom_intern ("text/plain", FALSE);
 194   xa_string = gdk_atom_intern ("STRING", FALSE);
 195
 196   parent_class = g_type_class_peek_parent (class);
 197
 198   class->saved_to_uri = NULL;
 199   class->save_to_file = NULL;
 200   dialog->response = gtk_savebox_response;
 201
 202   object_class = G_OBJECT_CLASS(class);
 203
 204   savebox_signals[SAVE_TO_FILE] = g_signal_new(
 205                                         "save_to_file",
 206                                         G_TYPE_FROM_CLASS(object_class),
 207                                         G_SIGNAL_RUN_LAST,
 208                                         G_STRUCT_OFFSET(GtkSaveboxClass,
 209                                                         save_to_file),
 210                                         NULL, NULL,
 211                                         marshal_INT__STRING,
 212                                         G_TYPE_INT, 1,
 213                                         G_TYPE_STRING);
 214
 215   savebox_signals[SAVED_TO_URI] = g_signal_new(
 216                                         "saved_to_uri",
 217                                         G_TYPE_FROM_CLASS(object_class),
 218                                         G_SIGNAL_RUN_LAST,
 219                                         G_STRUCT_OFFSET(GtkSaveboxClass,
 220                                                         saved_to_uri),
 221                                         NULL, NULL,
 222                                         g_cclosure_marshal_VOID__STRING,
 223                                         G_TYPE_NONE, 1,
 224                                         G_TYPE_STRING);
 225
 226   object_class->set_property = gtk_savebox_set_property;
 227   object_class->get_property = gtk_savebox_get_property;
 228
 229   g_object_class_install_property(object_class, PROP_HAS_DISCARD,
 230                                   g_param_spec_boolean("has_discard",
 231                                          _("Has Discard"),
 232                                          _("The dialog has a Discard button"),
 233                                          TRUE,
 234                                          G_PARAM_READWRITE));
 235 }
 236
 237 static void
 238 gtk_savebox_init (GtkSavebox *savebox)
 239 {
 240   GtkWidget *alignment, *button;
 241   GtkDialog *dialog = (GtkDialog *) savebox;
 242   GtkTargetEntry targets[] = { {"XdndDirectSave0", 0, GTK_TARGET_XDS} };
 243
 244   gtk_dialog_set_has_separator (dialog, FALSE);
 245
 246   savebox->targets = gtk_target_list_new (targets,
 247                                           sizeof (targets) / sizeof (*targets));
 248   savebox->icon = NULL;
 249
 250   gtk_window_set_title (GTK_WINDOW (savebox), _("Save As:"));
 251   gtk_window_set_position (GTK_WINDOW (savebox), GTK_WIN_POS_MOUSE);
 252   gtk_window_set_wmclass (GTK_WINDOW (savebox), "savebox", "Savebox");
 253
 254   alignment = gtk_alignment_new (0.5, 0.5, 0, 0);
 255   gtk_box_pack_start (GTK_BOX (dialog->vbox), alignment, TRUE, TRUE, 0);
 256
 257   savebox->drag_box = gtk_event_box_new ();
 258   gtk_container_set_border_width (GTK_CONTAINER (savebox->drag_box), 4);
 259   gtk_widget_add_events (savebox->drag_box, GDK_BUTTON_PRESS_MASK);
 260   g_signal_connect (savebox->drag_box, "button_press_event",
 261                       G_CALLBACK (button_press_over_icon), savebox);
 262   g_signal_connect (savebox, "drag_end",
 263                       G_CALLBACK (drag_end), savebox);
 264   g_signal_connect (savebox, "drag_data_get",
 265                       G_CALLBACK (drag_data_get), savebox);
 266   gtk_container_add (GTK_CONTAINER (alignment), savebox->drag_box);
 267
 268   savebox->entry = gtk_entry_new ();
 269   g_signal_connect_swapped (savebox->entry, "activate",
 270                              G_CALLBACK (do_save), savebox);
 271   gtk_box_pack_start (GTK_BOX (dialog->vbox), savebox->entry, FALSE, TRUE, 4);
 272
 273   gtk_widget_show_all (dialog->vbox);
 274   gtk_widget_grab_focus (savebox->entry);
 275
 276   savebox->discard_area = gtk_hbutton_box_new();
 277
 278   button = button_new_mixed (GTK_STOCK_DELETE, "_Discard");
 279   gtk_box_pack_start (GTK_BOX (savebox->discard_area), button, FALSE, TRUE, 2);
 280   g_signal_connect (button, "clicked", G_CALLBACK (discard_clicked), savebox);
 281   GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS);
 282   GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 283
 284   gtk_box_pack_end (GTK_BOX (dialog->vbox), savebox->discard_area,
 285                       FALSE, TRUE, 0);
 286   gtk_box_reorder_child (GTK_BOX (dialog->vbox), savebox->discard_area, 0);
 287
 288   savebox->dnd_action = GDK_ACTION_COPY;
 289 }
 290
 291 void
 292 gtk_savebox_set_action (GtkSavebox *savebox, GdkDragAction action)
 293 {
 294   g_return_if_fail (savebox != NULL);
 295   g_return_if_fail (GTK_IS_SAVEBOX (savebox));
 296
 297   savebox->dnd_action = action;
 298 }
 299
 300 GtkWidget*
 301 gtk_savebox_new (const gchar *action)
 302 {
 303   GtkWidget *button;
 304   GtkDialog *dialog;
 305   GList     *list, *next;
 306
 307   dialog = GTK_DIALOG (gtk_widget_new (gtk_savebox_get_type(), NULL));
 308
 309   gtk_dialog_add_button (dialog, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
 310
 311   button = button_new_mixed (GTK_STOCK_SAVE, action);
 312   GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 313   gtk_widget_show (button);
 314   gtk_dialog_add_action_widget (dialog, button, GTK_RESPONSE_OK);
 315
 316   gtk_dialog_set_default_response (dialog, GTK_RESPONSE_OK);
 317
 318   list = gtk_container_get_children (GTK_CONTAINER (dialog->action_area));
 319   for (next = list; next; next = next->next)
 320     GTK_WIDGET_UNSET_FLAGS (GTK_WIDGET(next->data), GTK_CAN_FOCUS);
 321   g_list_free(list);
 322
 323   return GTK_WIDGET(dialog);
 324 }
 325
 326 void
 327 gtk_savebox_set_icon (GtkSavebox *savebox, GdkPixbuf *pixbuf)
 328 {
 329   g_return_if_fail (savebox != NULL);
 330   g_return_if_fail (GTK_IS_SAVEBOX (savebox));
 331   g_return_if_fail (pixbuf != NULL);
 332
 333   if (savebox->icon)
 334     gtk_image_set_from_pixbuf (GTK_IMAGE (savebox->icon), pixbuf);
 335   else
 336     {
 337       savebox->icon = gtk_image_new_from_pixbuf (pixbuf);
 338       gtk_container_add (GTK_CONTAINER (savebox->drag_box), savebox->icon);
 339       gtk_widget_show(savebox->icon);
 340     }
 341 }
 342
 343 void
 344 gtk_savebox_set_pathname (GtkSavebox *savebox, const gchar *pathname)
 345 {
 346   const gchar *slash, *dot;
 347   gint  leaf;
 348
 349   g_return_if_fail (savebox != NULL);
 350   g_return_if_fail (GTK_IS_SAVEBOX (savebox));
 351   g_return_if_fail (pathname != NULL);
 352
 353   gtk_entry_set_text (GTK_ENTRY (savebox->entry), pathname);
 354
 355   slash = strrchr (pathname, '/');
 356
 357   leaf = slash ? g_utf8_pointer_to_offset(pathname, slash) + 1 : 0;
 358   dot = strchr(pathname + leaf, '.');
 359
 360   gtk_editable_select_region (GTK_EDITABLE (savebox->entry), leaf,
 361                               dot ? g_utf8_pointer_to_offset (pathname, dot)
 362                                   : -1);
 363 }
 364
 365 void
 366 gtk_savebox_set_has_discard (GtkSavebox *savebox, gboolean setting)
 367 {
 368   if (setting)
 369     gtk_widget_show_all (savebox->discard_area);
 370   else
 371     gtk_widget_hide (savebox->discard_area);
 372 }
 373
 374 static void
 375 button_press_over_icon (GtkWidget *drag_box, GdkEventButton *event,
 376                         GtkSavebox *savebox)
 377 {
 378   GdkDragContext  *context;
 379   const gchar     *uri = NULL, *leafname;
 380
 381   g_return_if_fail (savebox != NULL);
 382   g_return_if_fail (GTK_IS_SAVEBOX (savebox));
 383   g_return_if_fail (event != NULL);
 384   g_return_if_fail (savebox->icon != NULL);
 385
 386   savebox->using_xds = FALSE;
 387   savebox->data_sent = FALSE;
 388   context = gtk_drag_begin (GTK_WIDGET (savebox),
 389                             savebox->targets, savebox->dnd_action,
 390                             event->button, (GdkEvent *) event);
 391
 392   uri = gtk_entry_get_text (GTK_ENTRY (savebox->entry));
 393   if (uri && *uri)
 394     leafname = g_basename (uri);
 395   else
 396     leafname = _("Unnamed");
 397
 398   write_xds_property (context, leafname);
 399
 400   gtk_drag_set_icon_pixbuf (context,
 401                             gtk_image_get_pixbuf (GTK_IMAGE (savebox->icon)),
 402                             event->x, event->y);
 403
 404 }
 405
 406 static void
 407 drag_data_get (GtkWidget        *widget,
 408                GdkDragContext   *context,
 409                GtkSelectionData *selection_data,
 410                guint            info,
 411                guint32          time)
 412 {
 413   GtkSavebox  *savebox;
 414   guchar      to_send = 'E';
 415   gchar       *uri;
 416   const gchar *pathname;
 417
 418   g_return_if_fail (widget != NULL);
 419   g_return_if_fail (GTK_IS_SAVEBOX (widget));
 420   g_return_if_fail (context != NULL);
 421   g_return_if_fail (selection_data != NULL);
 422
 423   savebox = GTK_SAVEBOX (widget);
 424
 425   /* We're only concerned with the XDS protocol. Responding to other requests
 426    * (including application/octet-stream) is the job of the application.
 427    */
 428   if (info != GTK_TARGET_XDS)
 429   {
 430     /* Assume that the data will be/has been sent */
 431     savebox->data_sent = TRUE;
 432     return;
 433   }
 434
 435   uri = read_xds_property (context, FALSE);
 436
 437   if (uri)
 438   {
 439     gint result = GTK_XDS_NO_HANDLER;
 440
 441     pathname = get_local_path (uri);
 442     if (!pathname)
 443       to_send = 'F';    /* Not on the local machine */
 444     else
 445       {
 446         g_signal_emit (widget, savebox_signals[SAVE_TO_FILE], 0,
 447                        pathname, &result);
 448
 449         if (result == GTK_XDS_SAVED)
 450           {
 451             savebox->data_sent = TRUE;
 452             to_send = 'S';
 453           }
 454         else if (result != GTK_XDS_SAVE_ERROR)
 455           g_warning ("No handler for saving to a file.\n");
 456
 457         g_free (uri);
 458       }
 459   }
 460   else
 461   {
 462     g_warning (_("Remote application wants to use Direct Save, but I can't "
 463                "read the XdndDirectSave0 (type text/plain) property.\n"));
 464   }
 465
 466   if (to_send != 'E')
 467     savebox->using_xds = TRUE;
 468   gtk_selection_data_set (selection_data, xa_string, 8, &to_send, 1);
 469 }
 470
 471 static guchar *
 472 read_xds_property (GdkDragContext *context, gboolean delete)
 473 {
 474   guchar  *prop_text;
 475   guint   length;
 476   guchar  *retval = NULL;
 477
 478   g_return_val_if_fail (context != NULL, NULL);
 479
 480   if (gdk_property_get (context->source_window, XdndDirectSave, text_plain,
 481                        0, XDS_MAXURILEN, delete,
 482                        NULL, NULL, &length, &prop_text)
 483             && prop_text)
 484   {
 485     /* Terminate the string */
 486     retval = g_realloc (prop_text, length + 1);
 487     retval[length] = '\0';
 488   }
 489
 490   return retval;
 491 }
 492
 493 static void
 494 write_xds_property (GdkDragContext *context, const guchar *value)
 495 {
 496   if (value)
 497     {
 498       gdk_property_change (context->source_window, XdndDirectSave,
 499                            text_plain, 8, GDK_PROP_MODE_REPLACE,
 500                            value, strlen (value));
 501     }
 502   else
 503     gdk_property_delete (context->source_window, XdndDirectSave);
 504 }
 505
 506 static void drag_end (GtkWidget *widget, GdkDragContext *context)
 507 {
 508   g_return_if_fail (widget != NULL);
 509   g_return_if_fail (GTK_IS_SAVEBOX (widget));
 510   g_return_if_fail (context != NULL);
 511
 512   if (GTK_SAVEBOX (widget)->using_xds)
 513     {
 514       guchar  *uri;
 515       uri = read_xds_property (context, TRUE);
 516
 517       if (uri)
 518         {
 519           const gchar  *path;
 520
 521           path = get_local_path (uri);
 522
 523           g_signal_emit (widget, savebox_signals[SAVED_TO_URI], 0,
 524                          path ? path : (const gchar *) uri);
 525           g_free(uri);
 526
 527           gtk_widget_destroy (widget);
 528
 529           return;
 530         }
 531     }
 532   else
 533       write_xds_property (context, NULL);
 534
 535   if (GTK_SAVEBOX (widget)->data_sent)
 536     {
 537       g_signal_emit (widget, savebox_signals[SAVED_TO_URI], 0, NULL);
 538       gtk_widget_destroy (widget);
 539     }
 540 }
 541
 542 static void discard_clicked (GtkWidget *button, GtkWidget *savebox)
 543 {
 544   g_signal_emit (savebox, savebox_signals[SAVED_TO_URI], 0, NULL);
 545   gtk_widget_destroy (savebox);
 546 }
 547
 548 /* User has clicked Save or pressed Return... */
 549 static void do_save (GtkSavebox *savebox)
 550 {
 551   gint  result = GTK_XDS_NO_HANDLER;
 552   const gchar  *pathname, *uri;
 553
 554   g_return_if_fail (savebox != NULL);
 555   g_return_if_fail (GTK_IS_SAVEBOX (savebox));
 556
 557   uri = gtk_entry_get_text (GTK_ENTRY (savebox->entry));
 558   pathname = get_local_path (uri);
 559
 560   if (!pathname)
 561     {
 562       GtkWidget *dialog;
 563
 564       dialog = gtk_message_dialog_new (GTK_WINDOW (savebox),
 565                         GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
 566                         GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
 567                         _("Drag the icon to a directory viewer\n"
 568                                 "(or enter a full pathname)"));
 569
 570       gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER);
 571
 572       gtk_dialog_run (GTK_DIALOG (dialog));
 573       gtk_widget_destroy (dialog);
 574
 575       return;
 576     }
 577
 578   g_signal_emit (savebox, savebox_signals[SAVE_TO_FILE], 0, pathname, &result);
 579
 580   if (result == GTK_XDS_SAVED)
 581     {
 582       g_signal_emit (savebox, savebox_signals[SAVED_TO_URI], 0, pathname);
 583
 584       gtk_widget_destroy (GTK_WIDGET (savebox));
 585     }
 586   else if (result == GTK_XDS_NO_HANDLER)
 587     g_warning ("No handler for saving to a file.\n");
 588 }
 589
 590 static void
 591 gtk_savebox_response (GtkDialog *savebox, gint response)
 592 {
 593         if (response == GTK_RESPONSE_OK)
 594         {
 595                 do_save(GTK_SAVEBOX(savebox));
 596                 return;
 597         }
 598         else if (response == GTK_RESPONSE_CANCEL)
 599                 gtk_widget_destroy (GTK_WIDGET (savebox));
 600 }
 601
 602 static void
 603 gtk_savebox_set_property (GObject      *object,
 604                           guint         prop_id,
 605                           const GValue *value,
 606                           GParamSpec   *pspec)
 607 {
 608   GtkSavebox *savebox;
 609
 610   savebox = GTK_SAVEBOX (object);
 611
 612   switch (prop_id)
 613     {
 614     case PROP_HAS_DISCARD:
 615       gtk_savebox_set_has_discard (GTK_SAVEBOX(object),
 616                                    g_value_get_boolean (value));
 617       break;
 618
 619     default:
 620       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 621       break;
 622     }
 623 }
 624
 625 static void
 626 gtk_savebox_get_property (GObject     *object,
 627                           guint        prop_id,
 628                           GValue      *value,
 629                           GParamSpec  *pspec)
 630 {
 631   GtkSavebox *savebox;
 632
 633   savebox = GTK_SAVEBOX (object);
 634
 635   switch (prop_id)
 636     {
 637     case PROP_HAS_DISCARD:
 638       g_value_set_boolean (value, GTK_WIDGET_VISIBLE(savebox->discard_area));
 639       break;
 640
 641     default:
 642       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 643       break;
 644     }
 645 }
 646
 647 void
 648 marshal_INT__STRING (GClosure     *closure,
 649                      GValue       *return_value,
 650                      guint         n_param_values,
 651                      const GValue *param_values,
 652                      gpointer      invocation_hint,
 653                      gpointer      marshal_data)
 654 {
 655   typedef gint (*GMarshalFunc_INT__STRING) (gpointer     data1,
 656                                             gpointer     arg_1,
 657                                             gpointer     data2);
 658   register GMarshalFunc_INT__STRING callback;
 659   register GCClosure *cc = (GCClosure*) closure;
 660   register gpointer data1, data2;
 661   gint v_return;
 662
 663   g_return_if_fail (return_value != NULL);
 664   g_return_if_fail (n_param_values == 2);
 665
 666   if (G_CCLOSURE_SWAP_DATA (closure))
 667     {
 668       data1 = closure->data;
 669       data2 = g_value_peek_pointer (param_values + 0);
 670     }
 671   else
 672     {
 673       data1 = g_value_peek_pointer (param_values + 0);
 674       data2 = closure->data;
 675     }
 676   callback = (GMarshalFunc_INT__STRING)
 677                 (marshal_data ? marshal_data : cc->callback);
 678
 679   v_return = callback (data1, param_values[1].data[0].v_pointer, data2);
 680
 681   g_value_set_int (return_value, v_return);
 682 }