static void app_chooser_online_get_default_ready_cb (GObject *source, GAsyncResult *res, gpointer user_data) { GtkAppChooserDialog *self = user_data; self->priv->online = _gtk_app_chooser_online_get_default_finish (source, res); if (self->priv->online != NULL) { GtkWidget *action_area; action_area = gtk_dialog_get_action_area (GTK_DIALOG (self)); self->priv->online_button = gtk_button_new_with_label (_("Find applications online")); gtk_box_pack_start (GTK_BOX (action_area), self->priv->online_button, FALSE, FALSE, 0); gtk_button_box_set_child_secondary (GTK_BUTTON_BOX (action_area), self->priv->online_button, TRUE); g_signal_connect (self->priv->online_button, "clicked", G_CALLBACK (online_button_clicked_cb), self); if (!self->priv->content_type) gtk_widget_set_sensitive (self->priv->online_button, FALSE); gtk_widget_show (self->priv->online_button); } }
JNIEXPORT void JNICALL Java_org_gnome_gtk_GtkButtonBox_gtk_1button_1box_1set_1child_1secondary ( JNIEnv* env, jclass cls, jlong _self, jlong _child, jboolean _isSecondary ) { GtkButtonBox* self; GtkWidget* child; gboolean isSecondary; // convert parameter self self = (GtkButtonBox*) _self; // convert parameter child child = (GtkWidget*) _child; // convert parameter isSecondary isSecondary = (gboolean) _isSecondary; // call function gtk_button_box_set_child_secondary(self, child, isSecondary); // cleanup parameter self // cleanup parameter child // cleanup parameter isSecondary }
static VALUE rg_set_child_secondary(VALUE self, VALUE child, VALUE is_secondary) { gtk_button_box_set_child_secondary(_SELF(self), RVAL2GTKWIDGET(child), RVAL2CBOOL(is_secondary)); return self; }
static void option_cb (GtkToggleButton *option, GtkWidget *button) { gboolean active = gtk_toggle_button_get_active (option); gtk_button_box_set_child_secondary (GTK_BUTTON_BOX (bbox), button, active); }
void zenity_about (ZenityData *data) { GdkPixbuf *logo; GtkWidget *help_button; char *license_trans; translators = _("translator-credits"); logo = gdk_pixbuf_new_from_file (ZENITY_IMAGE_FULLPATH ("zenity.png"), NULL); license_trans = g_strconcat (_(license[0]), "\n", _(license[1]), "\n", _(license[2]), "\n", NULL); dialog = gtk_about_dialog_new (); g_object_set (G_OBJECT (dialog), "name", "Zenity", "version", VERSION, "copyright", "Copyright \xc2\xa9 2003 Sun Microsystems", "comments", _("Display dialog boxes from shell scripts"), "authors", authors, "documenters", documenters, "translator-credits", translators, "website", "http://live.gnome.org/Zenity", "logo", logo, "wrap-license", TRUE, "license", license_trans, NULL); g_free (license_trans); zenity_util_set_window_icon (dialog, NULL, ZENITY_IMAGE_FULLPATH ("zenity.png")); help_button = gtk_button_new_from_stock (GTK_STOCK_HELP); g_signal_connect (G_OBJECT (help_button), "clicked", G_CALLBACK (zenity_about_display_help), data); gtk_widget_show (help_button); gtk_box_pack_end (GTK_BOX (gtk_dialog_get_action_area (GTK_DIALOG (dialog))), help_button, FALSE, TRUE, 0); gtk_button_box_set_child_secondary (GTK_BUTTON_BOX (gtk_dialog_get_action_area (GTK_DIALOG (dialog))), help_button, TRUE); g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (zenity_about_dialog_response), data); #if 0 g_signal_connect (G_OBJECT (dialog), "key_press_event", G_CALLBACK (zenity_zen_wisdom), NULL); #endif zenity_util_show_dialog (dialog, data->attach); gtk_main (); }
void go_gtk_help_button_init (GtkWidget *w, char const *data_dir, char const *app, char const *link) { CBHelpPaths *paths = g_new (CBHelpPaths, 1); GtkWidget *parent = gtk_widget_get_parent (w); if (GTK_IS_BUTTON_BOX (parent)) gtk_button_box_set_child_secondary ( GTK_BUTTON_BOX (parent), w, TRUE); paths->data_dir = data_dir; paths->app = app; paths->link = link; g_signal_connect_data (G_OBJECT (w), "clicked", G_CALLBACK (cb_help), (gpointer) paths, (GClosureNotify)g_free, G_CONNECT_SWAPPED); }
static void remmina_file_editor_init(RemminaFileEditor* gfe) { RemminaFileEditorPriv* priv; GtkWidget* widget; priv = g_new0(RemminaFileEditorPriv, 1); gfe->priv = priv; /* Create the editor dialog */ gtk_window_set_title(GTK_WINDOW(gfe), _("Remote Desktop Preference")); widget = gtk_dialog_add_button(GTK_DIALOG(gfe), GTK_STOCK_SAVE, GTK_RESPONSE_APPLY); g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(remmina_file_editor_on_save), gfe); gtk_widget_set_sensitive(widget, FALSE); priv->save_button = widget; widget = gtk_dialog_add_button(GTK_DIALOG(gfe), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(remmina_file_editor_on_cancel), gfe); widget = gtk_dialog_add_button(GTK_DIALOG(gfe), GTK_STOCK_CONNECT, GTK_RESPONSE_OK); g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(remmina_file_editor_on_connect), gfe); gtk_dialog_set_alternative_button_order(GTK_DIALOG(gfe), GTK_RESPONSE_OK, GTK_RESPONSE_APPLY, GTK_RESPONSE_CANCEL, -1); gtk_dialog_set_default_response(GTK_DIALOG(gfe), GTK_RESPONSE_OK); gtk_window_set_default_size(GTK_WINDOW(gfe), 450, 500); g_signal_connect(G_OBJECT(gfe), "destroy", G_CALLBACK(remmina_file_editor_destroy), NULL); g_signal_connect(G_OBJECT(gfe), "realize", G_CALLBACK(remmina_file_editor_on_realize), NULL); /* The Set As Default button */ widget = gtk_button_new_with_label(_("Default")); gtk_widget_show(widget); gtk_button_set_image(GTK_BUTTON(widget), gtk_image_new_from_stock(GTK_STOCK_PREFERENCES, GTK_ICON_SIZE_BUTTON)); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_action_area(GTK_DIALOG(gfe))), widget, FALSE, TRUE, 0); gtk_button_box_set_child_secondary(GTK_BUTTON_BOX(gtk_dialog_get_action_area(GTK_DIALOG(gfe))), widget, TRUE); g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(remmina_file_editor_on_default), gfe); priv->setting_widgets = g_hash_table_new(g_str_hash, g_str_equal); remmina_widget_pool_register(GTK_WIDGET(gfe)); }
int clip_GTK_BUTTONBOXSETCHILDSECONDARY(ClipMachine * ClipMachineMemory) { C_widget *cbbox = _fetch_cw_arg(ClipMachineMemory); C_widget *cwid = _fetch_cwidget(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2)); gboolean is_secondary = BOOL_OPTION(ClipMachineMemory, 3, 1); CHECKARG2(1, NUMERIC_type_of_ClipVarType, MAP_type_of_ClipVarType); CHECKCWID(cbbox, GTK_IS_BUTTON_BOX); CHECKARG2(2, NUMERIC_type_of_ClipVarType, MAP_type_of_ClipVarType); CHECKCWID(cwid, GTK_IS_WIDGET); CHECKARG(3, LOGICAL_type_of_ClipVarType); gtk_button_box_set_child_secondary(GTK_BUTTON_BOX(cbbox->widget), GTK_WIDGET(cwid->widget), is_secondary); return 0; err: return 1; }
static GObject * gimp_dialog_constructor (GType type, guint n_params, GObjectConstructParam *params) { GObject *object; GimpHelpFunc help_func; const gchar *help_id; object = G_OBJECT_CLASS (parent_class)->constructor (type, n_params, params); help_func = g_object_get_data (object, "gimp-dialog-help-func"); help_id = g_object_get_data (object, "gimp-dialog-help-id"); if (help_func) gimp_help_connect (GTK_WIDGET (object), help_func, help_id, object); if (show_help_button && help_func && help_id) { GtkDialog *dialog = GTK_DIALOG (object); GtkWidget *button = gtk_button_new_from_stock (GTK_STOCK_HELP); gtk_box_pack_end (GTK_BOX (dialog->action_area), button, FALSE, TRUE, 0); gtk_button_box_set_child_secondary (GTK_BUTTON_BOX (dialog->action_area), button, TRUE); gtk_widget_show (button); g_signal_connect_object (button, "clicked", G_CALLBACK (gimp_dialog_help), dialog, G_CONNECT_SWAPPED); g_object_set_data (object, "gimp-dialog-help-button", button); } return object; }
static void sAddHelpButton (GtkDialog * me, XAP_Dialog * pDlg) { #if defined(EMBEDDED_TARGET) && EMBEDDED_TARGET == EMBEDDED_TARGET_HILDON UT_UNUSED(me); UT_UNUSED(pDlg); #else // prevent help button from being added twice gint has_button = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (me), "has-help-button")); if (has_button) return; if (pDlg && pDlg->getHelpUrl().size () > 0) { #ifdef HAVE_SDI GtkWidget * image = gtk_image_new_from_stock(GTK_STOCK_HELP, GTK_ICON_SIZE_BUTTON); GtkWidget * button = gtk_button_new(); gtk_container_add(GTK_CONTAINER(button), image); GtkWidget * alignment = gtk_alignment_new (0, 0.5, 0, 0); gtk_container_add (GTK_CONTAINER(alignment), button); #else GtkWidget * alignment = gtk_button_new_from_stock (GTK_STOCK_HELP); GtkWidget * button = alignment; #endif gtk_box_pack_start(GTK_BOX(me->action_area), alignment, FALSE, FALSE, 0); gtk_button_box_set_child_secondary (GTK_BUTTON_BOX(me->action_area), alignment, TRUE); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK(help_button_cb), pDlg); gtk_widget_show_all (alignment); g_object_set_data (G_OBJECT (me), "has-help-button", GINT_TO_POINTER (1)); } #endif }
static GtkWidget *my_gtk_about_new( const gchar *name, const gchar *version, const gchar *copyright, const gchar *comments, const gchar **authors, const gchar **documenters, const gchar *translator_credits, GdkPixbuf *logo_pixbuf) { GtkWidget *dialog; GtkWidget *vbox; GtkWidget *button; GtkWidget *logo_image; GtkWidget *name_label; GtkWidget *comments_label; GtkWidget *copyright_label; gchar *title; gchar *str; static Credits *credits = NULL; if (credits == NULL) { credits = g_malloc(sizeof(Credits)); credits->dialog = NULL; credits->authors = g_strdupv((gchar **)authors); credits->documenters = g_strdupv((gchar **)documenters); credits->translator_credits = g_strdup(translator_credits); } dialog = gtk_dialog_new(); # if GTK_CHECK_VERSION(2, 4, 0) gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE); gtk_container_set_border_width(GTK_CONTAINER(dialog), 5); gtk_box_set_spacing(GTK_BOX(GTK_DIALOG(dialog)->vbox), 5); # endif gtk_dialog_add_button(GTK_DIALOG(dialog), # if GTK_CHECK_VERSION(2, 4, 0) GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE); # else GTK_STOCK_OK, GTK_RESPONSE_CLOSE); # endif gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE); g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(gtk_widget_destroy), dialog); # if GTK_CHECK_VERSION(2, 4, 0) button = gtk_button_new_with_mnemonic(_("C_redits")); # else button = gtk_button_new_with_mnemonic(_("_Credits")); # endif gtk_box_pack_end(GTK_BOX(GTK_DIALOG(dialog)->action_area), button, FALSE, TRUE, 0); gtk_button_box_set_child_secondary( GTK_BUTTON_BOX(GTK_DIALOG(dialog)->action_area), button, TRUE); g_signal_connect(button, "clicked", G_CALLBACK(display_credits_dialog), credits); gtk_widget_show(button); title = g_strdup_printf(_("About %s"), name); gtk_window_set_title(GTK_WINDOW(dialog), title); g_free(title); vbox = gtk_vbox_new(FALSE, 8); # if GTK_CHECK_VERSION(2, 4, 0) gtk_container_set_border_width(GTK_CONTAINER(vbox), 5); # else gtk_container_set_border_width(GTK_CONTAINER(vbox), 8); # endif gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), vbox, TRUE, TRUE, 0); logo_image = gtk_image_new(); gtk_image_set_from_pixbuf(GTK_IMAGE(logo_image), logo_pixbuf); gtk_box_pack_start(GTK_BOX(vbox), logo_image, FALSE, FALSE, 0); name_label = gtk_label_new(NULL); gtk_label_set_selectable(GTK_LABEL(name_label), TRUE); gtk_label_set_justify(GTK_LABEL(name_label), GTK_JUSTIFY_CENTER); gtk_box_pack_start(GTK_BOX(vbox), name_label, FALSE, FALSE, 0); comments_label = gtk_label_new(NULL); gtk_label_set_selectable(GTK_LABEL(comments_label), TRUE); gtk_label_set_justify(GTK_LABEL(comments_label), GTK_JUSTIFY_CENTER); gtk_label_set_line_wrap(GTK_LABEL(comments_label), TRUE); gtk_box_pack_start(GTK_BOX(vbox), comments_label, FALSE, FALSE, 0); copyright_label = gtk_label_new(NULL); gtk_label_set_selectable(GTK_LABEL(copyright_label), TRUE); gtk_label_set_justify(GTK_LABEL(comments_label), GTK_JUSTIFY_CENTER); gtk_box_pack_start(GTK_BOX(vbox), copyright_label, FALSE, FALSE, 0); str = g_strdup_printf( "<span size=\"xx-large\" weight=\"bold\">%s %s</span>", name, version); gtk_label_set_markup(GTK_LABEL(name_label), str); g_free(str); gtk_label_set_markup(GTK_LABEL(comments_label), comments); str = g_strdup_printf("<span size=\"small\">%s</span>", copyright); gtk_label_set_markup(GTK_LABEL(copyright_label), str); g_free(str); gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE); gtk_widget_show_all(vbox); return dialog; }
/* returns TRUE if a folder window should be opened */ static gboolean do_autorun_for_content_type (GMount *mount, const char *x_content_type, CajaAutorunOpenWindow open_window_func, gpointer user_data) { AutorunDialogData *data; GtkWidget *dialog; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *label; GtkWidget *combo_box; GtkWidget *always_check_button; GtkWidget *eject_button; GtkWidget *image; char *markup; char *content_description; char *mount_name; GIcon *icon; GdkPixbuf *pixbuf; CajaIconInfo *icon_info; int icon_size; gboolean user_forced_dialog; gboolean pref_ask; gboolean pref_start_app; gboolean pref_ignore; gboolean pref_open_folder; char *media_greeting; gboolean ret; ret = FALSE; mount_name = NULL; if (g_content_type_is_a (x_content_type, "x-content/win32-software")) { /* don't pop up the dialog anyway if the content type says * windows software. */ goto out; } user_forced_dialog = is_shift_pressed (); caja_autorun_get_preferences (x_content_type, &pref_start_app, &pref_ignore, &pref_open_folder); pref_ask = !pref_start_app && !pref_ignore && !pref_open_folder; if (user_forced_dialog) { goto show_dialog; } if (!pref_ask && !pref_ignore && !pref_open_folder) { GAppInfo *app_info; app_info = g_app_info_get_default_for_type (x_content_type, FALSE); if (app_info != NULL) { caja_autorun_launch_for_mount (mount, app_info); } goto out; } if (pref_open_folder) { ret = TRUE; goto out; } if (pref_ignore) { goto out; } show_dialog: mount_name = g_mount_get_name (mount); dialog = gtk_dialog_new (); hbox = gtk_hbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), hbox, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (hbox), 12); icon = g_mount_get_icon (mount); icon_size = caja_get_icon_size_for_stock_size (GTK_ICON_SIZE_DIALOG); icon_info = caja_icon_info_lookup (icon, icon_size); pixbuf = caja_icon_info_get_pixbuf_at_size (icon_info, icon_size); g_object_unref (icon_info); g_object_unref (icon); image = gtk_image_new_from_pixbuf (pixbuf); gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0); gtk_box_pack_start (GTK_BOX (hbox), image, TRUE, TRUE, 0); /* also use the icon on the dialog */ gtk_window_set_title (GTK_WINDOW (dialog), mount_name); gtk_window_set_icon (GTK_WINDOW (dialog), pixbuf); gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER); g_object_unref (pixbuf); vbox = gtk_vbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0); label = gtk_label_new (NULL); /* Customize greeting for well-known x-content types */ if (strcmp (x_content_type, "x-content/audio-cdda") == 0) { media_greeting = _("You have just inserted an Audio CD."); } else if (strcmp (x_content_type, "x-content/audio-dvd") == 0) { media_greeting = _("You have just inserted an Audio DVD."); } else if (strcmp (x_content_type, "x-content/video-dvd") == 0) { media_greeting = _("You have just inserted a Video DVD."); } else if (strcmp (x_content_type, "x-content/video-vcd") == 0) { media_greeting = _("You have just inserted a Video CD."); } else if (strcmp (x_content_type, "x-content/video-svcd") == 0) { media_greeting = _("You have just inserted a Super Video CD."); } else if (strcmp (x_content_type, "x-content/blank-cd") == 0) { media_greeting = _("You have just inserted a blank CD."); } else if (strcmp (x_content_type, "x-content/blank-dvd") == 0) { media_greeting = _("You have just inserted a blank DVD."); } else if (strcmp (x_content_type, "x-content/blank-cd") == 0) { media_greeting = _("You have just inserted a blank Blu-Ray disc."); } else if (strcmp (x_content_type, "x-content/blank-cd") == 0) { media_greeting = _("You have just inserted a blank HD DVD."); } else if (strcmp (x_content_type, "x-content/image-photocd") == 0) { media_greeting = _("You have just inserted a Photo CD."); } else if (strcmp (x_content_type, "x-content/image-picturecd") == 0) { media_greeting = _("You have just inserted a Picture CD."); } else if (strcmp (x_content_type, "x-content/image-dcf") == 0) { media_greeting = _("You have just inserted a medium with digital photos."); } else if (strcmp (x_content_type, "x-content/audio-player") == 0) { media_greeting = _("You have just inserted a digital audio player."); } else if (g_content_type_is_a (x_content_type, "x-content/software")) { media_greeting = _("You have just inserted a medium with software intended to be automatically started."); } else { /* fallback to generic greeting */ media_greeting = _("You have just inserted a medium."); } markup = g_strdup_printf ("<big><b>%s %s</b></big>", media_greeting, _("Choose what application to launch.")); gtk_label_set_markup (GTK_LABEL (label), markup); g_free (markup); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0); label = gtk_label_new (NULL); content_description = g_content_type_get_description (x_content_type); markup = g_strdup_printf (_("Select how to open \"%s\" and whether to perform this action in the future for other media of type \"%s\"."), mount_name, content_description); g_free (content_description); gtk_label_set_markup (GTK_LABEL (label), markup); g_free (markup); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0); data = g_new0 (AutorunDialogData, 1); data->dialog = dialog; data->mount = g_object_ref (mount); data->remember = !pref_ask; data->selected_ignore = pref_ignore; data->x_content_type = g_strdup (x_content_type); data->selected_app = g_app_info_get_default_for_type (x_content_type, FALSE); data->open_window_func = open_window_func; data->user_data = user_data; combo_box = gtk_combo_box_new (); caja_autorun_prepare_combo_box (combo_box, x_content_type, FALSE, TRUE, FALSE, autorun_combo_changed, data); g_signal_connect (G_OBJECT (combo_box), "key-press-event", G_CALLBACK (combo_box_enter_ok), dialog); gtk_box_pack_start (GTK_BOX (vbox), combo_box, TRUE, TRUE, 0); always_check_button = gtk_check_button_new_with_mnemonic (_("_Always perform this action")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (always_check_button), data->remember); g_signal_connect (G_OBJECT (always_check_button), "toggled", G_CALLBACK (autorun_always_toggled), data); gtk_box_pack_start (GTK_BOX (vbox), always_check_button, TRUE, TRUE, 0); gtk_dialog_add_buttons (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); if (g_mount_can_eject (mount)) { GtkWidget *eject_image; eject_button = gtk_button_new_with_mnemonic (_("_Eject")); pixbuf = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), "media-eject", caja_get_icon_size_for_stock_size (GTK_ICON_SIZE_BUTTON), 0, NULL); eject_image = gtk_image_new_from_pixbuf (pixbuf); g_object_unref (pixbuf); gtk_button_set_image (GTK_BUTTON (eject_button), eject_image); data->should_eject = TRUE; } else { eject_button = gtk_button_new_with_mnemonic (_("_Unmount")); data->should_eject = FALSE; } gtk_dialog_add_action_widget (GTK_DIALOG (dialog), eject_button, AUTORUN_DIALOG_RESPONSE_EJECT); gtk_button_box_set_child_secondary (GTK_BUTTON_BOX (gtk_dialog_get_action_area (GTK_DIALOG (dialog))), eject_button, TRUE); /* show the dialog */ gtk_widget_show_all (dialog); g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (autorun_dialog_response), data); g_signal_connect (G_OBJECT (data->mount), "unmounted", G_CALLBACK (autorun_dialog_mount_unmounted), data); out: g_free (mount_name); return ret; }
static void nautilus_mime_application_chooser_build_ui (NautilusMimeApplicationChooser *chooser) { GtkWidget *box, *button; GAppInfo *info; gtk_container_set_border_width (GTK_CONTAINER (chooser), 8); gtk_box_set_spacing (GTK_BOX (chooser), 0); gtk_box_set_homogeneous (GTK_BOX (chooser), FALSE); chooser->details->label = gtk_label_new (""); gtk_label_set_xalign (GTK_LABEL (chooser->details->label), 0); gtk_label_set_line_wrap (GTK_LABEL (chooser->details->label), TRUE); gtk_label_set_line_wrap_mode (GTK_LABEL (chooser->details->label), PANGO_WRAP_WORD_CHAR); gtk_box_pack_start (GTK_BOX (chooser), chooser->details->label, FALSE, FALSE, 0); gtk_widget_show (chooser->details->label); chooser->details->open_with_widget = gtk_app_chooser_widget_new (chooser->details->content_type); gtk_app_chooser_widget_set_show_default (GTK_APP_CHOOSER_WIDGET (chooser->details->open_with_widget), TRUE); gtk_app_chooser_widget_set_show_fallback (GTK_APP_CHOOSER_WIDGET (chooser->details->open_with_widget), TRUE); gtk_app_chooser_widget_set_show_other (GTK_APP_CHOOSER_WIDGET (chooser->details->open_with_widget), TRUE); gtk_box_pack_start (GTK_BOX (chooser), chooser->details->open_with_widget, TRUE, TRUE, 6); gtk_widget_show (chooser->details->open_with_widget); box = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL); gtk_box_set_spacing (GTK_BOX (box), 6); gtk_button_box_set_layout (GTK_BUTTON_BOX (box), GTK_BUTTONBOX_END); gtk_box_pack_start (GTK_BOX (chooser), box, FALSE, FALSE, 6); gtk_widget_show (box); button = gtk_button_new_with_label (_("Reset")); g_signal_connect (button, "clicked", G_CALLBACK (reset_clicked_cb), chooser); gtk_widget_show (button); gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0); gtk_button_box_set_child_secondary (GTK_BUTTON_BOX (box), button, TRUE); button = gtk_button_new_with_mnemonic (_("_Add")); g_signal_connect (button, "clicked", G_CALLBACK (add_clicked_cb), chooser); gtk_widget_show (button); gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0); chooser->details->add_button = button; button = gtk_button_new_with_label (_("Set as default")); g_signal_connect (button, "clicked", G_CALLBACK (set_as_default_clicked_cb), chooser); gtk_widget_show (button); gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0); chooser->details->set_as_default_button = button; /* initialize sensitivity */ info = gtk_app_chooser_get_app_info (GTK_APP_CHOOSER (chooser->details->open_with_widget)); if (info != NULL) { application_selected_cb (GTK_APP_CHOOSER_WIDGET (chooser->details->open_with_widget), info, chooser); g_object_unref (info); } g_signal_connect (chooser->details->open_with_widget, "application-selected", G_CALLBACK (application_selected_cb), chooser); g_signal_connect (chooser->details->open_with_widget, "populate-popup", G_CALLBACK (populate_popup_cb), chooser); }
void nsgtk_about_dialog_init(GtkWindow *parent, struct browser_window *bw, const char *version) { GtkWidget *dialog, *vbox, *button, *image, *label; gchar *name_string; GList *pixbufs = gtk_window_get_default_icon_list(); name_string = g_markup_printf_escaped ("<span size=\"xx-large\" weight=\"bold\">NetSurf %s</span>", version); /* Create the widgets */ dialog = gtk_dialog_new_with_buttons("About NetSurf", parent, GTK_DIALOG_DESTROY_WITH_PARENT, NULL); vbox = gtk_vbox_new (FALSE, 8); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), vbox, TRUE, TRUE, 0); if (pixbufs != NULL) { GtkIconSet *icon_set = gtk_icon_set_new_from_pixbuf(GDK_PIXBUF(g_list_nth_data(pixbufs, 0))); image = gtk_image_new(); gtk_image_set_from_icon_set (GTK_IMAGE (image), icon_set, GTK_ICON_SIZE_DIALOG); gtk_icon_set_unref (icon_set); g_list_free (pixbufs); gtk_box_pack_start(GTK_BOX (vbox), image, FALSE, FALSE, 0); } label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), name_string); g_free (name_string); gtk_label_set_selectable (GTK_LABEL (label), TRUE); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_CENTER); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); label = gtk_label_new("NetSurf is a small fast web browser"); gtk_label_set_selectable(GTK_LABEL (label), TRUE); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_CENTER); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); label = gtk_label_new("Copyright © 2003 - 2012 The NetSurf Developers"); gtk_label_set_selectable(GTK_LABEL(label), TRUE); gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_CENTER); gtk_box_pack_start(GTK_BOX (vbox), label, FALSE, FALSE, 0); nsgtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE); /* Add the OK button */ gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE); /* Add the credits button */ button = gtk_button_new_from_stock ("Credits"); gtk_box_pack_end(GTK_BOX (GTK_DIALOG (dialog)->action_area), button, FALSE, TRUE, 0); gtk_button_box_set_child_secondary (GTK_BUTTON_BOX (GTK_DIALOG (dialog)->action_area), button, TRUE); g_signal_connect(button, "clicked", G_CALLBACK(nsgtk_about_dialog_credits), (gpointer)bw); /* Add the Licence button */ button = gtk_button_new_from_stock ("Licence"); gtk_box_pack_end(GTK_BOX (GTK_DIALOG (dialog)->action_area), button, FALSE, TRUE, 0); gtk_button_box_set_child_secondary (GTK_BUTTON_BOX (GTK_DIALOG (dialog)->action_area), button, TRUE); g_signal_connect(button, "clicked", G_CALLBACK(nsgtk_about_dialog_licence), (gpointer)bw); /* Ensure that the dialog box is destroyed when the user responds. */ g_signal_connect_swapped(dialog, "response", G_CALLBACK (gtk_widget_destroy), dialog); /* Add the label, and show everything we've added to the dialog. */ gtk_widget_show_all(dialog); }
static void mate_druid_instance_init (MateDruid *druid) { druid->_priv = g_new0(MateDruidPrivate, 1); /* set the default border width */ GTK_CONTAINER (druid)->border_width = MATE_PAD_SMALL; /* set up the buttons */ GTK_WIDGET_SET_FLAGS (GTK_WIDGET (druid), GTK_NO_WINDOW); druid->back = gtk_button_new_from_stock (GTK_STOCK_GO_BACK); GTK_WIDGET_SET_FLAGS (druid->back, GTK_CAN_DEFAULT); druid->next = gtk_button_new_from_stock (GTK_STOCK_GO_FORWARD); GTK_WIDGET_SET_FLAGS (druid->next, GTK_CAN_DEFAULT); druid->cancel = gtk_button_new_from_stock (GTK_STOCK_CANCEL); GTK_WIDGET_SET_FLAGS (druid->cancel, GTK_CAN_DEFAULT); druid->finish = gtk_button_new_from_stock (GTK_STOCK_APPLY); GTK_WIDGET_SET_FLAGS (druid->finish, GTK_CAN_DEFAULT); druid->help = gtk_button_new_from_stock (GTK_STOCK_HELP); GTK_WIDGET_SET_FLAGS (druid->help, GTK_CAN_DEFAULT); gtk_widget_show (druid->back); gtk_widget_show (druid->next); gtk_widget_show (druid->cancel); druid->_priv->bbox = gtk_hbutton_box_new (); gtk_button_box_set_layout (GTK_BUTTON_BOX (druid->_priv->bbox), GTK_BUTTONBOX_END); /* FIXME: use a style property for these */ gtk_box_set_spacing (GTK_BOX (druid->_priv->bbox), 10); gtk_container_set_border_width (GTK_CONTAINER (druid->_priv->bbox), 5); gtk_widget_set_parent (druid->_priv->bbox, GTK_WIDGET (druid)); gtk_widget_show (druid->_priv->bbox); gtk_box_pack_end (GTK_BOX (druid->_priv->bbox), druid->help, FALSE, TRUE, 0); gtk_button_box_set_child_secondary (GTK_BUTTON_BOX (druid->_priv->bbox), druid->help, TRUE); gtk_box_pack_end (GTK_BOX (druid->_priv->bbox), druid->cancel, FALSE, TRUE, 0); gtk_box_pack_end (GTK_BOX (druid->_priv->bbox), druid->back, FALSE, TRUE, 0); gtk_box_pack_end (GTK_BOX (druid->_priv->bbox), druid->next, FALSE, TRUE, 0); gtk_box_pack_end (GTK_BOX (druid->_priv->bbox), druid->finish, FALSE, TRUE, 0); /* other flags */ druid->_priv->current = NULL; druid->_priv->children = NULL; druid->_priv->show_finish = FALSE; druid->_priv->show_help = FALSE; g_signal_connect (druid->back, "clicked", G_CALLBACK (mate_druid_back_callback), druid); g_signal_connect (druid->next, "clicked", G_CALLBACK (mate_druid_next_callback), druid); g_signal_connect (druid->cancel, "clicked", G_CALLBACK (mate_druid_cancel_callback), druid); g_signal_connect (druid->finish, "clicked", G_CALLBACK (mate_druid_next_callback), druid); g_signal_connect (druid->help, "clicked", G_CALLBACK (mate_druid_help_callback), druid); gtk_widget_grab_focus (druid->next); }
static gboolean remmina_nx_session_manager_main (RemminaProtocolWidget *gp) { RemminaPluginNxData *gpdata; RemminaFile *remminafile; GtkWidget *dialog; GtkWidget *widget; gchar *s; GtkWidget *scrolledwindow; GtkWidget *tree; GtkCellRenderer *renderer; GtkTreeViewColumn *column; gpdata = (RemminaPluginNxData*) g_object_get_data (G_OBJECT (gp), "plugin-data"); remminafile = remmina_plugin_nx_service->protocol_plugin_get_file (gp); if (!gpdata->manager_started) { remmina_plugin_nx_service->protocol_plugin_init_hide (gp); dialog = gtk_dialog_new (); s = g_strdup_printf (_("NX Sessions on %s"), remmina_plugin_nx_service->file_get_string (remminafile, "server")); gtk_window_set_title (GTK_WINDOW (dialog), s); g_free (s); if (gpdata->attach_session) { gtk_dialog_add_button (GTK_DIALOG (dialog), _("Attach"), REMMINA_NX_EVENT_ATTACH); } else { gtk_dialog_add_button (GTK_DIALOG (dialog), _("Restore"), REMMINA_NX_EVENT_RESTORE); gtk_dialog_add_button (GTK_DIALOG (dialog), _("Start"), REMMINA_NX_EVENT_START); } gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, REMMINA_NX_EVENT_CANCEL); widget = gtk_dialog_add_button (GTK_DIALOG (dialog), _("Terminate"), REMMINA_NX_EVENT_TERMINATE); gtk_button_box_set_child_secondary (GTK_BUTTON_BOX (gtk_dialog_get_action_area (GTK_DIALOG (dialog))), widget, TRUE); gtk_window_set_default_size (GTK_WINDOW (dialog), 640, 300); gpdata->manager_dialog = dialog; scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), scrolledwindow, TRUE, TRUE, 0); tree = gtk_tree_view_new (); gtk_container_add (GTK_CONTAINER (scrolledwindow), tree); gtk_widget_show (tree); remmina_nx_session_set_tree_view (gpdata->nx, GTK_TREE_VIEW (tree)); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("#", renderer, "text", REMMINA_NX_SESSION_COLUMN_ID, NULL); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_column_set_sort_column_id (column, REMMINA_NX_SESSION_COLUMN_ID); gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("Type"), renderer, "text", REMMINA_NX_SESSION_COLUMN_TYPE, NULL); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_column_set_sort_column_id (column, REMMINA_NX_SESSION_COLUMN_TYPE); gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("Display"), renderer, "text", REMMINA_NX_SESSION_COLUMN_DISPLAY, NULL); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_column_set_sort_column_id (column, REMMINA_NX_SESSION_COLUMN_DISPLAY); gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("Status"), renderer, "text", REMMINA_NX_SESSION_COLUMN_STATUS, NULL); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_column_set_sort_column_id (column, REMMINA_NX_SESSION_COLUMN_STATUS); gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("Name"), renderer, "text", REMMINA_NX_SESSION_COLUMN_NAME, NULL); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_column_set_sort_column_id (column, REMMINA_NX_SESSION_COLUMN_NAME); gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column); gtk_tree_selection_set_select_function ( gtk_tree_view_get_selection (GTK_TREE_VIEW (tree)), remmina_nx_session_manager_selection_func, gp, NULL); g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (remmina_nx_session_manager_on_response), gp); gpdata->manager_started = TRUE; } gpdata->manager_selected = FALSE; if (gpdata->manager_dialog) { remmina_nx_session_manager_set_sensitive (gp, FALSE); gtk_widget_show (gpdata->manager_dialog); } if (remmina_nx_session_has_error (gpdata->nx)) { dialog = gtk_message_dialog_new ((gpdata->manager_dialog ? GTK_WINDOW (gpdata->manager_dialog) : NULL), GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "%s", remmina_nx_session_get_error (gpdata->nx)); remmina_nx_session_clear_error (gpdata->nx); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); remmina_nx_session_manager_send_signal (gpdata, 0); } gpdata->session_manager_start_handler = 0; return FALSE; }
int main (int argc, char **argv) { GtkWidget *window; GtkWidget *vbox; GtkWidget *bbox; button_t buttons_1[] = { {"One", PRIMARY, PACK_START}, {"Two", SECONDARY, PACK_START}, {NULL} }; button_t buttons_2[] = { {"One", PRIMARY, PACK_START}, {"Two", PRIMARY, PACK_START}, {"Three", SECONDARY, PACK_START}, {"Four", SECONDARY, PACK_START}, {NULL} }; button_t buttons_3[] = { {"One", PRIMARY, PACK_START}, {"Two", PRIMARY, PACK_START}, {"Three", PRIMARY, PACK_START}, {"Four", SECONDARY, PACK_START}, {"Five", SECONDARY, PACK_START}, {"Six", SECONDARY, PACK_START}, {NULL} }; button_t buttons_4[] = { {"One", PRIMARY, PACK_START}, {"Two", PRIMARY, PACK_START}, {"Three", PRIMARY, PACK_START}, {"Four", PRIMARY, PACK_START}, {"Five", SECONDARY, PACK_START}, {"Six", SECONDARY, PACK_START}, {"Seven", SECONDARY, PACK_START}, {"Eight", SECONDARY, PACK_START}, {NULL} }; button_t *boxes[] = { buttons_1, buttons_2, buttons_3, buttons_4, }; int row; gtk_rc_add_default_file ("buttonbox.gtkrc"); gtk_init (&argc, &argv); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); vbox = gtk_vbox_new (FALSE, 0); if (g_getenv ("SAPWOOD_TESTING") && !strcmp (g_getenv ("SAPWOOD_TESTING"), "true")) { gtk_widget_set_app_paintable (window, TRUE); g_signal_connect_after (window, "expose-event", G_CALLBACK (gtk_widget_destroy), NULL); } for (row = 0; row < G_N_ELEMENTS(boxes); row++) { button_t *buttons = boxes[row]; bbox = gtk_hbutton_box_new (); gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_END); for (;;) { GtkWidget *widget; button_t *button = buttons++; if (!button->label) break; widget = gtk_button_new_with_label (button->label); if (button->pack_end) gtk_box_pack_end (GTK_BOX (bbox), widget, TRUE, TRUE, 0); else gtk_container_add (GTK_CONTAINER (bbox), widget); gtk_button_box_set_child_secondary (GTK_BUTTON_BOX (bbox), widget, button->is_secondary); } gtk_container_add (GTK_CONTAINER (vbox), bbox); } gtk_container_add (GTK_CONTAINER (window), vbox); gtk_widget_show_all (window); g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); gtk_main (); return 0; }
/**************************************************************** Worklist editor shell. *****************************************************************/ GtkWidget *create_worklist(void) { GtkWidget *editor, *table, *sw, *bbox; GtkWidget *src_view, *dst_view, *label, *button; GtkWidget *menubar, *item, *menu, *image; GtkWidget *table2, *arrow, *check; GtkSizeGroup *group; GtkListStore *src_store, *dst_store; struct worklist_data *ptr; ptr = fc_malloc(sizeof(*ptr)); src_store = gtk_list_store_new(1, G_TYPE_INT); dst_store = gtk_list_store_new(1, G_TYPE_INT); ptr->global_worklist_id = -1; ptr->pcity = NULL; ptr->src = src_store; ptr->dst = dst_store; ptr->future = FALSE; /* create shell. */ editor = gtk_grid_new(); gtk_grid_set_row_spacing(GTK_GRID(editor), 6); gtk_orientable_set_orientation(GTK_ORIENTABLE(editor), GTK_ORIENTATION_VERTICAL); g_signal_connect(editor, "destroy", G_CALLBACK(worklist_destroy), ptr); g_object_set_data(G_OBJECT(editor), "data", ptr); ptr->editor = editor; /* add source and target lists. */ table = gtk_grid_new(); gtk_container_add(GTK_CONTAINER(editor), table); group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_grid_attach(GTK_GRID(table), sw, 3, 1, 2, 1); src_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(src_store)); gtk_widget_set_hexpand(src_view, TRUE); gtk_widget_set_vexpand(src_view, TRUE); g_object_unref(src_store); gtk_size_group_add_widget(group, src_view); gtk_widget_set_name(src_view, "small_font"); populate_view(GTK_TREE_VIEW(src_view), &ptr->pcity, &ptr->src_col); gtk_container_add(GTK_CONTAINER(sw), src_view); label = g_object_new(GTK_TYPE_LABEL, "use-underline", TRUE, "mnemonic-widget", src_view, "label", _("Source _Tasks:"), "xalign", 0.0, "yalign", 0.5, NULL); gtk_grid_attach(GTK_GRID(table), label, 3, 0, 1, 1); check = gtk_check_button_new_with_mnemonic(_("Show _Future Targets")); gtk_grid_attach(GTK_GRID(table), check, 4, 0, 1, 1); g_signal_connect(check, "toggled", G_CALLBACK(future_callback), ptr); table2 = gtk_grid_new(); gtk_grid_attach(GTK_GRID(table), table2, 2, 1, 1, 1); button = gtk_button_new(); gtk_widget_set_margin_top(button, 24); gtk_widget_set_margin_bottom(button, 24); ptr->prepend_cmd = button; gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE); gtk_grid_attach(GTK_GRID(table2), button, 0, 0, 1, 1); arrow = gtk_arrow_new(GTK_ARROW_LEFT, GTK_SHADOW_NONE); gtk_container_add(GTK_CONTAINER(button), arrow); g_signal_connect_swapped(button, "clicked", G_CALLBACK(queue_prepend), ptr); gtk_widget_set_sensitive(ptr->prepend_cmd, FALSE); button = gtk_button_new(); ptr->up_cmd = button; gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE); gtk_grid_attach(GTK_GRID(table2), button, 0, 1, 1, 1); arrow = gtk_arrow_new(GTK_ARROW_UP, GTK_SHADOW_NONE); gtk_container_add(GTK_CONTAINER(button), arrow); g_signal_connect_swapped(button, "clicked", G_CALLBACK(queue_bubble_up), ptr); gtk_widget_set_sensitive(ptr->up_cmd, FALSE); button = gtk_button_new(); ptr->down_cmd = button; gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE); gtk_grid_attach(GTK_GRID(table2), button, 0, 2, 1, 1); arrow = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_IN); gtk_container_add(GTK_CONTAINER(button), arrow); g_signal_connect_swapped(button, "clicked", G_CALLBACK(queue_bubble_down), ptr); gtk_widget_set_sensitive(ptr->down_cmd, FALSE); button = gtk_button_new(); gtk_widget_set_margin_top(button, 24); gtk_widget_set_margin_bottom(button, 24); ptr->append_cmd = button; gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE); gtk_grid_attach(GTK_GRID(table2), button, 0, 3, 1, 1); arrow = gtk_arrow_new(GTK_ARROW_LEFT, GTK_SHADOW_NONE); gtk_container_add(GTK_CONTAINER(button), arrow); g_signal_connect_swapped(button, "clicked", G_CALLBACK(queue_append), ptr); gtk_widget_set_sensitive(ptr->append_cmd, FALSE); button = gtk_button_new(); gtk_widget_set_margin_top(button, 24); gtk_widget_set_margin_bottom(button, 24); ptr->remove_cmd = button; gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE); gtk_grid_attach(GTK_GRID(table2), button, 0, 4, 1, 1); arrow = gtk_arrow_new(GTK_ARROW_RIGHT, GTK_SHADOW_IN); gtk_container_add(GTK_CONTAINER(button), arrow); g_signal_connect_swapped(button, "clicked", G_CALLBACK(queue_remove), ptr); gtk_widget_set_sensitive(ptr->remove_cmd, FALSE); sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_grid_attach(GTK_GRID(table), sw, 0, 1, 2, 1); dst_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(dst_store)); gtk_widget_set_hexpand(dst_view, TRUE); gtk_widget_set_vexpand(dst_view, TRUE); g_object_unref(dst_store); gtk_size_group_add_widget(group, dst_view); gtk_widget_set_name(dst_view, "small_font"); populate_view(GTK_TREE_VIEW(dst_view), &ptr->pcity, &ptr->dst_col); gtk_container_add(GTK_CONTAINER(sw), dst_view); label = g_object_new(GTK_TYPE_LABEL, "use-underline", TRUE, "mnemonic-widget", dst_view, "label", _("Target _Worklist:"), "xalign", 0.0, "yalign", 0.5, NULL); gtk_grid_attach(GTK_GRID(table), label, 0, 0, 1, 1); /* add bottom menu and buttons. */ bbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL); gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END); gtk_box_set_spacing(GTK_BOX(bbox), 10); gtk_container_add(GTK_CONTAINER(editor), bbox); menubar = gtk_aux_menu_bar_new(); gtk_container_add(GTK_CONTAINER(bbox), menubar); gtk_button_box_set_child_secondary(GTK_BUTTON_BOX(bbox), menubar, TRUE); menu = gtk_menu_new(); image = gtk_image_new_from_stock(GTK_STOCK_ADD, GTK_ICON_SIZE_MENU); item = gtk_image_menu_item_new_with_mnemonic(_("_Add Global Worklist")); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), menu); gtk_menu_shell_append(GTK_MENU_SHELL(menubar), item); g_signal_connect(menu, "show", G_CALLBACK(popup_add_menu), ptr); ptr->add_cmd = item; gtk_widget_set_sensitive(ptr->add_cmd, FALSE); button = gtk_button_new_from_stock(GTK_STOCK_HELP); gtk_container_add(GTK_CONTAINER(bbox), button); g_signal_connect(button, "clicked", G_CALLBACK(help_callback), ptr); ptr->help_cmd = button; gtk_widget_set_sensitive(ptr->help_cmd, FALSE); button = gtk_button_new_with_mnemonic(_("Change Prod_uction")); gtk_container_add(GTK_CONTAINER(bbox), button); g_signal_connect(button, "clicked", G_CALLBACK(change_callback), ptr); ptr->change_cmd = button; gtk_widget_set_sensitive(ptr->change_cmd, FALSE); ptr->src_view = src_view; ptr->dst_view = dst_view; ptr->src_selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(src_view)); ptr->dst_selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dst_view)); gtk_tree_selection_set_mode(ptr->dst_selection, GTK_SELECTION_MULTIPLE); /* DND and other state changing callbacks. */ gtk_tree_view_set_reorderable(GTK_TREE_VIEW(dst_view), TRUE); g_signal_connect(dst_view, "drag_end", G_CALLBACK(dst_dnd_callback), ptr); g_signal_connect(src_view, "row_activated", G_CALLBACK(src_row_callback), ptr); g_signal_connect(src_view, "key_press_event", G_CALLBACK(src_key_press_callback), ptr); g_signal_connect(dst_view, "row_activated", G_CALLBACK(dst_row_callback), ptr); g_signal_connect(dst_view, "key_press_event", G_CALLBACK(dst_key_press_callback), ptr); g_signal_connect(ptr->src_selection, "changed", G_CALLBACK(src_selection_callback), ptr); g_signal_connect(ptr->dst_selection, "changed", G_CALLBACK(dst_selection_callback), ptr); gtk_widget_show_all(table); gtk_widget_show_all(bbox); return editor; }
void xkb_layout_choose (GtkBuilder * dialog) { GtkBuilder *chooser_dialog; chooser_dialog = gtk_builder_new (); gtk_builder_add_from_file (chooser_dialog, MATECC_UI_DIR "/mate-keyboard-properties-layout-chooser.ui", NULL); GtkWidget *chooser = CWID ("xkb_layout_chooser"); GtkWidget *lang_chooser = CWID ("xkb_languages_available"); GtkWidget *notebook = CWID ("choosers_nb"); GtkWidget *kbdraw = NULL; GtkWidget *toplevel = NULL; gtk_window_set_transient_for (GTK_WINDOW (chooser), GTK_WINDOW (WID ("keyboard_dialog"))); xkb_layout_chooser_available_layouts_fill (chooser_dialog, "xkb_countries_available", "xkb_country_variants_available", xkl_config_registry_foreach_country, (ConfigItemProcessFunc) xkb_layout_chooser_add_country_to_available_countries, G_CALLBACK (xkb_layout_chooser_available_country_changed)); xkb_layout_chooser_available_layouts_fill (chooser_dialog, "xkb_languages_available", "xkb_language_variants_available", xkl_config_registry_foreach_language, (ConfigItemProcessFunc) xkb_layout_chooser_add_language_to_available_languages, G_CALLBACK (xkb_layout_chooser_available_language_changed)); g_signal_connect_after (G_OBJECT (notebook), "switch_page", G_CALLBACK (xkb_layout_chooser_page_changed), chooser_dialog); gtk_combo_box_set_active (GTK_COMBO_BOX (CWID ("xkb_countries_available")), FALSE); if (gtk_tree_model_iter_n_children (gtk_combo_box_get_model (GTK_COMBO_BOX (lang_chooser)), NULL)) { gtk_combo_box_set_active (GTK_COMBO_BOX (CWID ("xkb_languages_available")), FALSE); } else { /* If language info is not available - remove the corresponding tab, pretend there is no notebook at all */ gtk_notebook_remove_page (GTK_NOTEBOOK (notebook), 1); gtk_notebook_set_show_tabs (GTK_NOTEBOOK (notebook), FALSE); gtk_notebook_set_show_border (GTK_NOTEBOOK (notebook), FALSE); } #ifdef HAVE_X11_EXTENSIONS_XKB_H if (!strcmp (xkl_engine_get_backend_name (engine), "XKB")) { kbdraw = xkb_layout_preview_create_widget (chooser_dialog); g_object_set_data (G_OBJECT (chooser), "kbdraw", kbdraw); gtk_container_add (GTK_CONTAINER (CWID ("previewFrame")), kbdraw); gtk_widget_show_all (kbdraw); gtk_button_box_set_child_secondary (GTK_BUTTON_BOX (CWID ("hbtnBox")), CWID ("btnPrint"), TRUE); } else #endif { gtk_widget_hide_all (CWID ("vboxPreview")); gtk_widget_hide (CWID ("btnPrint")); } g_signal_connect (G_OBJECT (chooser), "response", G_CALLBACK (xkb_layout_chooser_response), chooser_dialog); toplevel = gtk_widget_get_toplevel (chooser); if (gtk_widget_is_toplevel (toplevel)) { GdkRectangle *rect = matekbd_preview_load_position (); if (rect != NULL) { gtk_window_move (GTK_WINDOW (toplevel), rect->x, rect->y); gtk_window_resize (GTK_WINDOW (toplevel), rect->width, rect->height); g_free (rect); } } xkb_layout_preview_update (chooser_dialog); gtk_dialog_run (GTK_DIALOG (chooser)); gtk_widget_destroy (chooser); }
static void imp_ldif_dialog_create() { GtkWidget *window; GtkWidget *vbox; GtkWidget *vnbox; GtkWidget *notebook; GtkWidget *hbbox; GtkWidget *btnPrev; GtkWidget *btnNext; GtkWidget *btnCancel; GtkWidget *hsbox; GtkWidget *statusbar; window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_widget_set_size_request(window, IMPORTLDIF_WIDTH, IMPORTLDIF_HEIGHT ); gtk_container_set_border_width( GTK_CONTAINER(window), 0 ); gtk_window_set_title( GTK_WINDOW(window), _("Import LDIF file into Address Book") ); gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); gtk_window_set_modal(GTK_WINDOW(window), TRUE); g_signal_connect(G_OBJECT(window), "delete_event", G_CALLBACK(imp_ldif_delete_event), NULL); g_signal_connect(G_OBJECT(window), "key_press_event", G_CALLBACK(imp_ldif_key_pressed), NULL); MANAGE_WINDOW_SIGNALS_CONNECT(window); vbox = gtk_vbox_new(FALSE, 4); gtk_widget_show(vbox); gtk_container_add(GTK_CONTAINER(window), vbox); vnbox = gtk_vbox_new(FALSE, 4); gtk_container_set_border_width(GTK_CONTAINER(vnbox), 4); gtk_widget_show(vnbox); gtk_box_pack_start(GTK_BOX(vbox), vnbox, TRUE, TRUE, 0); /* Notebook */ notebook = gtk_notebook_new(); gtk_notebook_set_show_tabs( GTK_NOTEBOOK(notebook), FALSE ); gtk_widget_show(notebook); gtk_box_pack_start(GTK_BOX(vnbox), notebook, TRUE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(notebook), 6); /* Status line */ hsbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_end(GTK_BOX(vbox), hsbox, FALSE, FALSE, 0); statusbar = gtk_statusbar_new(); gtk_box_pack_start(GTK_BOX(hsbox), statusbar, TRUE, TRUE, 0); /* Button panel */ gtkut_stock_button_set_create(&hbbox, &btnNext, _("Next"), &btnPrev, _("Prev"), &btnCancel, GTK_STOCK_CANCEL); gtk_button_box_set_child_secondary(GTK_BUTTON_BOX(hbbox), btnCancel, TRUE); gtkut_box_set_reverse_order(GTK_BOX(hbbox), FALSE); gtk_box_pack_end(GTK_BOX(vbox), hbbox, FALSE, FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(hbbox), 2); gtk_widget_grab_default(btnNext); /* Button handlers */ g_signal_connect(G_OBJECT(btnPrev), "clicked", G_CALLBACK(imp_ldif_prev), NULL); g_signal_connect(G_OBJECT(btnNext), "clicked", G_CALLBACK(imp_ldif_next), NULL); g_signal_connect(G_OBJECT(btnCancel), "clicked", G_CALLBACK(imp_ldif_cancel), NULL); gtk_widget_show_all(vbox); impldif_dlg.window = window; impldif_dlg.notebook = notebook; impldif_dlg.btnPrev = btnPrev; impldif_dlg.btnNext = btnNext; impldif_dlg.btnCancel = btnCancel; impldif_dlg.statusbar = statusbar; impldif_dlg.status_cid = gtk_statusbar_get_context_id( GTK_STATUSBAR(statusbar), "Import LDIF Dialog" ); }
static void create_adapter(adapter_data *adapter) { GHashTable *hash = NULL; GValue *value; DBusGProxy *default_proxy; const gchar *name; gboolean powered, discoverable; guint timeout; GtkWidget *mainbox; GtkWidget *vbox; GtkWidget *alignment; GtkWidget *table; GtkWidget *label; GtkWidget *image; GtkWidget *button; GtkWidget *entry; GtkWidget *buttonbox; int page_num; dbus_g_proxy_call(adapter->proxy, "GetProperties", NULL, G_TYPE_INVALID, dbus_g_type_get_map("GHashTable", G_TYPE_STRING, G_TYPE_VALUE), &hash, G_TYPE_INVALID); if (hash != NULL) { value = g_hash_table_lookup(hash, "Name"); name = value ? g_value_get_string(value) : NULL; value = g_hash_table_lookup(hash, "Powered"); powered = value ? g_value_get_boolean(value) : FALSE; value = g_hash_table_lookup(hash, "Discoverable"); discoverable = value ? g_value_get_boolean(value) : FALSE; value = g_hash_table_lookup(hash, "DiscoverableTimeout"); timeout = value ? g_value_get_uint(value) : 0; } else { name = NULL; powered = FALSE; discoverable = FALSE; timeout = 0; } adapter->powered = powered; adapter->discoverable = discoverable; adapter->timeout_value = timeout; default_proxy = bluetooth_client_get_default_adapter (client); if (default_proxy != NULL) { adapter->is_default = g_str_equal (dbus_g_proxy_get_path (default_proxy), dbus_g_proxy_get_path (adapter->proxy)); g_object_unref (default_proxy); } mainbox = gtk_vbox_new(FALSE, 6); gtk_container_set_border_width(GTK_CONTAINER(mainbox), 12); page_num = gtk_notebook_prepend_page(GTK_NOTEBOOK(adapter->notebook), mainbox, NULL); adapter->child = mainbox; vbox = gtk_vbox_new(FALSE, 6); gtk_box_pack_start(GTK_BOX(mainbox), vbox, FALSE, TRUE, 0); /* The discoverable checkbox */ button = gtk_check_button_new_with_mnemonic (_("Make computer _visible")); if (powered == FALSE) discoverable = FALSE; if (discoverable != FALSE && timeout == 0) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); else if (discoverable == FALSE) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE); else { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (button), TRUE); } gtk_widget_set_sensitive (button, adapter->powered); adapter->button_discoverable = button; adapter->signal_discoverable = g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(discoverable_changed_cb), adapter); gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 0); /* The friendly name */ vbox = gtk_vbox_new(FALSE, 6); gtk_box_pack_start(GTK_BOX(mainbox), vbox, FALSE, FALSE, 0); label = create_label(_("Friendly name")); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment); gtk_box_pack_start (GTK_BOX (vbox), alignment, TRUE, TRUE, 0); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 12, 0); entry = gtk_entry_new(); gtk_entry_set_max_length(GTK_ENTRY(entry), 248); gtk_widget_set_size_request(entry, 240, -1); gtk_container_add (GTK_CONTAINER (alignment), entry); if (name != NULL) gtk_entry_set_text(GTK_ENTRY(entry), name); adapter->entry = entry; adapter->name_vbox = vbox; g_signal_connect(G_OBJECT(entry), "changed", G_CALLBACK(name_callback), adapter); g_signal_connect(G_OBJECT(entry), "focus-out-event", G_CALLBACK(focus_callback), adapter); gtk_widget_set_sensitive (adapter->name_vbox, adapter->powered); /* The known devices */ table = gtk_table_new(2, 2, FALSE); gtk_box_pack_start(GTK_BOX(mainbox), table, TRUE, TRUE, 0); label = create_label(_("Devices")); gtk_table_attach(GTK_TABLE(table), label, 0, 2, 0, 1, GTK_EXPAND | GTK_FILL, GTK_SHRINK, 0, 6); /* Note that this will only ever show the devices on the default * adapter, this is on purpose */ adapter->chooser = bluetooth_chooser_new (NULL); g_object_set (adapter->chooser, "show-searching", FALSE, "show-device-type", FALSE, "show-device-category", FALSE, "show-pairing", TRUE, "show-connected", TRUE, "device-category-filter", BLUETOOTH_CATEGORY_PAIRED_OR_TRUSTED, NULL); g_signal_connect (adapter->chooser, "notify::device-selected", G_CALLBACK(device_selected_cb), adapter); gtk_table_attach(GTK_TABLE(table), adapter->chooser, 0, 1, 1, 2, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); adapter->devices_table = table; buttonbox = gtk_vbutton_box_new(); gtk_button_box_set_layout(GTK_BUTTON_BOX(buttonbox), GTK_BUTTONBOX_START); gtk_box_set_spacing(GTK_BOX(buttonbox), 6); gtk_box_set_homogeneous(GTK_BOX(buttonbox), FALSE); gtk_table_attach(GTK_TABLE(table), buttonbox, 1, 2, 1, 2, GTK_FILL, GTK_FILL, 6, 6); button = gtk_button_new_with_mnemonic(_("Set up _new device...")); image = gtk_image_new_from_stock(GTK_STOCK_ADD, GTK_ICON_SIZE_BUTTON); gtk_button_set_image(GTK_BUTTON(button), image); gtk_box_pack_start(GTK_BOX(buttonbox), button, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(wizard_callback), adapter); button = gtk_button_new_with_label(_("Disconnect")); image = gtk_image_new_from_stock(GTK_STOCK_DISCONNECT, GTK_ICON_SIZE_BUTTON); gtk_button_set_image(GTK_BUTTON(button), image); gtk_box_pack_end(GTK_BOX(buttonbox), button, FALSE, FALSE, 0); gtk_button_box_set_child_secondary(GTK_BUTTON_BOX(buttonbox), button, TRUE); gtk_widget_set_sensitive(button, FALSE); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(disconnect_callback), adapter); adapter->button_disconnect = button; button = gtk_button_new_with_mnemonic(_("_Remove")); image = gtk_image_new_from_stock(GTK_STOCK_REMOVE, GTK_ICON_SIZE_BUTTON); gtk_button_set_image(GTK_BUTTON(button), image); gtk_box_pack_end(GTK_BOX(buttonbox), button, FALSE, FALSE, 0); gtk_button_box_set_child_secondary(GTK_BUTTON_BOX(buttonbox), button, TRUE); gtk_widget_set_sensitive(button, FALSE); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(remove_callback), adapter); adapter->button_delete = button; gtk_widget_set_sensitive (adapter->devices_table, adapter->powered); g_object_set_data(G_OBJECT(mainbox), "adapter", adapter); gtk_widget_show_all(mainbox); if (adapter->is_default != FALSE) gtk_notebook_set_current_page (GTK_NOTEBOOK (adapter->notebook), page_num); }
GtkWidget * screenshot_interactive_dialog_new (CaptureClickedCallback f, gpointer user_data) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *button_box; GtkWidget *button; gboolean shows_app_menu; GtkSettings *settings; CaptureData *data; dialog = gtk_application_window_new (GTK_APPLICATION (g_application_get_default ())); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gtk_window_set_title (GTK_WINDOW (dialog), _("Take Screenshot")); gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER); gtk_container_set_border_width (GTK_CONTAINER (dialog), 5); /* main container */ main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 18); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 5); gtk_container_add (GTK_CONTAINER (dialog), main_vbox); create_screenshot_frame (main_vbox, _("Take Screenshot")); create_effects_frame (main_vbox, _("Effects")); button_box = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL); gtk_button_box_set_layout (GTK_BUTTON_BOX (button_box), GTK_BUTTONBOX_END); gtk_container_add (GTK_CONTAINER (main_vbox), button_box); /* add help as a dialog button if we're not showing the application menu */ settings = gtk_settings_get_for_screen (gtk_widget_get_screen (GTK_WIDGET (dialog))); g_object_get (settings, "gtk-shell-shows-app-menu", &shows_app_menu, NULL); if (!shows_app_menu) { button = gtk_button_new_from_stock (GTK_STOCK_HELP); g_signal_connect_swapped (button, "clicked", G_CALLBACK (screenshot_display_help), dialog); gtk_container_add (GTK_CONTAINER (button_box), button); gtk_button_box_set_child_secondary (GTK_BUTTON_BOX (button_box), button, TRUE); } button = gtk_button_new_with_mnemonic (_("Take _Screenshot")); data = g_new (CaptureData, 1); data->widget = dialog; data->callback = f; data->user_data = user_data; g_signal_connect (button, "clicked", G_CALLBACK (capure_button_clicked_cb), data); gtk_container_add (GTK_CONTAINER (button_box), button); gtk_widget_set_can_default (button, TRUE); gtk_widget_grab_default (button); g_signal_connect (dialog, "key-press-event", G_CALLBACK (interactive_dialog_key_press_cb), NULL); gtk_widget_show_all (dialog); return dialog; }
static GtkWidget *create_window(GtkWidget *notebook) { GtkWidget *window; GtkWidget *vbox; GtkWidget *buttonbox; GtkWidget *button; GtkWidget *image; GSettings *settings; window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window), _("Bluetooth Preferences")); gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); gtk_window_set_default_size(GTK_WINDOW(window), 600, 420); g_signal_connect(G_OBJECT(window), "delete-event", G_CALLBACK(delete_callback), NULL); g_signal_connect(G_OBJECT(window), "key-press-event", G_CALLBACK(keypress_callback), NULL); vbox = gtk_vbox_new(FALSE, 6); gtk_container_set_border_width(GTK_CONTAINER(vbox), 12); gtk_container_add(GTK_CONTAINER(window), vbox); gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0); button = gtk_check_button_new_with_mnemonic (_("_Show Bluetooth icon")); gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 0); settings = g_settings_new (SCHEMA_NAME); g_settings_bind (settings, PREF_SHOW_ICON, G_OBJECT (button), "active", G_SETTINGS_BIND_DEFAULT); buttonbox = gtk_hbutton_box_new(); gtk_button_box_set_layout(GTK_BUTTON_BOX(buttonbox), GTK_BUTTONBOX_END); gtk_box_pack_start(GTK_BOX(vbox), buttonbox, FALSE, FALSE, 0); button = gtk_button_new_from_stock(GTK_STOCK_CLOSE); gtk_container_add(GTK_CONTAINER(buttonbox), button); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(close_callback), window); button = gtk_button_new_from_stock(GTK_STOCK_HELP); gtk_container_add(GTK_CONTAINER(buttonbox), button); gtk_button_box_set_child_secondary(GTK_BUTTON_BOX(buttonbox), button, TRUE); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(help_callback), window); image = gtk_image_new_from_stock (GTK_STOCK_JUMP_TO, GTK_ICON_SIZE_BUTTON); button = gtk_button_new_with_label (_("Receive Files")); gtk_button_set_image (GTK_BUTTON (button), image); gtk_container_add(GTK_CONTAINER(buttonbox), button); gtk_button_box_set_child_secondary(GTK_BUTTON_BOX(buttonbox), button, TRUE); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(receive_callback), window); gtk_widget_show_all(window); return window; }
GtkWidget * gimp_file_dialog_new (Gimp *gimp, GtkFileChooserAction action, const gchar *title, const gchar *role, const gchar *stock_id, const gchar *help_id) { GimpFileDialog *dialog; GSList *file_procs; const gchar *automatic; const gchar *automatic_help_id; const gchar *pictures; gboolean local_only; g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL); g_return_val_if_fail (title != NULL, NULL); g_return_val_if_fail (role != NULL, NULL); g_return_val_if_fail (stock_id != NULL, NULL); g_return_val_if_fail (help_id != NULL, NULL); switch (action) { case GTK_FILE_CHOOSER_ACTION_OPEN: file_procs = gimp->plug_in_manager->load_procs; automatic = _("Automatically Detected"); automatic_help_id = GIMP_HELP_FILE_OPEN_BY_EXTENSION; /* FIXME */ local_only = (gimp_pdb_lookup_procedure (gimp->pdb, "file-uri-load") == NULL); break; case GTK_FILE_CHOOSER_ACTION_SAVE: file_procs = gimp->plug_in_manager->save_procs; automatic = _("By Extension"); automatic_help_id = GIMP_HELP_FILE_SAVE_BY_EXTENSION; /* FIXME */ local_only = (gimp_pdb_lookup_procedure (gimp->pdb, "file-uri-save") == NULL); break; default: g_return_val_if_reached (NULL); return NULL; } dialog = g_object_new (GIMP_TYPE_FILE_DIALOG, "title", title, "role", role, "action", action, "local-only", local_only, "do-overwrite-confirmation", TRUE, NULL); gtk_dialog_add_buttons (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, stock_id, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_help_connect (GTK_WIDGET (dialog), gimp_file_dialog_help_func, help_id, dialog); if (GIMP_GUI_CONFIG (gimp->config)->show_help_button && help_id) { GtkWidget *action_area = GTK_DIALOG (dialog)->action_area; GtkWidget *button = gtk_button_new_from_stock (GTK_STOCK_HELP); gtk_box_pack_end (GTK_BOX (action_area), button, FALSE, TRUE, 0); gtk_button_box_set_child_secondary (GTK_BUTTON_BOX (action_area), button, TRUE); gtk_widget_show (button); g_object_set_data_full (G_OBJECT (dialog), "gimp-dialog-help-id", g_strdup (help_id), (GDestroyNotify) g_free); g_signal_connect (button, "clicked", G_CALLBACK (gimp_file_dialog_help_clicked), dialog); g_object_set_data (G_OBJECT (dialog), "gimp-dialog-help-button", button); } pictures = gimp_user_directory (GIMP_USER_DIRECTORY_PICTURES); if (pictures) gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog), pictures, NULL); gimp_file_dialog_add_preview (dialog, gimp); gimp_file_dialog_add_filters (dialog, gimp, file_procs); gimp_file_dialog_add_proc_selection (dialog, gimp, file_procs, automatic, automatic_help_id); dialog->progress = gimp_progress_box_new (); gtk_box_pack_end (GTK_BOX (GTK_DIALOG (dialog)->vbox), dialog->progress, FALSE, FALSE, 0); return GTK_WIDGET (dialog); }