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 ();
}
static GtkWidget *build_yesno_dialog(GtkWidget **yesno_dialog_message)
{
GtkWidget *yesno_dialog;
yesno_dialog = gtk_dialog_new_with_buttons("", NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_NO,
GTK_RESPONSE_NO, GTK_STOCK_YES, GTK_RESPONSE_YES, NULL);
*yesno_dialog_message = gtk_label_new("");
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(yesno_dialog))), *yesno_dialog_message,TRUE,TRUE,0);
gtk_widget_show(*yesno_dialog_message);
gtk_widget_show(yesno_dialog);
gtk_widget_set_size_request(yesno_dialog, gtk_widget_get_allocated_width(gtk_dialog_get_action_area(GTK_DIALOG(yesno_dialog))) * 2,
gtk_widget_get_allocated_height(gtk_dialog_get_action_area(GTK_DIALOG(yesno_dialog))) * 3);
return yesno_dialog;
}
static void
script_fu_response (GtkWidget *widget,
gint response_id,
SFScript *script)
{
GtkWidget *action_area;
action_area = gtk_dialog_get_action_area (GTK_DIALOG (sf_interface->dialog));
if (! gtk_widget_is_sensitive (action_area))
return;
switch (response_id)
{
case RESPONSE_RESET:
script_fu_reset (script);
break;
case GTK_RESPONSE_OK:
gtk_widget_set_sensitive (sf_interface->table, FALSE);
gtk_widget_set_sensitive (action_area, FALSE);
script_fu_ok (script);
gtk_widget_destroy (sf_interface->dialog);
break;
default:
sf_status = GIMP_PDB_CANCEL;
gtk_widget_destroy (sf_interface->dialog);
break;
}
}
GtkWidget * AP_UnixDialog_ListRevisions::constructWindow ()
{
GtkWidget *ap_UnixDialog_ListRevisions;
GtkWidget *vbDialog;
GtkWidget *aaDialog;
ap_UnixDialog_ListRevisions = abiDialogNew ( "list revisions dialog", TRUE, getTitle());
gtk_window_set_modal (GTK_WINDOW (ap_UnixDialog_ListRevisions), TRUE);
gtk_window_set_default_size ( GTK_WINDOW(ap_UnixDialog_ListRevisions), 800, 450 ) ;
vbDialog = gtk_dialog_get_content_area(GTK_DIALOG(ap_UnixDialog_ListRevisions));
gtk_widget_show (vbDialog);
gtk_container_set_border_width (GTK_CONTAINER (vbDialog), 5);
aaDialog = gtk_dialog_get_action_area(GTK_DIALOG(ap_UnixDialog_ListRevisions));
gtk_widget_show (aaDialog);
constructWindowContents ( vbDialog ) ;
abiAddStockButton ( GTK_DIALOG(ap_UnixDialog_ListRevisions), GTK_STOCK_CANCEL, BUTTON_CANCEL ) ;
abiAddStockButton ( GTK_DIALOG(ap_UnixDialog_ListRevisions), GTK_STOCK_OK, BUTTON_OK ) ;
return ap_UnixDialog_ListRevisions;
}
GtkWidget * AP_UnixDialog_Styles::_constructModifyDialog(void)
{
GtkWidget *modifyDialog;
GtkWidget *dialog_action_area;
const XAP_StringSet * pSS = m_pApp->getStringSet();
UT_UTF8String title;
if(!isNew())
pSS->getValueUTF8(AP_STRING_ID_DLG_Styles_ModifyTitle,title);
else
pSS->getValueUTF8(AP_STRING_ID_DLG_Styles_NewTitle,title);
modifyDialog = abiDialogNew("modify style dialog", TRUE, title.utf8_str());
gtk_container_set_border_width (GTK_CONTAINER (modifyDialog), 5);
_constructModifyDialogContents(gtk_dialog_get_content_area(GTK_DIALOG (modifyDialog)));
dialog_action_area = gtk_dialog_get_action_area(GTK_DIALOG (modifyDialog));
gtk_widget_show (dialog_action_area);
m_wModifyDialog = modifyDialog;
//
// Gnome buttons
//
_constructGnomeModifyButtons(dialog_action_area);
//
// Connect signals
//
_connectModifySignals();
return modifyDialog;
}
WaitDialog::WaitDialog(int milliseconds, int width, int height)
{
waitdialog = gtk_dialog_new();
gtk_window_set_title(GTK_WINDOW(waitdialog), _("Please wait ..."));
gtk_window_set_position(GTK_WINDOW(waitdialog), GTK_WIN_POS_CENTER_ON_PARENT);
gtk_window_set_modal(GTK_WINDOW(waitdialog), TRUE);
if (width && height)
gtk_window_set_default_size(GTK_WINDOW(waitdialog), width, height);
dialog_vbox1 = gtk_dialog_get_content_area (GTK_DIALOG(waitdialog));
gtk_widget_show(dialog_vbox1);
vbox1 = gtk_vbox_new(FALSE, 0);
gtk_widget_show(vbox1);
gtk_box_pack_start(GTK_BOX(dialog_vbox1), vbox1, TRUE, TRUE, 0);
label1 = gtk_label_new(_("Please hold on ... processing data"));
gtk_widget_show(label1);
gtk_box_pack_start(GTK_BOX(vbox1), label1, FALSE, FALSE, 0);
dialog_action_area1 = gtk_dialog_get_action_area (GTK_DIALOG(waitdialog));
gtk_widget_show(dialog_action_area1);
gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area1), GTK_BUTTONBOX_END);
g_timeout_add(milliseconds, GSourceFunc(static_on_timeout), gpointer(this));
}
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);
}
}
GtkWidget * AP_UnixDialog_MarkRevisions::constructWindow ()
{
const XAP_StringSet * pSS = XAP_App::getApp()->getStringSet();
GtkWidget* w = 0;
GtkWidget *dialog1;
GtkWidget *dialog_vbox1;
GtkWidget *dialog_action_area1;
UT_UTF8String s;
pSS->getValueUTF8(AP_STRING_ID_DLG_MarkRevisions_Title,s);
dialog1 = abiDialogNew ( "mark revisions", TRUE, s.utf8_str());
gtk_window_set_default_size ( GTK_WINDOW(dialog1), 250, 150 ) ;
dialog_vbox1 = gtk_dialog_get_content_area(GTK_DIALOG (dialog1));
gtk_widget_show (dialog_vbox1);
dialog_action_area1 = gtk_dialog_get_action_area(GTK_DIALOG (dialog1));
gtk_widget_show (dialog_action_area1);
gtk_container_set_border_width (GTK_CONTAINER (dialog_action_area1), 10);
constructWindowContents ( dialog_vbox1 ) ;
abiAddStockButton ( GTK_DIALOG(dialog1), GTK_STOCK_CANCEL, BUTTON_CANCEL );
w = abiAddStockButton ( GTK_DIALOG(dialog1),
GTK_STOCK_OK, BUTTON_OK );
mButtonOK = w;
abiSetActivateOnWidgetToActivateButton( mComment, mButtonOK );
return dialog1;
}
gboolean
alarm_dialog_run (GtkWidget *parent,
ECalClient *cal_client,
ECalComponentAlarm *alarm)
{
Dialog dialog;
GtkWidget *container;
gint response_id;
g_return_val_if_fail (alarm != NULL, FALSE);
dialog.alarm = alarm;
dialog.cal_client = cal_client;
dialog.builder = gtk_builder_new ();
e_load_ui_builder_definition (dialog.builder, "alarm-dialog.ui");
if (!get_widgets (&dialog)) {
g_object_unref (dialog.builder);
return FALSE;
}
if (!setup_select_names (&dialog)) {
g_object_unref (dialog.builder);
return FALSE;
}
init_widgets (&dialog);
alarm_to_dialog (&dialog);
gtk_widget_ensure_style (dialog.toplevel);
container = gtk_dialog_get_action_area (GTK_DIALOG (dialog.toplevel));
gtk_container_set_border_width (GTK_CONTAINER (container), 12);
container = gtk_dialog_get_content_area (GTK_DIALOG (dialog.toplevel));
gtk_container_set_border_width (GTK_CONTAINER (container), 0);
gtk_window_set_icon_name (
GTK_WINDOW (dialog.toplevel), "x-office-calendar");
gtk_window_set_transient_for (
GTK_WINDOW (dialog.toplevel),
GTK_WINDOW (parent));
response_id = gtk_dialog_run (GTK_DIALOG (dialog.toplevel));
if (response_id == GTK_RESPONSE_OK)
dialog_to_alarm (&dialog);
if (dialog.name_selector) {
e_name_selector_cancel_loading (dialog.name_selector);
g_object_unref (dialog.name_selector);
}
gtk_widget_destroy (dialog.toplevel);
g_object_unref (dialog.builder);
return response_id == GTK_RESPONSE_OK ? TRUE : FALSE;
}
void DialogManagerX11::_showFolderDialog(FB::PluginWindow* win, bool multi, const PathCallback& cb)
{
FB::VariantList out;
// Create the dialog. Do it the hard way so we can override the default
// behavior which does not allow files and directories to be selected together.
GtkWidget *dialog = gtk_dialog_new_with_buttons("Open", NULL, GTK_DIALOG_MODAL,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
GtkWidget *action_area = gtk_dialog_get_action_area(GTK_DIALOG(dialog));
GtkWidget *content_area = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
// Some nicer formatting
gtk_box_set_spacing(GTK_BOX(content_area), 2);
gtk_container_set_border_width(GTK_CONTAINER(dialog), 5);
gtk_container_set_border_width(GTK_CONTAINER(action_area), 5);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
// Create the file chooser widget
GtkWidget *chooser = gtk_file_chooser_widget_new(GTK_FILE_CHOOSER_ACTION_OPEN);
if (multi)
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(chooser), TRUE);
// And add it to the dialog
gtk_container_add(GTK_CONTAINER(content_area), chooser);
gtk_widget_show(chooser);
// for the life of me I can't figure out how to get the filechooserwidget
// to return an actual requested size. Going with the simple hard coded
// size until that can be figured out.
gtk_window_resize(GTK_WINDOW(dialog), 600, 400);
// run the dialog
gint result = gtk_dialog_run(GTK_DIALOG(dialog));
if (result == GTK_RESPONSE_ACCEPT) {
char *buffer;
std::string filename;
GSList *filenames, *iterator;
filenames = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(chooser));
iterator = filenames;
while (iterator) {
buffer = (char *)g_slist_nth_data(iterator, 0);
filename = std::string(buffer);
g_free(buffer);
// append a trailing slash if the name is a directory
if (fs::is_directory(filename))
filename.push_back('/');
out.push_back(filename);
iterator = g_slist_next(iterator);
}
g_slist_free(filenames);
}
gtk_widget_destroy(dialog);
// call the callback with the results
cb(out);
}
/* returns a result code following this schema:
* 0 = user responses "don't overwrite" to a confirm dialog
* 1 = old file was the same as the new one and user responses "yes, overwrite"
* 2 = old file wasn't the same (implicit overwrite)
*/
static int overwrite_result(char* path, GtkWidget* parent) {
gboolean oldfile_access = g_file_test(path, G_FILE_TEST_IS_REGULAR);
if ( (bimp_alertoverwrite == BIMP_ASK_OVERWRITE) && oldfile_access) {
GtkWidget *dialog;
GtkWidget *check_alertoverwrite;
GtkWidget *dialog_action;
dialog = gtk_message_dialog_new(
GTK_WINDOW(parent),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_NONE,
_("File %s already exists, overwrite it?"), bimp_comp_get_filename(path)
);
// Add checkbox "Always apply decision"
dialog_action = gtk_dialog_get_action_area(GTK_DIALOG(dialog));
check_alertoverwrite = gtk_check_button_new_with_label(_("Always apply this decision"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_alertoverwrite), FALSE);
gtk_box_pack_start (GTK_BOX(dialog_action), check_alertoverwrite, FALSE, FALSE, 0);
gtk_widget_show (check_alertoverwrite);
gtk_dialog_add_buttons (
GTK_DIALOG(dialog),
GTK_STOCK_YES, GTK_RESPONSE_YES,
GTK_STOCK_NO, GTK_RESPONSE_NO, NULL
);
gtk_window_set_title(GTK_WINDOW(dialog), _("Overwrite?"));
gint result = gtk_dialog_run(GTK_DIALOG(dialog));
gboolean dont_ask_anymore = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_alertoverwrite));
gtk_widget_destroy(dialog);
if (result == GTK_RESPONSE_YES) {
if (dont_ask_anymore)
bimp_alertoverwrite = BIMP_OVERWRITE_SKIP_ASK;
return 1;
}
else {
if (dont_ask_anymore)
bimp_alertoverwrite = BIMP_DONT_OVERWRITE_SKIP_ASK;
return 0;
}
}
else {
if (oldfile_access) {
return (bimp_alertoverwrite == BIMP_OVERWRITE_SKIP_ASK) ? 1 : 0;
}
else {
return 2;
}
}
}
GtkWidget *nsgtk_dialog_get_action_area(GtkDialog *dialog)
{
#if GTK_CHECK_VERSION(2,14,0)
return gtk_dialog_get_action_area(dialog);
#else
return dialog->action_area;
#endif
}
static void
mate_color_selection_dialog_init (MateColorSelectionDialog *colorseldiag)
{
GtkDialog *dialog = GTK_DIALOG (colorseldiag);
_mate_desktop_init_i18n ();
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (dialog)), 2); /* 2 * 5 + 2 = 12 */
gtk_container_set_border_width (GTK_CONTAINER (gtk_dialog_get_action_area (dialog)), 5);
gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_action_area (dialog)), 6);
colorseldiag->colorsel = mate_color_selection_new ();
gtk_container_set_border_width (GTK_CONTAINER (colorseldiag->colorsel), 5);
mate_color_selection_set_has_palette (MATE_COLOR_SELECTION(colorseldiag->colorsel), FALSE);
mate_color_selection_set_has_opacity_control (MATE_COLOR_SELECTION(colorseldiag->colorsel), FALSE);
gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (colorseldiag))), colorseldiag->colorsel);
gtk_widget_show (colorseldiag->colorsel);
colorseldiag->cancel_button = gtk_dialog_add_button (GTK_DIALOG (colorseldiag),
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
colorseldiag->ok_button = gtk_dialog_add_button (GTK_DIALOG (colorseldiag),
GTK_STOCK_OK,
GTK_RESPONSE_OK);
gtk_widget_grab_default (colorseldiag->ok_button);
colorseldiag->help_button = gtk_dialog_add_button (GTK_DIALOG (colorseldiag),
GTK_STOCK_HELP,
GTK_RESPONSE_HELP);
gtk_widget_hide (colorseldiag->help_button);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (colorseldiag),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
GTK_RESPONSE_HELP,
-1);
gtk_window_set_title (GTK_WINDOW (colorseldiag),
_("Color Selection"));
//_gtk_dialog_set_ignore_separator (dialog, TRUE);
}
static void configure(void)
{
GtkWidget *hbox, *label, *scale, *button, *bbox;
GtkAdjustment * adjustment;
if (conf_dialog != NULL)
return;
conf_dialog = gtk_dialog_new();
g_signal_connect (conf_dialog, "destroy", (GCallback)
gtk_widget_destroyed, & conf_dialog);
gtk_window_set_title(GTK_WINDOW(conf_dialog), _("Configure Crystalizer"));
label = gtk_label_new(_("Effect intensity:"));
gtk_box_pack_start ((GtkBox *) gtk_dialog_get_content_area
((GtkDialog *) conf_dialog), label, TRUE, TRUE, 0);
gtk_widget_show(label);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 10);
gtk_box_pack_start ((GtkBox *) gtk_dialog_get_content_area
((GtkDialog *) conf_dialog), hbox, TRUE, TRUE, 10);
gtk_widget_show(hbox);
adjustment = (GtkAdjustment *) gtk_adjustment_new (value, 0, 15 + 1,
0.1, 1, 1);
scale = gtk_scale_new(GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT(adjustment));
gtk_box_pack_start(GTK_BOX(hbox), scale, TRUE, TRUE, 10);
gtk_widget_show(scale);
bbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
gtk_box_pack_start ((GtkBox *) gtk_dialog_get_action_area ((GtkDialog *)
conf_dialog), bbox, TRUE, TRUE, 0);
button = gtk_button_new_with_label(_("Ok"));
gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start(GTK_BOX(bbox), button, TRUE, TRUE, 0);
g_signal_connect (button, "clicked", (GCallback) conf_ok_cb, adjustment);
gtk_widget_grab_default(button);
gtk_widget_show(button);
button = gtk_button_new_with_label(_("Cancel"));
gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start(GTK_BOX(bbox), button, TRUE, TRUE, 0);
g_signal_connect (button, "clicked", (GCallback) conf_cancel_cb, NULL);
gtk_widget_show(button);
button = gtk_button_new_with_label(_("Apply"));
gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start(GTK_BOX(bbox), button, TRUE, TRUE, 0);
g_signal_connect (button, "clicked", (GCallback) conf_apply_cb,
adjustment);
gtk_widget_show(button);
gtk_widget_show(bbox);
gtk_widget_show(conf_dialog);
}
/**
* e_charset_dialog:
* @title: title for the dialog box
* @prompt: prompt string for the dialog box
* @default_charset: as for e_charset_picker_new()
* @parent: a parent window for the dialog box, or %NULL
*
* This creates a new dialog box with the given @title and @prompt and
* a character set picker menu. It then runs the dialog and returns
* the selected character set, or %NULL if the user clicked "Cancel".
*
* Return value: the selected character set (which must be freed with
* g_free()), or %NULL.
**/
char *
e_charset_dialog (const char *title, const char *prompt,
const char *default_charset, GtkWindow *parent)
{
GtkDialog *dialog;
GtkWidget *label, *picker, *vbox, *hbox;
char *charset = NULL;
dialog = GTK_DIALOG (gtk_dialog_new_with_buttons (title,
parent,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL));
//gtk_dialog_set_has_separator (dialog, FALSE);
gtk_dialog_set_default_response (dialog, GTK_RESPONSE_OK);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area(dialog)), vbox, FALSE, FALSE, 0);
gtk_widget_show (vbox);
label = gtk_label_new (prompt);
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, FALSE, FALSE, 0);
gtk_widget_show (label);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
label = gtk_label_new ("");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
picker = e_charset_combo_box_new ();
e_charset_combo_box_set_charset (E_CHARSET_COMBO_BOX(picker), default_charset);
gtk_box_pack_start (GTK_BOX (hbox), picker, TRUE, TRUE, 0);
gtk_widget_show (picker);
gtk_container_set_border_width (GTK_CONTAINER (gtk_dialog_get_content_area(dialog)), 0);
gtk_container_set_border_width (GTK_CONTAINER (gtk_dialog_get_action_area(dialog)), 12);
gtk_widget_show_all (GTK_WIDGET (dialog));
g_object_ref (dialog);
if (gtk_dialog_run (dialog) == GTK_RESPONSE_OK)
charset = g_strdup (e_charset_combo_box_get_charset (E_CHARSET_COMBO_BOX(picker)));
gtk_widget_destroy (GTK_WIDGET (dialog));
g_object_unref (dialog);
return charset;
}
/** Creates a new dialog with a title and Ok and Cancel buttons.
Default texts are supplied for Ok and Cancel buttons if NULL.
Returns the created dialog and sets the two widget pointers.
This function does not call gtk_widget_show(), do
gtk_widget_show_all() when all has been added.
*/
GtkWidget *
dialog_make(char *title, char *okay_text, char *cancel_text,
GtkWidget **okay_button, GtkWidget **cancel_button) {
GtkWidget *dialog = gtk_dialog_new();
GtkWidget *label = gtk_label_new(title);
gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), label);
*okay_button = gtk_button_new_with_label((okay_text!=NULL?okay_text:_("OK")));
*cancel_button = gtk_button_new_with_label((cancel_text!=NULL?cancel_text:_("Cancel")));
gtk_container_add(GTK_CONTAINER(gtk_dialog_get_action_area(GTK_DIALOG(dialog))),
*okay_button);
gtk_container_add(GTK_CONTAINER(gtk_dialog_get_action_area(GTK_DIALOG(dialog))),
*cancel_button);
return dialog;
}
static dialog_t *edit_dialog_new (int ci, const char *title,
void (*okfunc)(), void *data,
int helpcode, GtkWidget *parent,
int *canceled)
{
dialog_t *d = mymalloc(sizeof *d);
if (d == NULL) {
return NULL;
}
d->ci = ci;
d->okfunc = okfunc;
d->data = data;
d->opt = OPT_NONE;
d->popup = NULL;
d->blocking = 0;
d->cancel = canceled;
d->dialog = gtk_dialog_new();
d->vbox = gtk_dialog_get_content_area(GTK_DIALOG(d->dialog));
d->bbox = gtk_dialog_get_action_area(GTK_DIALOG(d->dialog));
if (canceled != NULL) {
*canceled = 1; /* will be undone by "OK" */
d->blocking = 1;
}
if (!strncmp(title, "gretl", 5)) {
gtk_window_set_title(GTK_WINDOW(d->dialog), title);
} else {
gchar *tmp = g_strdup_printf("gretl: %s", title);
gtk_window_set_title(GTK_WINDOW(d->dialog), tmp);
g_free(tmp);
}
gtk_box_set_homogeneous(GTK_BOX(d->bbox), TRUE);
gtk_window_set_position(GTK_WINDOW(d->dialog), GTK_WIN_POS_MOUSE);
if (parent == NULL) {
parent = mdata->main;
}
g_signal_connect(G_OBJECT(d->dialog), "destroy",
G_CALLBACK(destroy_edit_dialog), d);
g_signal_connect(G_OBJECT(d->dialog), "key-press-event",
G_CALLBACK(esc_kills_window), NULL);
g_signal_connect(G_OBJECT(d->dialog), "show",
G_CALLBACK(gretl_dialog_set_destruction), parent);
if (d->blocking) {
g_signal_connect(G_OBJECT(d->dialog), "show",
G_CALLBACK(gtk_main), NULL);
}
return d;
}
// ---- choice dialog without text entry
gint gx_nchoice_dialog_without_entry(
const char* window_title,
const char* msg,
const guint nchoice,
const char* label[],
const gint resp[],
const gint default_response,
Glib::RefPtr<Gdk::Pixbuf> gw_ib) {
GtkWidget* dialog = gtk_dialog_new();
GtkWidget* text_label = gtk_label_new(msg);
GtkWidget* image = gtk_image_new_from_pixbuf(gw_ib->gobj());
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), text_label);
GdkColor colorGreen;
gdk_color_parse("#e1e1ed", &colorGreen);
gtk_widget_modify_fg(text_label, GTK_STATE_NORMAL, &colorGreen);
GdkColor colorBlack;
gdk_color_parse("#10101e", &colorBlack);
gtk_widget_modify_bg(dialog, GTK_STATE_NORMAL, &colorBlack);
g_signal_connect(GTK_DIALOG(dialog)->vbox, "expose-event",
G_CALLBACK(gx_cairo::start_box_expose), NULL);
gtk_widget_set_redraw_on_allocate(GTK_WIDGET(GTK_DIALOG(dialog)->vbox),true);
GtkStyle* text_style = gtk_widget_get_style(text_label);
pango_font_description_set_size(text_style->font_desc, 10*PANGO_SCALE);
pango_font_description_set_weight(text_style->font_desc, PANGO_WEIGHT_BOLD);
gtk_widget_modify_font(text_label, text_style->font_desc);
gtk_container_add(GTK_CONTAINER(gtk_dialog_get_action_area(GTK_DIALOG(dialog))), image);
for (guint i = 0; i < nchoice; i++) {
GtkWidget* button =
gtk_dialog_add_button(GTK_DIALOG(dialog), label[i], resp[i]);
gdk_color_parse("#555555", &colorBlack);
gtk_widget_modify_bg(button, GTK_STATE_NORMAL, &colorBlack);
}
// set default
gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), default_response);
gtk_window_set_title(GTK_WINDOW(dialog), window_title);
gtk_widget_show(text_label);
gtk_widget_show(image);
gtk_window_set_keep_above(GTK_WINDOW(dialog), TRUE);
g_signal_connect(dialog, "map", G_CALLBACK(on_gx_nchoice_map), NULL);
// --- run dialog and check response
gint response = gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
return response;
}
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));
}
/**
* extended_error_dialog:
* @parent: (allow-none): The parent window to make this dialog transient for.
* @what_failed: a message describing what failed.
* @why_failed: a message describing why the failure occurred.
* @suggestions: a message suggesting actions the user can take to remedy the
* failure.
*
* Displays an error dialog with extra information. Based on code from
* Conglomerate. The messages can use Pango markup.
*/
void
extended_error_dialog(GtkWindow *parent, const char *what_failed, const char *why_failed, const char *suggestions)
{
GtkWidget *dialog, *vbox, *content_hbox, *action_area, *ok, *image, *label;
char *message;
g_return_if_fail(what_failed);
g_return_if_fail(why_failed);
g_return_if_fail(suggestions);
dialog = g_object_new(GTK_TYPE_DIALOG,
"border-width", 6,
"resizable", FALSE,
"has-separator", FALSE,
"transient-for", parent,
NULL);
vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
gtk_container_set_border_width(GTK_CONTAINER(vbox), 2);
content_hbox = gtk_hbox_new(FALSE, 12);
gtk_container_set_border_width(GTK_CONTAINER(content_hbox), 6);
image = gtk_image_new_from_stock(GTK_STOCK_DIALOG_ERROR, GTK_ICON_SIZE_DIALOG);
gtk_box_pack_start(GTK_BOX(content_hbox), image, FALSE, TRUE, 0);
gtk_misc_set_alignment(GTK_MISC(image), 0.5, 0);
message = g_strdup_printf("<span weight=\"bold\" size=\"larger\">%s</span>\n\n%s\n\n%s", what_failed, why_failed, suggestions);
label = g_object_new(GTK_TYPE_LABEL,
"label", message,
"use-markup", TRUE,
"justify", GTK_JUSTIFY_LEFT,
"wrap", TRUE,
"xalign", 0.5,
"yalign", 0.0,
NULL);
g_free(message);
gtk_box_pack_start(GTK_BOX(content_hbox), label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), content_hbox, TRUE, TRUE, 0);
action_area = gtk_dialog_get_action_area(GTK_DIALOG(dialog));
gtk_container_set_border_width(GTK_CONTAINER(action_area), 5);
gtk_button_box_set_layout(GTK_BUTTON_BOX(action_area), GTK_BUTTONBOX_END);
gtk_box_set_spacing(GTK_BOX(action_area), 10);
ok = gtk_button_new_from_stock(GTK_STOCK_OK);
gtk_dialog_add_action_widget(GTK_DIALOG(dialog), ok, GTK_RESPONSE_OK);
gtk_widget_set_can_default(ok, TRUE);
gtk_widget_show_all(dialog);
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
}
GtkWidget *gretl_dialog_new (const char *title, GtkWidget *parent,
unsigned char flags)
{
GtkWidget *d = gtk_dialog_new();
GtkWidget *ca, *aa;
if (title != NULL) {
gtk_window_set_title(GTK_WINDOW(d), title);
} else {
gtk_window_set_title(GTK_WINDOW(d), "gretl");
}
ca = gtk_dialog_get_content_area(GTK_DIALOG(d));
aa = gtk_dialog_get_action_area(GTK_DIALOG(d));
gtk_button_box_set_layout(GTK_BUTTON_BOX(aa), GTK_BUTTONBOX_END);
set_dialog_border_widths(ca, aa);
gtk_window_set_position(GTK_WINDOW(d), GTK_WIN_POS_MOUSE);
if (flags & GRETL_DLG_BLOCK) {
current_dialog = d;
}
if (flags & GRETL_DLG_MODAL) {
gretl_set_window_modal(d);
} else if (flags & GRETL_DLG_QUASI_MODAL) {
gretl_set_window_quasi_modal(d);
}
if (!(flags & GRETL_DLG_RESIZE)) {
gretl_dialog_set_resizeable(d, FALSE);
}
if (flags & GRETL_DLG_BLOCK) {
g_signal_connect(G_OBJECT(d), "destroy",
G_CALLBACK(dialog_unblock), NULL);
}
if (parent == NULL && mdata != NULL) {
parent = mdata->main;
}
if (parent != NULL) {
g_signal_connect(G_OBJECT(d), "realize", /* was "show" */
G_CALLBACK(gretl_dialog_set_destruction),
parent);
}
if (flags & GRETL_DLG_BLOCK) {
g_signal_connect(G_OBJECT(d), "show",
G_CALLBACK(gtk_main), NULL);
}
return d;
}
static void
test_dialog_basic (void)
{
GtkWidget *dialog;
dialog = gtk_dialog_new();
g_assert (GTK_IS_DIALOG (dialog));
g_assert (gtk_dialog_get_action_area (GTK_DIALOG (dialog)) != NULL);
g_assert (gtk_dialog_get_content_area (GTK_DIALOG (dialog)) != NULL);
gtk_widget_destroy (dialog);
}
static void
win_style_set_cb (GtkWidget *win)
{
GtkWidget *content_area, *action_area;
content_area = gtk_dialog_get_content_area (GTK_DIALOG (win));
action_area = gtk_dialog_get_action_area (GTK_DIALOG (win));
gtk_container_set_border_width (GTK_CONTAINER (content_area), 12);
gtk_box_set_spacing (GTK_BOX (content_area), 24);
gtk_container_set_border_width (GTK_CONTAINER (action_area), 0);
gtk_box_set_spacing (GTK_BOX (action_area), 6);
}
GtkBox *our_dialog_make_action_hbox(GtkWindow *dlg)
{
#if GTK_CHECK_VERSION(3,0,0)
GtkWidget *hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
our_dialog_set_action_area(dlg, hbox);
g_object_set(G_OBJECT(hbox), "margin", 0, (const char *)NULL);
g_object_set(G_OBJECT(hbox), "spacing", 8, (const char *)NULL);
gtk_widget_show(hbox);
return GTK_BOX(hbox);
#else /* not GTK 3 */
return GTK_BOX(gtk_dialog_get_action_area(GTK_DIALOG(dlg)));
#endif
}
void our_dialog_set_action_area(GtkWindow *dlg, GtkWidget *w)
{
#if !GTK_CHECK_VERSION(2,0,0)
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dlg)->action_area),
w, TRUE, TRUE, 0);
#elif !GTK_CHECK_VERSION(3,0,0)
GtkWidget *align;
align = gtk_alignment_new(0, 0, 1, 1);
gtk_container_add(GTK_CONTAINER(align), w);
/*
* The purpose of this GtkAlignment is to provide padding
* around the buttons. The padding we use is twice the padding
* used in our GtkColumns, because we nest two GtkColumns most
* of the time (one separating the tree view from the main
* controls, and another for the main controls themselves).
*/
#if GTK_CHECK_VERSION(2,4,0)
gtk_alignment_set_padding(GTK_ALIGNMENT(align), 8, 8, 8, 8);
#endif
gtk_widget_show(align);
gtk_box_pack_end(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dlg))),
align, FALSE, TRUE, 0);
w = gtk_hseparator_new();
gtk_box_pack_end(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dlg))),
w, FALSE, TRUE, 0);
gtk_widget_show(w);
gtk_widget_hide(gtk_dialog_get_action_area(GTK_DIALOG(dlg)));
g_object_set(G_OBJECT(dlg), "has-separator", TRUE, (const char *)NULL);
#else /* GTK 3 */
/* GtkWindow is a GtkBin, hence contains exactly one child, which
* here we always expect to be a vbox */
GtkBox *vbox = GTK_BOX(gtk_bin_get_child(GTK_BIN(dlg)));
GtkWidget *sep;
g_object_set(G_OBJECT(w), "margin", 8, (const char *)NULL);
gtk_box_pack_end(vbox, w, FALSE, TRUE, 0);
sep = gtk_hseparator_new();
gtk_box_pack_end(vbox, sep, FALSE, TRUE, 0);
gtk_widget_show(sep);
#endif
}
static void build_dwiz_buttons (GtkWidget *dlg, DATASET *dwinfo)
{
GtkWidget *hbox = gtk_dialog_get_action_area(GTK_DIALOG(dlg));
GtkWidget *b;
/* "Cancel" button */
b = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
g_object_set_data(G_OBJECT(b), "dlg", dlg);
g_signal_connect(G_OBJECT(b), "clicked",
G_CALLBACK(dwiz_cancel),
dwinfo);
gtk_container_add(GTK_CONTAINER(hbox), b);
g_object_set_data(G_OBJECT(dlg), "cancel", b);
/* "Back" button */
b = gtk_button_new_from_stock(GTK_STOCK_GO_BACK);
g_object_set_data(G_OBJECT(b), "dlg", dlg);
g_signal_connect(G_OBJECT(b), "clicked",
G_CALLBACK(dwiz_back),
dlg);
gtk_container_add(GTK_CONTAINER(hbox), b);
g_object_set_data(G_OBJECT(dlg), "back", b);
/* "Forward" button */
b = gtk_button_new_from_stock(GTK_STOCK_GO_FORWARD);
g_object_set_data(G_OBJECT(b), "dlg", dlg);
g_signal_connect(G_OBJECT(b), "clicked",
G_CALLBACK(dwiz_forward),
dlg);
gtk_container_add(GTK_CONTAINER(hbox), b);
g_object_set_data(G_OBJECT(dlg), "forward", b);
/* "Apply" button */
b = gtk_button_new_from_stock(GTK_STOCK_APPLY);
g_object_set_data(G_OBJECT(b), "dlg", dlg);
g_signal_connect(G_OBJECT(b), "clicked",
G_CALLBACK(dwiz_apply),
dwinfo);
gtk_container_add(GTK_CONTAINER(hbox), b);
g_object_set_data(G_OBJECT(dlg), "apply", b);
/* Help button for panel mode selection */
b = context_help_button(hbox, PANEL_MODE);
g_object_set_data(G_OBJECT(dlg), "help", b);
}
static void _check_arrows (AtkObject *obj)
{
GtkWidget *content_area, *action_area;
AtkRole role;
MainDialog *md;
static gint visibleDialog = 0;
role = atk_object_get_role(obj);
if(role == ATK_ROLE_FRAME) {
md = (MainDialog *) malloc (sizeof(MainDialog));
if (visibleDialog == 0)
{
md->arrow1 = gtk_arrow_new(GTK_ARROW_UP,GTK_SHADOW_IN);
md->arrow2 = gtk_arrow_new(GTK_ARROW_DOWN,GTK_SHADOW_IN);
md->arrow3 = gtk_arrow_new(GTK_ARROW_LEFT,GTK_SHADOW_OUT);
md->arrow4 = gtk_arrow_new(GTK_ARROW_RIGHT,GTK_SHADOW_OUT);
md->dialog = gtk_dialog_new();
gtk_window_set_modal(GTK_WINDOW(md->dialog), TRUE);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (md->dialog));
action_area = gtk_dialog_get_action_area (GTK_DIALOG (md->dialog));
gtk_box_pack_start(GTK_BOX (content_area), md->arrow1, TRUE,TRUE, 0);
gtk_box_pack_start(GTK_BOX (content_area), md->arrow2, TRUE,TRUE, 0);
gtk_box_pack_start(GTK_BOX (content_area), md->arrow3, TRUE,TRUE, 0);
gtk_box_pack_start(GTK_BOX (content_area), md->arrow4, TRUE,TRUE, 0);
g_signal_connect(md->dialog, "destroy",
G_CALLBACK (destroy), md->dialog);
md->image = GTK_IMAGE(gtk_image_new_from_file("circles.xbm"));
gtk_box_pack_start(GTK_BOX (content_area), GTK_WIDGET(md->image), TRUE,TRUE, 0);
md->close_button = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
g_signal_connect(md->close_button, "clicked",
G_CALLBACK (destroy), md->dialog);
gtk_box_pack_start(GTK_BOX (action_area), md->close_button, TRUE,TRUE, 0);
gtk_widget_show_all(md->dialog);
visibleDialog = 1;
}
}
}
GtkWidget *
ca_trust_dialog_show (ECert *cert,
gboolean importing)
{
CATrustDialogData *ctd_data;
GtkDialog *dialog;
GtkWidget *action_area;
GtkWidget *content_area;
GtkWidget *w;
gchar *txt;
ctd_data = g_new0 (CATrustDialogData, 1);
ctd_data->builder = gtk_builder_new ();
e_load_ui_builder_definition (ctd_data->builder, "smime-ui.ui");
ctd_data->dialog = e_builder_get_widget (ctd_data->builder, "ca-trust-dialog");
gtk_widget_ensure_style (ctd_data->dialog);
dialog = GTK_DIALOG (ctd_data->dialog);
action_area = gtk_dialog_get_action_area (dialog);
content_area = gtk_dialog_get_content_area (dialog);
gtk_container_set_border_width (GTK_CONTAINER (action_area), 12);
gtk_container_set_border_width (GTK_CONTAINER (content_area), 0);
ctd_data->cert = g_object_ref (cert);
ctd_data->ssl_checkbutton = e_builder_get_widget (ctd_data->builder, "ssl_trust_checkbutton");
ctd_data->email_checkbutton = e_builder_get_widget (ctd_data->builder, "email_trust_checkbutton");
ctd_data->objsign_checkbutton = e_builder_get_widget (ctd_data->builder, "objsign_trust_checkbutton");
w = e_builder_get_widget(ctd_data->builder, "ca-trust-label");
txt = g_strdup_printf(_("Certificate '%s' is a CA certificate.\n\nEdit trust settings:"), e_cert_get_cn(cert));
gtk_label_set_text ((GtkLabel *) w, txt);
g_free (txt);
g_signal_connect (ctd_data->dialog, "response", G_CALLBACK (catd_response), ctd_data);
g_object_set_data_full (G_OBJECT (ctd_data->dialog), "CATrustDialogData", ctd_data, free_data);
return ctd_data->dialog;
}
DateDialog::DateDialog(guint32 * seconds_since_epoch, GtkWindow *transient_parent, bool showtime) :
datewidget (seconds_since_epoch, showtime)
/*
By default this dialog shows the calendar only.
If showtime is true it shows the time also.
*/
{
// Store variabeles.
my_seconds_since_epoch = seconds_since_epoch;
myshowtime = showtime;
datedialog = gtk_dialog_new();
gtk_window_set_transient_for(GTK_WINDOW(datedialog), transient_parent);
gtk_window_set_title(GTK_WINDOW(datedialog), _("Date"));
//gtk_window_set_position(GTK_WINDOW(datedialog), GTK_WIN_POS_CENTER_ON_PARENT);
gtk_window_set_type_hint(GTK_WINDOW(datedialog), GDK_WINDOW_TYPE_HINT_DIALOG);
dialog_vbox1 = gtk_dialog_get_content_area (GTK_DIALOG(datedialog));
gtk_widget_show(dialog_vbox1);
gtk_box_pack_start(GTK_BOX(dialog_vbox1), datewidget.hbox, TRUE, TRUE, 0);
dialog_action_area1 = gtk_dialog_get_action_area (GTK_DIALOG(datedialog));
gtk_widget_show(dialog_action_area1);
gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area1), GTK_BUTTONBOX_END);
new InDialogHelp(datedialog, NULL, NULL, NULL);
cancelbutton1 = gtk_button_new_from_stock("gtk-cancel");
gtk_widget_show(cancelbutton1);
gtk_dialog_add_action_widget(GTK_DIALOG(datedialog), cancelbutton1, GTK_RESPONSE_CANCEL);
gtk_widget_set_can_default (GTK_WIDGET (cancelbutton1), true);
okbutton1 = gtk_button_new_from_stock("gtk-ok");
gtk_widget_show(okbutton1);
gtk_dialog_add_action_widget(GTK_DIALOG(datedialog), okbutton1, GTK_RESPONSE_OK);
gtk_widget_set_can_default (GTK_WIDGET (okbutton1), true);
g_signal_connect((gpointer) okbutton1, "clicked", G_CALLBACK(on_okbutton_clicked), gpointer(this));
gtk_widget_grab_default(okbutton1);
}
/**
* set_buttons:
* @self: a pointer to a GamesScoresDialog
* @buttons: An or-ed list of GamesScoresButtons
*
* Changes the button sets at the buttom of the dialog
*
**/
void games_scores_dialog_set_buttons (GamesScoresDialog *self, guint buttons)
{
/* Remove an existing buttons. */
gtk_container_foreach (GTK_CONTAINER (gtk_dialog_get_action_area (GTK_DIALOG (self))),
(GtkCallback) (gtk_widget_destroy), NULL);
/* The default is a single close button, suitable for the scores
menu item. */
if (buttons == 0)
buttons = GAMES_SCORES_CLOSE_BUTTON;
if (buttons & GAMES_SCORES_QUIT_BUTTON) {
gtk_dialog_add_button (GTK_DIALOG (self), _("_Quit"),
GTK_RESPONSE_REJECT);
gtk_dialog_set_default_response (GTK_DIALOG (self),
GTK_RESPONSE_REJECT);
}
if (buttons & GAMES_SCORES_UNDO_BUTTON) {
gtk_dialog_add_button (GTK_DIALOG (self), _("_Undo"),
GTK_RESPONSE_DELETE_EVENT);
gtk_dialog_set_default_response (GTK_DIALOG (self),
GTK_RESPONSE_DELETE_EVENT);
}
if (buttons & GAMES_SCORES_NEW_GAME_BUTTON) {
gtk_dialog_add_button (GTK_DIALOG (self), _("_New Game"),
GTK_RESPONSE_ACCEPT);
gtk_dialog_set_default_response (GTK_DIALOG (self),
GTK_RESPONSE_ACCEPT);
}
if (buttons & GAMES_SCORES_CLOSE_BUTTON) {
gtk_dialog_add_button (GTK_DIALOG (self), _("_Close"),
GTK_RESPONSE_CLOSE);
gtk_dialog_set_default_response (GTK_DIALOG (self),
GTK_RESPONSE_CLOSE);
}
}
