Pileus Git - ~andy/gtk/blob - gtk/gtkappchooserdialog.c

   1 /*
   2  * gtkappchooserdialog.c: an app-chooser dialog
   3  *
   4  * Copyright (C) 2004 Novell, Inc.
   5  * Copyright (C) 2007, 2010 Red Hat, Inc.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public License as
   9  * published by the Free Software Foundation; either version 2 of the
  10  * License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with the Gnome Library; see the file COPYING.LIB.  If not,
  19  * write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  *
  22  * Authors: Dave Camp <dave@novell.com>
  23  *          Alexander Larsson <alexl@redhat.com>
  24  *          Cosimo Cecchi <ccecchi@redhat.com>
  25  */
  26
  27 /**
  28  * SECTION:gtkappchooserdialog
  29  * @Title: GtkAppChooserDialog
  30  * @Short_description: An application chooser dialog
  31  *
  32  * #GtkAppChooserDialog shows a #GtkAppChooserWidget inside a #GtkDialog.
  33  *
  34  * Note that #GtkAppChooserDialog does not have any interesting methods
  35  * of its own. Instead, you should get the embedded #GtkAppChooserWidget
  36  * using gtk_app_chooser_dialog_get_widget() and call its methods if
  37  * the generic #GtkAppChooser interface is not sufficient for your needs.
  38  *
  39  * To set the heading that is shown above the #GtkAppChooserWidget,
  40  * use gtk_app_chooser_dialog_set_heading().
  41  */
  42 #include "config.h"
  43
  44 #include "gtkappchooserdialog.h"
  45
  46 #include "gtkintl.h"
  47 #include "gtkappchooser.h"
  48 #include "gtkappchooseronline.h"
  49 #include "gtkappchooserprivate.h"
  50 #include "gtkappchooserprivate.h"
  51
  52 #include "gtkmessagedialog.h"
  53 #include "gtklabel.h"
  54 #include "gtkbbox.h"
  55 #include "gtkbutton.h"
  56 #include "gtkmenuitem.h"
  57 #include "gtkstock.h"
  58
  59 #include <string.h>
  60 #include <glib/gi18n-lib.h>
  61 #include <gio/gio.h>
  62
  63 #define sure_string(s) ((const char *) ((s) != NULL ? (s) : ""))
  64
  65 struct _GtkAppChooserDialogPrivate {
  66   char *content_type;
  67   GFile *gfile;
  68   char *heading;
  69
  70   GtkWidget *label;
  71   GtkWidget *button;
  72   GtkWidget *online_button;
  73
  74   GtkWidget *open_label;
  75
  76   GtkWidget *app_chooser_widget;
  77   GtkWidget *show_more_button;
  78
  79   GtkAppChooserOnline *online;
  80   GCancellable *online_cancellable;
  81
  82   gboolean show_more_clicked;
  83   gboolean dismissed;
  84 };
  85
  86 enum {
  87   PROP_GFILE = 1,
  88   PROP_CONTENT_TYPE,
  89   PROP_HEADING
  90 };
  91
  92 static void gtk_app_chooser_dialog_iface_init (GtkAppChooserIface *iface);
  93 G_DEFINE_TYPE_WITH_CODE (GtkAppChooserDialog, gtk_app_chooser_dialog, GTK_TYPE_DIALOG,
  94                          G_IMPLEMENT_INTERFACE (GTK_TYPE_APP_CHOOSER,
  95                                                 gtk_app_chooser_dialog_iface_init));
  96
  97 static void
  98 show_error_dialog (const gchar *primary,
  99                    const gchar *secondary,
 100                    GtkWindow   *parent)
 101 {
 102   GtkWidget *message_dialog;
 103
 104   message_dialog = gtk_message_dialog_new (parent, 0,
 105                                            GTK_MESSAGE_ERROR,
 106                                            GTK_BUTTONS_OK,
 107                                            NULL);
 108   g_object_set (message_dialog,
 109                 "text", primary,
 110                 "secondary-text", secondary,
 111                 NULL);
 112   gtk_dialog_set_default_response (GTK_DIALOG (message_dialog), GTK_RESPONSE_OK);
 113
 114   gtk_widget_show (message_dialog);
 115
 116   g_signal_connect (message_dialog, "response",
 117                     G_CALLBACK (gtk_widget_destroy), NULL);
 118 }
 119
 120 static void
 121 search_for_mimetype_ready_cb (GObject      *source,
 122                               GAsyncResult *res,
 123                               gpointer      user_data)
 124 {
 125   GtkAppChooserOnline *online = GTK_APP_CHOOSER_ONLINE (source);
 126   GtkAppChooserDialog *self = user_data;
 127   GError *error = NULL;
 128
 129   gdk_threads_enter ();
 130
 131   _gtk_app_chooser_online_search_for_mimetype_finish (online, res, &error);
 132
 133   if (self->priv->dismissed)
 134     goto out;
 135
 136   if (error != NULL &&
 137       !g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
 138     {
 139       show_error_dialog (_("Failed to look for applications online"),
 140                          error->message, GTK_WINDOW (self));
 141     }
 142   else
 143     {
 144       gtk_widget_set_sensitive (self->priv->online_button, TRUE);
 145       gtk_app_chooser_refresh (GTK_APP_CHOOSER (self->priv->app_chooser_widget));
 146     }
 147
 148  out:
 149   g_clear_object (&self->priv->online_cancellable);
 150   g_clear_error (&error);
 151   g_object_unref (self);
 152
 153   gdk_threads_leave ();
 154 }
 155
 156 static void
 157 online_button_clicked_cb (GtkButton *b,
 158                           gpointer   user_data)
 159 {
 160   GtkAppChooserDialog *self = user_data;
 161
 162   self->priv->online_cancellable = g_cancellable_new ();
 163   gtk_widget_set_sensitive (self->priv->online_button, FALSE);
 164
 165   _gtk_app_chooser_online_search_for_mimetype_async (self->priv->online,
 166                                                      self->priv->content_type,
 167                                                      GTK_WINDOW (self),
 168                                                      self->priv->online_cancellable,
 169                                                      search_for_mimetype_ready_cb,
 170                                                      g_object_ref (self));
 171 }
 172
 173 static void
 174 app_chooser_online_get_default_ready_cb (GObject *source,
 175                                          GAsyncResult *res,
 176                                          gpointer user_data)
 177 {
 178   GtkAppChooserDialog *self = user_data;
 179
 180   gdk_threads_enter ();
 181
 182   self->priv->online = _gtk_app_chooser_online_get_default_finish (source, res);
 183
 184   if (self->priv->online != NULL &&
 185       !self->priv->dismissed)
 186     {
 187       GtkWidget *action_area;
 188
 189       action_area = gtk_dialog_get_action_area (GTK_DIALOG (self));
 190       self->priv->online_button = gtk_button_new_with_label (_("Find applications online"));
 191       gtk_box_pack_start (GTK_BOX (action_area), self->priv->online_button,
 192                           FALSE, FALSE, 0);
 193       gtk_button_box_set_child_secondary (GTK_BUTTON_BOX (action_area), self->priv->online_button,
 194                                           TRUE);
 195       g_signal_connect (self->priv->online_button, "clicked",
 196                         G_CALLBACK (online_button_clicked_cb), self);
 197
 198
 199       if (!self->priv->content_type)
 200         gtk_widget_set_sensitive (self->priv->online_button, FALSE);
 201
 202       gtk_widget_show (self->priv->online_button);
 203     }
 204
 205   g_object_unref (self);
 206
 207   gdk_threads_leave ();
 208 }
 209
 210 static void
 211 ensure_online_button (GtkAppChooserDialog *self)
 212 {
 213   _gtk_app_chooser_online_get_default_async (app_chooser_online_get_default_ready_cb,
 214                                              g_object_ref (self));
 215 }
 216
 217 /* An application is valid if:
 218  *
 219  * 1) The file exists
 220  * 2) The user has permissions to run the file
 221  */
 222 static gboolean
 223 check_application (GtkAppChooserDialog  *self,
 224                    GAppInfo            **app_out)
 225 {
 226   const char *command;
 227   char *path = NULL;
 228   char **argv = NULL;
 229   int argc;
 230   GError *error = NULL;
 231   gint retval = TRUE;
 232   GAppInfo *info;
 233
 234   command = NULL;
 235
 236   info = gtk_app_chooser_get_app_info (GTK_APP_CHOOSER (self->priv->app_chooser_widget));
 237   if (info == NULL)
 238     {
 239       *app_out = NULL;
 240       return FALSE;
 241     }
 242
 243   command = g_app_info_get_executable (info);
 244
 245   g_shell_parse_argv (command, &argc, &argv, &error);
 246
 247   if (error)
 248     {
 249       show_error_dialog (_("Could not run application"),
 250                          error->message,
 251                          GTK_WINDOW (self));
 252       g_error_free (error);
 253       retval = FALSE;
 254       goto cleanup;
 255     }
 256
 257   path = g_find_program_in_path (argv[0]);
 258   if (!path)
 259     {
 260       char *error_message;
 261
 262       error_message = g_strdup_printf (_("Could not find '%s'"),
 263                                        argv[0]);
 264
 265       show_error_dialog (_("Could not find application"),
 266                          error_message,
 267                          GTK_WINDOW (self));
 268       g_free (error_message);
 269       retval = FALSE;
 270       goto cleanup;
 271     }
 272
 273   *app_out = info;
 274
 275  cleanup:
 276   g_strfreev (argv);
 277   g_free (path);
 278
 279   return retval;
 280 }
 281
 282 static void
 283 add_or_find_application (GtkAppChooserDialog *self)
 284 {
 285   GAppInfo *app;
 286
 287   app = gtk_app_chooser_get_app_info (GTK_APP_CHOOSER (self));
 288
 289   if (app)
 290     {
 291       /* we don't care about reporting errors here */
 292       if (self->priv->content_type)
 293         g_app_info_set_as_last_used_for_type (app,
 294                                               self->priv->content_type,
 295                                               NULL);
 296       g_object_unref (app);
 297     }
 298 }
 299
 300 static void
 301 cancel_and_clear_cancellable (GtkAppChooserDialog *self)
 302 {
 303   if (self->priv->online_cancellable != NULL)
 304     {
 305       g_cancellable_cancel (self->priv->online_cancellable);
 306       g_clear_object (&self->priv->online_cancellable);
 307     }
 308 }
 309
 310 static void
 311 gtk_app_chooser_dialog_response (GtkDialog *dialog,
 312                                  gint       response_id,
 313                                  gpointer   user_data)
 314 {
 315   GtkAppChooserDialog *self = GTK_APP_CHOOSER_DIALOG (dialog);
 316
 317   switch (response_id)
 318     {
 319     case GTK_RESPONSE_OK:
 320       add_or_find_application (self);
 321       break;
 322     case GTK_RESPONSE_CANCEL:
 323     case GTK_RESPONSE_DELETE_EVENT:
 324       cancel_and_clear_cancellable (self);
 325       self->priv->dismissed = TRUE;
 326     default :
 327       break;
 328     }
 329 }
 330
 331 static void
 332 widget_application_selected_cb (GtkAppChooserWidget *widget,
 333                                 GAppInfo            *app_info,
 334                                 gpointer             user_data)
 335 {
 336   GtkAppChooserDialog *self = user_data;
 337
 338   gtk_widget_set_sensitive (self->priv->button, TRUE);
 339 }
 340
 341 static void
 342 widget_application_activated_cb (GtkAppChooserWidget *widget,
 343                                  GAppInfo            *app_info,
 344                                  gpointer             user_data)
 345 {
 346   GtkAppChooserDialog *self = user_data;
 347
 348   gtk_dialog_response (GTK_DIALOG (self), GTK_RESPONSE_OK);
 349 }
 350
 351 static char *
 352 get_extension (const char *basename)
 353 {
 354   char *p;
 355
 356   p = strrchr (basename, '.');
 357
 358   if (p && *(p + 1) != '\0')
 359     return g_strdup (p + 1);
 360
 361   return NULL;
 362 }
 363
 364 static void
 365 set_dialog_properties (GtkAppChooserDialog *self)
 366 {
 367   gchar *label;
 368   gchar *name;
 369   gchar *extension;
 370   gchar *description;
 371   gchar *default_text;
 372   gchar *string;
 373   gboolean unknown;
 374   PangoFontDescription *font_desc;
 375
 376   name = NULL;
 377   extension = NULL;
 378   label = NULL;
 379   description = NULL;
 380   unknown = TRUE;
 381
 382   if (self->priv->gfile != NULL)
 383     {
 384       name = g_file_get_basename (self->priv->gfile);
 385       extension = get_extension (name);
 386     }
 387
 388   if (self->priv->content_type)
 389     {
 390       description = g_content_type_get_description (self->priv->content_type);
 391       unknown = g_content_type_is_unknown (self->priv->content_type);
 392     }
 393
 394   gtk_window_set_title (GTK_WINDOW (self), "");
 395
 396   if (name != NULL)
 397     {
 398       /* Translators: %s is a filename */
 399       label = g_strdup_printf (_("Select an application to open \"%s\""), name);
 400       string = g_strdup_printf (_("No applications available to open \"%s\""),
 401                                 name);
 402     }
 403   else
 404     {
 405       /* Translators: %s is a file type description */
 406       label = g_strdup_printf (_("Select an application for \"%s\" files"),
 407                                unknown ? self->priv->content_type : description);
 408       string = g_strdup_printf (_("No applications available to open \"%s\" files"),
 409                                unknown ? self->priv->content_type : description);
 410     }
 411
 412   font_desc = pango_font_description_new ();
 413   pango_font_description_set_weight (font_desc, PANGO_WEIGHT_BOLD);
 414   gtk_widget_override_font (self->priv->label, font_desc);
 415   pango_font_description_free (font_desc);
 416
 417   if (self->priv->heading != NULL)
 418     gtk_label_set_markup (GTK_LABEL (self->priv->label), self->priv->heading);
 419   else
 420     gtk_label_set_markup (GTK_LABEL (self->priv->label), label);
 421
 422   default_text = g_strdup_printf ("<big><b>%s</b></big>\n%s",
 423                                   string,
 424                                   _("Click \"Show other applications\", for more options, or "
 425                                     "\"Find applications online\" to install a new application"));
 426
 427   gtk_app_chooser_widget_set_default_text (GTK_APP_CHOOSER_WIDGET (self->priv->app_chooser_widget),
 428                                            default_text);
 429
 430   g_free (label);
 431   g_free (name);
 432   g_free (extension);
 433   g_free (description);
 434   g_free (string);
 435   g_free (default_text);
 436 }
 437
 438 static void
 439 show_more_button_clicked_cb (GtkButton *button,
 440                              gpointer   user_data)
 441 {
 442   GtkAppChooserDialog *self = user_data;
 443
 444   g_object_set (self->priv->app_chooser_widget,
 445                 "show-recommended", TRUE,
 446                 "show-fallback", TRUE,
 447                 "show-other", TRUE,
 448                 NULL);
 449
 450   gtk_widget_hide (self->priv->show_more_button);
 451   self->priv->show_more_clicked = TRUE;
 452 }
 453
 454 static void
 455 widget_notify_for_button_cb (GObject    *source,
 456                              GParamSpec *pspec,
 457                              gpointer    user_data)
 458 {
 459   GtkAppChooserDialog *self = user_data;
 460   GtkAppChooserWidget *widget = GTK_APP_CHOOSER_WIDGET (source);
 461   gboolean should_hide;
 462
 463   should_hide = gtk_app_chooser_widget_get_show_other (widget) ||
 464     self->priv->show_more_clicked;
 465
 466   if (should_hide)
 467     gtk_widget_hide (self->priv->show_more_button);
 468 }
 469
 470 static void
 471 forget_menu_item_activate_cb (GtkMenuItem *item,
 472                               gpointer     user_data)
 473 {
 474   GtkAppChooserDialog *self = user_data;
 475   GAppInfo *info;
 476
 477   info = gtk_app_chooser_get_app_info (GTK_APP_CHOOSER (self));
 478
 479   if (info != NULL)
 480     {
 481       g_app_info_remove_supports_type (info, self->priv->content_type, NULL);
 482
 483       gtk_app_chooser_refresh (GTK_APP_CHOOSER (self));
 484
 485       g_object_unref (info);
 486     }
 487 }
 488
 489 static GtkWidget *
 490 build_forget_menu_item (GtkAppChooserDialog *self)
 491 {
 492   GtkWidget *retval;
 493
 494   retval = gtk_menu_item_new_with_label (_("Forget association"));
 495   gtk_widget_show (retval);
 496
 497   g_signal_connect (retval, "activate",
 498                     G_CALLBACK (forget_menu_item_activate_cb), self);
 499
 500   return retval;
 501 }
 502
 503 static void
 504 widget_populate_popup_cb (GtkAppChooserWidget *widget,
 505                           GtkMenu             *menu,
 506                           GAppInfo            *info,
 507                           gpointer             user_data)
 508 {
 509   GtkAppChooserDialog *self = user_data;
 510   GtkWidget *menu_item;
 511
 512   if (g_app_info_can_remove_supports_type (info))
 513     {
 514       menu_item = build_forget_menu_item (self);
 515       gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
 516     }
 517 }
 518
 519 static void
 520 build_dialog_ui (GtkAppChooserDialog *self)
 521 {
 522   GtkWidget *vbox;
 523   GtkWidget *vbox2;
 524   GtkWidget *button, *w;
 525   GAppInfo *info;
 526
 527   gtk_container_set_border_width (GTK_CONTAINER (self), 5);
 528
 529   vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
 530   gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
 531   gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (self))), vbox, TRUE, TRUE, 0);
 532   gtk_widget_show (vbox);
 533
 534   vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
 535   gtk_box_pack_start (GTK_BOX (vbox), vbox2, TRUE, TRUE, 0);
 536   gtk_widget_show (vbox2);
 537
 538   self->priv->label = gtk_label_new ("");
 539   gtk_widget_set_halign (self->priv->label, GTK_ALIGN_START);
 540   gtk_widget_set_valign (self->priv->label, GTK_ALIGN_CENTER);
 541   gtk_label_set_line_wrap (GTK_LABEL (self->priv->label), TRUE);
 542   gtk_box_pack_start (GTK_BOX (vbox2), self->priv->label,
 543                       FALSE, FALSE, 0);
 544   gtk_widget_show (self->priv->label);
 545
 546   self->priv->app_chooser_widget =
 547     gtk_app_chooser_widget_new (self->priv->content_type);
 548   gtk_box_pack_start (GTK_BOX (vbox2), self->priv->app_chooser_widget, TRUE, TRUE, 0);
 549   gtk_widget_show (self->priv->app_chooser_widget);
 550
 551   g_signal_connect (self->priv->app_chooser_widget, "application-selected",
 552                     G_CALLBACK (widget_application_selected_cb), self);
 553   g_signal_connect (self->priv->app_chooser_widget, "application-activated",
 554                     G_CALLBACK (widget_application_activated_cb), self);
 555   g_signal_connect (self->priv->app_chooser_widget, "notify::show-other",
 556                     G_CALLBACK (widget_notify_for_button_cb), self);
 557   g_signal_connect (self->priv->app_chooser_widget, "populate-popup",
 558                     G_CALLBACK (widget_populate_popup_cb), self);
 559
 560   button = gtk_button_new_with_label (_("Show other applications"));
 561   self->priv->show_more_button = button;
 562   w = gtk_image_new_from_stock (GTK_STOCK_ADD,
 563                                 GTK_ICON_SIZE_BUTTON);
 564   gtk_button_set_image (GTK_BUTTON (button), w);
 565   gtk_box_pack_start (GTK_BOX (self->priv->app_chooser_widget), button, FALSE, FALSE, 6);
 566   gtk_widget_show_all (button);
 567
 568   g_signal_connect (button, "clicked",
 569                     G_CALLBACK (show_more_button_clicked_cb), self);
 570
 571   gtk_dialog_add_button (GTK_DIALOG (self),
 572                          GTK_STOCK_CANCEL,
 573                          GTK_RESPONSE_CANCEL);
 574
 575   self->priv->button = gtk_dialog_add_button (GTK_DIALOG (self),
 576                                               _("_Select"),
 577                                               GTK_RESPONSE_OK);
 578
 579   info = gtk_app_chooser_get_app_info (GTK_APP_CHOOSER (self->priv->app_chooser_widget));
 580   gtk_widget_set_sensitive (self->priv->button, info != NULL);
 581   if (info)
 582     g_object_unref (info);
 583
 584   gtk_dialog_set_default_response (GTK_DIALOG (self),
 585                                    GTK_RESPONSE_OK);
 586 }
 587
 588 static void
 589 set_gfile_and_content_type (GtkAppChooserDialog *self,
 590                             GFile *file)
 591 {
 592   GFileInfo *info;
 593
 594   if (file == NULL)
 595     return;
 596
 597   self->priv->gfile = g_object_ref (file);
 598
 599   info = g_file_query_info (self->priv->gfile,
 600                             G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,
 601                             0, NULL, NULL);
 602   self->priv->content_type = g_strdup (g_file_info_get_content_type (info));
 603
 604   g_object_unref (info);
 605 }
 606
 607 static GAppInfo *
 608 gtk_app_chooser_dialog_get_app_info (GtkAppChooser *object)
 609 {
 610   GtkAppChooserDialog *self = GTK_APP_CHOOSER_DIALOG (object);
 611   GAppInfo *app = NULL;
 612
 613   if (!check_application (self, &app))
 614     return NULL;
 615
 616   return app;
 617 }
 618
 619 static void
 620 gtk_app_chooser_dialog_refresh (GtkAppChooser *object)
 621 {
 622   GtkAppChooserDialog *self = GTK_APP_CHOOSER_DIALOG (object);
 623
 624   gtk_app_chooser_refresh (GTK_APP_CHOOSER (self->priv->app_chooser_widget));
 625 }
 626
 627 static void
 628 gtk_app_chooser_dialog_constructed (GObject *object)
 629 {
 630   GtkAppChooserDialog *self = GTK_APP_CHOOSER_DIALOG (object);
 631
 632   if (G_OBJECT_CLASS (gtk_app_chooser_dialog_parent_class)->constructed != NULL)
 633     G_OBJECT_CLASS (gtk_app_chooser_dialog_parent_class)->constructed (object);
 634
 635   build_dialog_ui (self);
 636   set_dialog_properties (self);
 637   ensure_online_button (self);
 638 }
 639
 640 static void
 641 gtk_app_chooser_dialog_dispose (GObject *object)
 642 {
 643   GtkAppChooserDialog *self = GTK_APP_CHOOSER_DIALOG (object);
 644
 645   g_clear_object (&self->priv->gfile);
 646   cancel_and_clear_cancellable (self);
 647   g_clear_object (&self->priv->online);
 648
 649   G_OBJECT_CLASS (gtk_app_chooser_dialog_parent_class)->dispose (object);
 650 }
 651
 652 static void
 653 gtk_app_chooser_dialog_finalize (GObject *object)
 654 {
 655   GtkAppChooserDialog *self = GTK_APP_CHOOSER_DIALOG (object);
 656
 657   g_free (self->priv->content_type);
 658
 659   G_OBJECT_CLASS (gtk_app_chooser_dialog_parent_class)->finalize (object);
 660 }
 661
 662 static void
 663 gtk_app_chooser_dialog_set_property (GObject      *object,
 664                                      guint         property_id,
 665                                      const GValue *value,
 666                                      GParamSpec   *pspec)
 667 {
 668   GtkAppChooserDialog *self = GTK_APP_CHOOSER_DIALOG (object);
 669
 670   switch (property_id)
 671     {
 672     case PROP_GFILE:
 673       set_gfile_and_content_type (self, g_value_get_object (value));
 674       break;
 675     case PROP_CONTENT_TYPE:
 676       /* don't try to override a value previously set with the GFile */
 677       if (self->priv->content_type == NULL)
 678         self->priv->content_type = g_value_dup_string (value);
 679       break;
 680     case PROP_HEADING:
 681       gtk_app_chooser_dialog_set_heading (self, g_value_get_string (value));
 682       break;
 683     default:
 684       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 685       break;
 686     }
 687 }
 688
 689 static void
 690 gtk_app_chooser_dialog_get_property (GObject    *object,
 691                                      guint       property_id,
 692                                      GValue     *value,
 693                                      GParamSpec *pspec)
 694 {
 695   GtkAppChooserDialog *self = GTK_APP_CHOOSER_DIALOG (object);
 696
 697   switch (property_id)
 698     {
 699     case PROP_GFILE:
 700       if (self->priv->gfile != NULL)
 701         g_value_set_object (value, self->priv->gfile);
 702       break;
 703     case PROP_CONTENT_TYPE:
 704       g_value_set_string (value, self->priv->content_type);
 705       break;
 706     case PROP_HEADING:
 707       g_value_set_string (value, self->priv->heading);
 708       break;
 709     default:
 710       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 711       break;
 712     }
 713 }
 714
 715 static void
 716 gtk_app_chooser_dialog_iface_init (GtkAppChooserIface *iface)
 717 {
 718   iface->get_app_info = gtk_app_chooser_dialog_get_app_info;
 719   iface->refresh = gtk_app_chooser_dialog_refresh;
 720 }
 721
 722 static void
 723 gtk_app_chooser_dialog_class_init (GtkAppChooserDialogClass *klass)
 724 {
 725   GObjectClass *gobject_class;
 726   GParamSpec *pspec;
 727
 728   gobject_class = G_OBJECT_CLASS (klass);
 729   gobject_class->dispose = gtk_app_chooser_dialog_dispose;
 730   gobject_class->finalize = gtk_app_chooser_dialog_finalize;
 731   gobject_class->set_property = gtk_app_chooser_dialog_set_property;
 732   gobject_class->get_property = gtk_app_chooser_dialog_get_property;
 733   gobject_class->constructed = gtk_app_chooser_dialog_constructed;
 734
 735   g_object_class_override_property (gobject_class, PROP_CONTENT_TYPE, "content-type");
 736
 737   /**
 738    * GtkAppChooserDialog:gfile:
 739    *
 740    * The GFile used by the #GtkAppChooserDialog.
 741    * The dialog's #GtkAppChooserWidget content type will be guessed from the
 742    * file, if present.
 743    */
 744   pspec = g_param_spec_object ("gfile",
 745                                P_("GFile"),
 746                                P_("The GFile used by the app chooser dialog"),
 747                                G_TYPE_FILE,
 748                                G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE |
 749                                G_PARAM_STATIC_STRINGS);
 750   g_object_class_install_property (gobject_class, PROP_GFILE, pspec);
 751
 752   /**
 753    * GtkAppChooserDialog:heading:
 754    *
 755    * The text to show at the top of the dialog.
 756    * The string may contain Pango markup.
 757    */
 758   pspec = g_param_spec_string ("heading",
 759                                P_("Heading"),
 760                                P_("The text to show at the top of the dialog"),
 761                                NULL,
 762                                G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
 763   g_object_class_install_property (gobject_class, PROP_HEADING, pspec);
 764
 765
 766   g_type_class_add_private (klass, sizeof (GtkAppChooserDialogPrivate));
 767 }
 768
 769 static void
 770 gtk_app_chooser_dialog_init (GtkAppChooserDialog *self)
 771 {
 772   self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GTK_TYPE_APP_CHOOSER_DIALOG,
 773                                             GtkAppChooserDialogPrivate);
 774
 775   /* we can't override the class signal handler here, as it's a RUN_LAST;
 776    * we want our signal handler instead to be executed before any user code.
 777    */
 778   g_signal_connect (self, "response",
 779                     G_CALLBACK (gtk_app_chooser_dialog_response), NULL);
 780 }
 781
 782 static void
 783 set_parent_and_flags (GtkWidget      *dialog,
 784                       GtkWindow      *parent,
 785                       GtkDialogFlags  flags)
 786 {
 787   if (parent != NULL)
 788     gtk_window_set_transient_for (GTK_WINDOW (dialog), parent);
 789
 790   if (flags & GTK_DIALOG_MODAL)
 791     gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
 792
 793   if (flags & GTK_DIALOG_DESTROY_WITH_PARENT)
 794     gtk_window_set_destroy_with_parent (GTK_WINDOW (dialog), TRUE);
 795 }
 796
 797 /**
 798  * gtk_app_chooser_dialog_new:
 799  * @parent: (allow-none): a #GtkWindow, or %NULL
 800  * @flags: flags for this dialog
 801  * @file: a #GFile
 802  *
 803  * Creates a new #GtkAppChooserDialog for the provided #GFile,
 804  * to allow the user to select an application for it.
 805  *
 806  * Returns: a newly created #GtkAppChooserDialog
 807  *
 808  * Since: 3.0
 809  **/
 810 GtkWidget *
 811 gtk_app_chooser_dialog_new (GtkWindow      *parent,
 812                             GtkDialogFlags  flags,
 813                             GFile          *file)
 814 {
 815   GtkWidget *retval;
 816
 817   g_return_val_if_fail (G_IS_FILE (file), NULL);
 818
 819   retval = g_object_new (GTK_TYPE_APP_CHOOSER_DIALOG,
 820                          "gfile", file,
 821                          NULL);
 822
 823   set_parent_and_flags (retval, parent, flags);
 824
 825   return retval;
 826 }
 827
 828 /**
 829  * gtk_app_chooser_dialog_new_for_content_type:
 830  * @parent: (allow-none): a #GtkWindow, or %NULL
 831  * @flags: flags for this dialog
 832  * @content_type: a content type string
 833  *
 834  * Creates a new #GtkAppChooserDialog for the provided content type,
 835  * to allow the user to select an application for it.
 836  *
 837  * Returns: a newly created #GtkAppChooserDialog
 838  *
 839  * Since: 3.0
 840  **/
 841 GtkWidget *
 842 gtk_app_chooser_dialog_new_for_content_type (GtkWindow      *parent,
 843                                              GtkDialogFlags  flags,
 844                                              const gchar    *content_type)
 845 {
 846   GtkWidget *retval;
 847
 848   g_return_val_if_fail (content_type != NULL, NULL);
 849
 850   retval = g_object_new (GTK_TYPE_APP_CHOOSER_DIALOG,
 851                          "content-type", content_type,
 852                          NULL);
 853
 854   set_parent_and_flags (retval, parent, flags);
 855
 856   return retval;
 857 }
 858
 859 /**
 860  * gtk_app_chooser_dialog_get_widget:
 861  * @self: a #GtkAppChooserDialog
 862  *
 863  * Returns the #GtkAppChooserWidget of this dialog.
 864  *
 865  * Returns: (transfer none): the #GtkAppChooserWidget of @self
 866  *
 867  * Since: 3.0
 868  */
 869 GtkWidget *
 870 gtk_app_chooser_dialog_get_widget (GtkAppChooserDialog *self)
 871 {
 872   g_return_val_if_fail (GTK_IS_APP_CHOOSER_DIALOG (self), NULL);
 873
 874   return self->priv->app_chooser_widget;
 875 }
 876
 877 /**
 878  * gtk_app_chooser_dialog_set_heading:
 879  * @self: a #GtkAppChooserDialog
 880  * @heading: a string containing Pango markup
 881  *
 882  * Sets the text to display at the top of the dialog.
 883  * If the heading is not set, the dialog displays a default text.
 884  */
 885 void
 886 gtk_app_chooser_dialog_set_heading (GtkAppChooserDialog *self,
 887                                     const gchar         *heading)
 888 {
 889   g_return_if_fail (GTK_IS_APP_CHOOSER_DIALOG (self));
 890
 891   g_free (self->priv->heading);
 892   self->priv->heading = g_strdup (heading);
 893
 894   if (self->priv->label && self->priv->heading)
 895     gtk_label_set_markup (GTK_LABEL (self->priv->label), self->priv->heading);
 896
 897   g_object_notify (G_OBJECT (self), "heading");
 898 }
 899
 900 /**
 901  * gtk_app_chooser_dialog_get_heading:
 902  * @self: a #GtkAppChooserDialog
 903  *
 904  * Returns the text to display at the top of the dialog.
 905  *
 906  * Returns: the text to display at the top of the dialog, or %NULL, in which
 907  *     case a default text is displayed
 908  */
 909 const gchar *
 910 gtk_app_chooser_dialog_get_heading (GtkAppChooserDialog *self)
 911 {
 912   g_return_val_if_fail (GTK_IS_APP_CHOOSER_DIALOG (self), NULL);
 913
 914   return self->priv->heading;
 915 }