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_file_chooser_dialog_get_widget() and call its methods if
  37  * the gneeric #GtkAppChooser interface is not sufficient for your needs.
  38  */
  39 #include "config.h"
  40
  41 #include "gtkappchooserdialog.h"
  42
  43 #include "gtkintl.h"
  44 #include "gtkappchooser.h"
  45 #include "gtkappchooseronline.h"
  46 #include "gtkappchooserprivate.h"
  47 #include "gtkappchooserprivate.h"
  48
  49 #include "gtkmessagedialog.h"
  50 #include "gtklabel.h"
  51 #include "gtkbbox.h"
  52 #include "gtkbutton.h"
  53 #include "gtkmenuitem.h"
  54 #include "gtkstock.h"
  55
  56 #include <string.h>
  57 #include <glib/gi18n-lib.h>
  58 #include <gio/gio.h>
  59
  60 #define sure_string(s) ((const char *) ((s) != NULL ? (s) : ""))
  61
  62 struct _GtkAppChooserDialogPrivate {
  63   char *content_type;
  64   GFile *gfile;
  65
  66   GtkWidget *label;
  67   GtkWidget *button;
  68   GtkWidget *online_button;
  69
  70   GtkWidget *open_label;
  71
  72   GtkWidget *app_chooser_widget;
  73   GtkWidget *show_more_button;
  74
  75   GtkAppChooserOnline *online;
  76
  77   gboolean show_more_clicked;
  78 };
  79
  80 enum {
  81   PROP_GFILE = 1,
  82   PROP_CONTENT_TYPE,
  83   N_PROPERTIES
  84 };
  85
  86 static void gtk_app_chooser_dialog_iface_init (GtkAppChooserIface *iface);
  87 G_DEFINE_TYPE_WITH_CODE (GtkAppChooserDialog, gtk_app_chooser_dialog, GTK_TYPE_DIALOG,
  88                          G_IMPLEMENT_INTERFACE (GTK_TYPE_APP_CHOOSER,
  89                                                 gtk_app_chooser_dialog_iface_init));
  90
  91 static void
  92 show_error_dialog (const gchar *primary,
  93                    const gchar *secondary,
  94                    GtkWindow   *parent)
  95 {
  96   GtkWidget *message_dialog;
  97
  98   message_dialog = gtk_message_dialog_new (parent, 0,
  99                                            GTK_MESSAGE_ERROR,
 100                                            GTK_BUTTONS_OK,
 101                                            NULL);
 102   g_object_set (message_dialog,
 103                 "text", primary,
 104                 "secondary-text", secondary,
 105                 NULL);
 106   gtk_dialog_set_default_response (GTK_DIALOG (message_dialog), GTK_RESPONSE_OK);
 107
 108   gtk_widget_show (message_dialog);
 109
 110   g_signal_connect (message_dialog, "response",
 111                     G_CALLBACK (gtk_widget_destroy), NULL);
 112 }
 113
 114 static void
 115 search_for_mimetype_ready_cb (GObject      *source,
 116                               GAsyncResult *res,
 117                               gpointer      user_data)
 118 {
 119   GtkAppChooserOnline *online = GTK_APP_CHOOSER_ONLINE (source);
 120   GtkAppChooserDialog *self = user_data;
 121   GError *error = NULL;
 122
 123   _gtk_app_chooser_online_search_for_mimetype_finish (online, res, &error);
 124
 125   if (error != NULL)
 126     {
 127       show_error_dialog (_("Failed to look for applications online"),
 128                          error->message, GTK_WINDOW (self));
 129       g_error_free (error);
 130     }
 131   else
 132     {
 133       gtk_app_chooser_refresh (GTK_APP_CHOOSER (self->priv->app_chooser_widget));
 134     }
 135 }
 136
 137 static void
 138 online_button_clicked_cb (GtkButton *b,
 139                           gpointer   user_data)
 140 {
 141   GtkAppChooserDialog *self = user_data;
 142
 143   _gtk_app_chooser_online_search_for_mimetype_async (self->priv->online,
 144                                                      self->priv->content_type,
 145                                                      GTK_WINDOW (self),
 146                                                      search_for_mimetype_ready_cb,
 147                                                      self);
 148 }
 149
 150 static void
 151 app_chooser_online_get_default_ready_cb (GObject *source,
 152                                          GAsyncResult *res,
 153                                          gpointer user_data)
 154 {
 155   GtkAppChooserDialog *self = user_data;
 156
 157   self->priv->online = _gtk_app_chooser_online_get_default_finish (source, res);
 158
 159   if (self->priv->online != NULL)
 160     {
 161       GtkWidget *action_area;
 162
 163       action_area = gtk_dialog_get_action_area (GTK_DIALOG (self));
 164       self->priv->online_button = gtk_button_new_with_label (_("Find applications online"));
 165       gtk_box_pack_start (GTK_BOX (action_area), self->priv->online_button,
 166                           FALSE, FALSE, 0);
 167       gtk_button_box_set_child_secondary (GTK_BUTTON_BOX (action_area), self->priv->online_button,
 168                                           TRUE);
 169       g_signal_connect (self->priv->online_button, "clicked",
 170                         G_CALLBACK (online_button_clicked_cb), self);
 171
 172       gtk_widget_show (self->priv->online_button);
 173     }
 174 }
 175
 176 static void
 177 ensure_online_button (GtkAppChooserDialog *self)
 178 {
 179   _gtk_app_chooser_online_get_default_async (app_chooser_online_get_default_ready_cb, self);
 180 }
 181
 182 /* An application is valid if:
 183  *
 184  * 1) The file exists
 185  * 2) The user has permissions to run the file
 186  */
 187 static gboolean
 188 check_application (GtkAppChooserDialog  *self,
 189                    GAppInfo            **app_out)
 190 {
 191   const char *command;
 192   char *path = NULL;
 193   char **argv = NULL;
 194   int argc;
 195   GError *error = NULL;
 196   gint retval = TRUE;
 197   GAppInfo *info;
 198
 199   command = NULL;
 200
 201   info = gtk_app_chooser_get_app_info (GTK_APP_CHOOSER (self->priv->app_chooser_widget));
 202   command = g_app_info_get_executable (info);
 203
 204   g_shell_parse_argv (command, &argc, &argv, &error);
 205
 206   if (error)
 207     {
 208       show_error_dialog (_("Could not run application"),
 209                          error->message,
 210                          GTK_WINDOW (self));
 211       g_error_free (error);
 212       retval = FALSE;
 213       goto cleanup;
 214     }
 215
 216   path = g_find_program_in_path (argv[0]);
 217   if (!path)
 218     {
 219       char *error_message;
 220
 221       error_message = g_strdup_printf (_("Could not find '%s'"),
 222                                        argv[0]);
 223
 224       show_error_dialog (_("Could not find application"),
 225                          error_message,
 226                          GTK_WINDOW (self));
 227       g_free (error_message);
 228       retval = FALSE;
 229       goto cleanup;
 230     }
 231
 232   *app_out = info;
 233
 234  cleanup:
 235   g_strfreev (argv);
 236   g_free (path);
 237
 238   return retval;
 239 }
 240
 241 static void
 242 add_or_find_application (GtkAppChooserDialog *self)
 243 {
 244   GAppInfo *app;
 245
 246   app = gtk_app_chooser_get_app_info (GTK_APP_CHOOSER (self));
 247
 248   /* we don't care about reporting errors here */
 249   g_app_info_set_as_last_used_for_type (app,
 250                                         self->priv->content_type,
 251                                         NULL);
 252
 253   g_object_unref (app);
 254 }
 255
 256 static void
 257 gtk_app_chooser_dialog_response (GtkDialog *dialog,
 258                                  gint       response_id,
 259                                  gpointer   user_data)
 260 {
 261   GtkAppChooserDialog *self = GTK_APP_CHOOSER_DIALOG (dialog);
 262
 263   switch (response_id)
 264     {
 265     case GTK_RESPONSE_OK:
 266       add_or_find_application (self);
 267       break;
 268     default :
 269       break;
 270     }
 271 }
 272
 273 static void
 274 widget_application_selected_cb (GtkAppChooserWidget *widget,
 275                                 GAppInfo            *app_info,
 276                                 gpointer             user_data)
 277 {
 278   GtkAppChooserDialog *self = user_data;
 279
 280   gtk_widget_set_sensitive (self->priv->button, TRUE);
 281 }
 282
 283 static void
 284 widget_application_activated_cb (GtkAppChooserWidget *widget,
 285                                  GAppInfo            *app_info,
 286                                  gpointer             user_data)
 287 {
 288   GtkAppChooserDialog *self = user_data;
 289
 290   gtk_dialog_response (GTK_DIALOG (self), GTK_RESPONSE_OK);
 291 }
 292
 293 static char *
 294 get_extension (const char *basename)
 295 {
 296   char *p;
 297
 298   p = strrchr (basename, '.');
 299
 300   if (p && *(p + 1) != '\0')
 301     return g_strdup (p + 1);
 302
 303   return NULL;
 304 }
 305
 306 static void
 307 set_dialog_properties (GtkAppChooserDialog *self)
 308 {
 309   gchar *label;
 310   gchar *name;
 311   gchar *extension;
 312   gchar *description;
 313   gchar *default_text;
 314   gchar *string;
 315   PangoFontDescription *font_desc;
 316
 317   name = NULL;
 318   extension = NULL;
 319   label = NULL;
 320   description = NULL;
 321
 322   if (self->priv->gfile != NULL)
 323     {
 324       name = g_file_get_basename (self->priv->gfile);
 325       extension = get_extension (name);
 326     }
 327
 328   description = g_content_type_get_description (self->priv->content_type);
 329   gtk_window_set_title (GTK_WINDOW (self), "");
 330
 331   if (name != NULL)
 332     {
 333       /* Translators: %s is a filename */
 334       label = g_strdup_printf (_("Select an application to open \"%s\""), name);
 335       string = g_strdup_printf (_("No applications available to open \"%s\""),
 336                                 name);
 337     }
 338   else
 339     {
 340       /* Translators: %s is a file type description */
 341       label = g_strdup_printf (_("Select an application for \"%s\" files"),
 342                                g_content_type_is_unknown (self->priv->content_type) ?
 343                                self->priv->content_type : description);
 344       string = g_strdup_printf (_("No applications available to open \"%s\" files"),
 345                                g_content_type_is_unknown (self->priv->content_type) ?
 346                                self->priv->content_type : description);
 347     }
 348
 349   font_desc = pango_font_description_new ();
 350   pango_font_description_set_weight (font_desc, PANGO_WEIGHT_BOLD);
 351   gtk_widget_modify_font (self->priv->label, font_desc);
 352   pango_font_description_free (font_desc);
 353
 354   gtk_label_set_markup (GTK_LABEL (self->priv->label), label);
 355
 356   default_text = g_strdup_printf ("<big><b>%s</b></big>\n%s",
 357                                   string,
 358                                   _("Click \"Show other applications\", for more options, or "
 359                                     "\"Find applications online\" to install a new application"));
 360
 361   gtk_app_chooser_widget_set_default_text (GTK_APP_CHOOSER_WIDGET (self->priv->app_chooser_widget),
 362                                            default_text);
 363
 364   g_free (label);
 365   g_free (name);
 366   g_free (extension);
 367   g_free (description);
 368   g_free (string);
 369   g_free (default_text);
 370 }
 371
 372 static void
 373 show_more_button_clicked_cb (GtkButton *button,
 374                              gpointer   user_data)
 375 {
 376   GtkAppChooserDialog *self = user_data;
 377
 378   g_object_set (self->priv->app_chooser_widget,
 379                 "show-recommended", TRUE,
 380                 "show-fallback", TRUE,
 381                 "show-other", TRUE,
 382                 NULL);
 383
 384   gtk_widget_hide (self->priv->show_more_button);
 385   self->priv->show_more_clicked = TRUE;
 386 }
 387
 388 static void
 389 widget_notify_for_button_cb (GObject    *source,
 390                              GParamSpec *pspec,
 391                              gpointer    user_data)
 392 {
 393   GtkAppChooserDialog *self = user_data;
 394   GtkAppChooserWidget *widget = GTK_APP_CHOOSER_WIDGET (source);
 395   gboolean should_hide;
 396
 397   should_hide = gtk_app_chooser_widget_get_show_all (widget) ||
 398     self->priv->show_more_clicked;
 399
 400   if (should_hide)
 401     gtk_widget_hide (self->priv->show_more_button);
 402 }
 403
 404 static void
 405 forget_menu_item_activate_cb (GtkMenuItem *item,
 406                               gpointer     user_data)
 407 {
 408   GtkAppChooserDialog *self = user_data;
 409   GAppInfo *info;
 410
 411   info = gtk_app_chooser_get_app_info (GTK_APP_CHOOSER (self));
 412
 413   if (info != NULL)
 414     {
 415       g_app_info_remove_supports_type (info, self->priv->content_type, NULL);
 416
 417       gtk_app_chooser_refresh (GTK_APP_CHOOSER (self));
 418
 419       g_object_unref (info);
 420     }
 421 }
 422
 423 static GtkWidget *
 424 build_forget_menu_item (GtkAppChooserDialog *self)
 425 {
 426   GtkWidget *retval;
 427
 428   retval = gtk_menu_item_new_with_label (_("Forget association"));
 429   gtk_widget_show (retval);
 430
 431   g_signal_connect (retval, "activate",
 432                     G_CALLBACK (forget_menu_item_activate_cb), self);
 433
 434   return retval;
 435 }
 436
 437 static void
 438 widget_populate_popup_cb (GtkAppChooserWidget *widget,
 439                           GtkMenu             *menu,
 440                           GAppInfo            *info,
 441                           gpointer             user_data)
 442 {
 443   GtkAppChooserDialog *self = user_data;
 444   GtkWidget *menu_item;
 445
 446   if (g_app_info_can_remove_supports_type (info))
 447     {
 448       menu_item = build_forget_menu_item (self);
 449       gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
 450     }
 451 }
 452
 453 static void
 454 build_dialog_ui (GtkAppChooserDialog *self)
 455 {
 456   GtkWidget *vbox;
 457   GtkWidget *vbox2;
 458   GtkWidget *label;
 459   GtkWidget *button, *w;
 460
 461   gtk_container_set_border_width (GTK_CONTAINER (self), 5);
 462
 463   vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
 464   gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
 465   gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (self))), vbox, TRUE, TRUE, 0);
 466   gtk_widget_show (vbox);
 467
 468   vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
 469   gtk_box_pack_start (GTK_BOX (vbox), vbox2, TRUE, TRUE, 0);
 470   gtk_widget_show (vbox2);
 471
 472   self->priv->label = gtk_label_new ("");
 473   gtk_misc_set_alignment (GTK_MISC (self->priv->label), 0, 0.5);
 474   gtk_label_set_line_wrap (GTK_LABEL (self->priv->label), TRUE);
 475   gtk_box_pack_start (GTK_BOX (vbox2), self->priv->label,
 476                       FALSE, FALSE, 0);
 477   gtk_widget_show (self->priv->label);
 478
 479   self->priv->app_chooser_widget =
 480     gtk_app_chooser_widget_new (self->priv->content_type);
 481   gtk_box_pack_start (GTK_BOX (vbox2), self->priv->app_chooser_widget, TRUE, TRUE, 0);
 482   gtk_widget_show (self->priv->app_chooser_widget);
 483
 484   g_signal_connect (self->priv->app_chooser_widget, "application-selected",
 485                     G_CALLBACK (widget_application_selected_cb), self);
 486   g_signal_connect (self->priv->app_chooser_widget, "application-activated",
 487                     G_CALLBACK (widget_application_activated_cb), self);
 488   g_signal_connect (self->priv->app_chooser_widget, "notify::show-all",
 489                     G_CALLBACK (widget_notify_for_button_cb), self);
 490   g_signal_connect (self->priv->app_chooser_widget, "populate-popup",
 491                     G_CALLBACK (widget_populate_popup_cb), self);
 492
 493   button = gtk_button_new_with_label (_("Show other applications"));
 494   self->priv->show_more_button = button;
 495   w = gtk_image_new_from_stock (GTK_STOCK_ADD,
 496                                 GTK_ICON_SIZE_BUTTON);
 497   gtk_button_set_image (GTK_BUTTON (button), w);
 498   gtk_box_pack_start (GTK_BOX (self->priv->app_chooser_widget), button, FALSE, FALSE, 6);
 499   gtk_widget_show_all (button);
 500
 501   g_signal_connect (button, "clicked",
 502                     G_CALLBACK (show_more_button_clicked_cb), self);
 503
 504   gtk_dialog_add_button (GTK_DIALOG (self),
 505                          GTK_STOCK_CANCEL,
 506                          GTK_RESPONSE_CANCEL);
 507
 508   /* Create a custom stock icon */
 509   self->priv->button = gtk_button_new ();
 510
 511   label = gtk_label_new_with_mnemonic (_("_Open"));
 512   gtk_label_set_mnemonic_widget (GTK_LABEL (label), GTK_WIDGET (self->priv->button));
 513   gtk_widget_set_halign (label, GTK_ALIGN_CENTER);
 514   gtk_widget_show (label);
 515   self->priv->open_label = label;
 516
 517   gtk_container_add (GTK_CONTAINER (self->priv->button),
 518                      self->priv->open_label);
 519
 520   gtk_widget_show (self->priv->button);
 521   gtk_widget_set_can_default (self->priv->button, TRUE);
 522
 523   gtk_dialog_add_action_widget (GTK_DIALOG (self),
 524                                 self->priv->button, GTK_RESPONSE_OK);
 525
 526   gtk_dialog_set_default_response (GTK_DIALOG (self),
 527                                    GTK_RESPONSE_OK);
 528 }
 529
 530 static void
 531 set_gfile_and_content_type (GtkAppChooserDialog *self,
 532                             GFile *file)
 533 {
 534   GFileInfo *info;
 535
 536   if (file == NULL)
 537     return;
 538
 539   self->priv->gfile = g_object_ref (file);
 540
 541   info = g_file_query_info (self->priv->gfile,
 542                             G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,
 543                             0, NULL, NULL);
 544   self->priv->content_type = g_strdup (g_file_info_get_content_type (info));
 545
 546   g_object_unref (info);
 547 }
 548
 549 static GAppInfo *
 550 gtk_app_chooser_dialog_get_app_info (GtkAppChooser *object)
 551 {
 552   GtkAppChooserDialog *self = GTK_APP_CHOOSER_DIALOG (object);
 553   GAppInfo *app = NULL;
 554
 555   if (!check_application (self, &app))
 556     return NULL;
 557
 558   return app;
 559 }
 560
 561 static void
 562 gtk_app_chooser_dialog_refresh (GtkAppChooser *object)
 563 {
 564   GtkAppChooserDialog *self = GTK_APP_CHOOSER_DIALOG (object);
 565
 566   gtk_app_chooser_refresh (GTK_APP_CHOOSER (self->priv->app_chooser_widget));
 567 }
 568
 569 static void
 570 gtk_app_chooser_dialog_constructed (GObject *object)
 571 {
 572   GtkAppChooserDialog *self = GTK_APP_CHOOSER_DIALOG (object);
 573
 574   g_assert (self->priv->content_type != NULL ||
 575             self->priv->gfile != NULL);
 576
 577   if (G_OBJECT_CLASS (gtk_app_chooser_dialog_parent_class)->constructed != NULL)
 578     G_OBJECT_CLASS (gtk_app_chooser_dialog_parent_class)->constructed (object);
 579
 580   build_dialog_ui (self);
 581   set_dialog_properties (self);
 582   ensure_online_button (self);
 583 }
 584
 585 static void
 586 gtk_app_chooser_dialog_dispose (GObject *object)
 587 {
 588   GtkAppChooserDialog *self = GTK_APP_CHOOSER_DIALOG (object);
 589
 590   g_clear_object (&self->priv->gfile);
 591   g_clear_object (&self->priv->online);
 592
 593   G_OBJECT_CLASS (gtk_app_chooser_dialog_parent_class)->dispose (object);
 594 }
 595
 596 static void
 597 gtk_app_chooser_dialog_finalize (GObject *object)
 598 {
 599   GtkAppChooserDialog *self = GTK_APP_CHOOSER_DIALOG (object);
 600
 601   g_free (self->priv->content_type);
 602
 603   G_OBJECT_CLASS (gtk_app_chooser_dialog_parent_class)->finalize (object);
 604 }
 605
 606 static void
 607 gtk_app_chooser_dialog_set_property (GObject      *object,
 608                                      guint         property_id,
 609                                      const GValue *value,
 610                                      GParamSpec   *pspec)
 611 {
 612   GtkAppChooserDialog *self = GTK_APP_CHOOSER_DIALOG (object);
 613
 614   switch (property_id)
 615     {
 616     case PROP_GFILE:
 617       set_gfile_and_content_type (self, g_value_get_object (value));
 618       break;
 619     case PROP_CONTENT_TYPE:
 620       /* don't try to override a value previously set with the GFile */
 621       if (self->priv->content_type == NULL)
 622         self->priv->content_type = g_value_dup_string (value);
 623       break;
 624     default:
 625       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 626       break;
 627     }
 628 }
 629
 630 static void
 631 gtk_app_chooser_dialog_get_property (GObject    *object,
 632                                      guint       property_id,
 633                                      GValue     *value,
 634                                      GParamSpec *pspec)
 635 {
 636   GtkAppChooserDialog *self = GTK_APP_CHOOSER_DIALOG (object);
 637
 638   switch (property_id)
 639     {
 640     case PROP_GFILE:
 641       if (self->priv->gfile != NULL)
 642         g_value_set_object (value, self->priv->gfile);
 643       break;
 644     case PROP_CONTENT_TYPE:
 645       g_value_set_string (value, self->priv->content_type);
 646       break;
 647     default:
 648       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 649       break;
 650     }
 651 }
 652
 653 static void
 654 gtk_app_chooser_dialog_iface_init (GtkAppChooserIface *iface)
 655 {
 656   iface->get_app_info = gtk_app_chooser_dialog_get_app_info;
 657   iface->refresh = gtk_app_chooser_dialog_refresh;
 658 }
 659
 660 static void
 661 gtk_app_chooser_dialog_class_init (GtkAppChooserDialogClass *klass)
 662 {
 663   GObjectClass *gobject_class;
 664   GParamSpec *pspec;
 665
 666   gobject_class = G_OBJECT_CLASS (klass);
 667   gobject_class->dispose = gtk_app_chooser_dialog_dispose;
 668   gobject_class->finalize = gtk_app_chooser_dialog_finalize;
 669   gobject_class->set_property = gtk_app_chooser_dialog_set_property;
 670   gobject_class->get_property = gtk_app_chooser_dialog_get_property;
 671   gobject_class->constructed = gtk_app_chooser_dialog_constructed;
 672
 673   g_object_class_override_property (gobject_class, PROP_CONTENT_TYPE, "content-type");
 674
 675   /**
 676    * GtkAppChooserDialog:gfile:
 677    *
 678    * The GFile used by the #GtkAppChooserDialog.
 679    * The dialog's #GtkAppChooserWidget content type will be guessed from the
 680    * file, if present.
 681    */
 682   pspec = g_param_spec_object ("gfile",
 683                                P_("GFile"),
 684                                P_("The GFile used by the app chooser dialog"),
 685                                G_TYPE_FILE,
 686                                G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE |
 687                                G_PARAM_STATIC_STRINGS);
 688   g_object_class_install_property (gobject_class, PROP_GFILE, pspec);
 689
 690   g_type_class_add_private (klass, sizeof (GtkAppChooserDialogPrivate));
 691 }
 692
 693 static void
 694 gtk_app_chooser_dialog_init (GtkAppChooserDialog *self)
 695 {
 696   self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GTK_TYPE_APP_CHOOSER_DIALOG,
 697                                             GtkAppChooserDialogPrivate);
 698
 699   /* we can't override the class signal handler here, as it's a RUN_LAST;
 700    * we want our signal handler instead to be executed before any user code.
 701    */
 702   g_signal_connect (self, "response",
 703                     G_CALLBACK (gtk_app_chooser_dialog_response), NULL);
 704 }
 705
 706 static void
 707 set_parent_and_flags (GtkWidget      *dialog,
 708                       GtkWindow      *parent,
 709                       GtkDialogFlags  flags)
 710 {
 711   if (parent != NULL)
 712     gtk_window_set_transient_for (GTK_WINDOW (dialog), parent);
 713
 714   if (flags & GTK_DIALOG_MODAL)
 715     gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
 716
 717   if (flags & GTK_DIALOG_DESTROY_WITH_PARENT)
 718     gtk_window_set_destroy_with_parent (GTK_WINDOW (dialog), TRUE);
 719 }
 720
 721 /**
 722  * gtk_app_chooser_dialog_new:
 723  * @parent: (allow-none): a #GtkWindow, or %NULL
 724  * @flags: flags for this dialog
 725  * @file: a #GFile
 726  *
 727  * Creates a new #GtkAppChooserDialog for the provided #GFile,
 728  * to allow the user to select an application for it.
 729  *
 730  * Returns: a newly created #GtkAppChooserDialog
 731  *
 732  * Since: 3.0
 733  **/
 734 GtkWidget *
 735 gtk_app_chooser_dialog_new (GtkWindow      *parent,
 736                             GtkDialogFlags  flags,
 737                             GFile          *file)
 738 {
 739   GtkWidget *retval;
 740
 741   g_return_val_if_fail (G_IS_FILE (file), NULL);
 742
 743   retval = g_object_new (GTK_TYPE_APP_CHOOSER_DIALOG,
 744                          "gfile", file,
 745                          NULL);
 746
 747   set_parent_and_flags (retval, parent, flags);
 748
 749   return retval;
 750 }
 751
 752 /**
 753  * gtk_app_chooser_dialog_new_for_content_type:
 754  * @parent: (allow-none): a #GtkWindow, or %NULL
 755  * @flags: flags for this dialog
 756  * @content_type: a content type string
 757  *
 758  * Creates a new #GtkAppChooserDialog for the provided content type,
 759  * to allow the user to select an application for it.
 760  *
 761  * Returns: a newly created #GtkAppChooserDialog
 762  *
 763  * Since: 3.0
 764  **/
 765 GtkWidget *
 766 gtk_app_chooser_dialog_new_for_content_type (GtkWindow      *parent,
 767                                              GtkDialogFlags  flags,
 768                                              const gchar    *content_type)
 769 {
 770   GtkWidget *retval;
 771
 772   g_return_val_if_fail (content_type != NULL, NULL);
 773
 774   retval = g_object_new (GTK_TYPE_APP_CHOOSER_DIALOG,
 775                          "content-type", content_type,
 776                          NULL);
 777
 778   set_parent_and_flags (retval, parent, flags);
 779
 780   return retval;
 781 }
 782
 783 /**
 784  * gtk_app_chooser_dialog_get_widget:
 785  * @self: a #GtkAppChooserDialog
 786  *
 787  * Returns the #GtkAppChooserWidget of this dialog.
 788  *
 789  * Returns: (transfer none): the #GtkAppChooserWidget of @self
 790  *
 791  * Since: 3.0
 792  */
 793 GtkWidget *
 794 gtk_app_chooser_dialog_get_widget (GtkAppChooserDialog *self)
 795 {
 796   g_return_val_if_fail (GTK_IS_APP_CHOOSER_DIALOG (self), NULL);
 797
 798   return self->priv->app_chooser_widget;
 799 }