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);
}
