static void
startMovingNextTorrent( struct relocate_dialog_data * data )
{
char * str;
const int id = GPOINTER_TO_INT( data->torrent_ids->data );
tr_session * session = tr_core_session( data->core );
tr_torrent * tor = tr_torrentFindFromId( session, id );
if( tor != NULL )
tr_torrentSetLocation( tor, previousLocation, data->do_move, NULL, &data->done );
data->torrent_ids = g_slist_delete_link( data->torrent_ids,
data->torrent_ids );
str = g_strdup_printf( _( "Moving \"%s\"" ), tr_torrentInfo(tor)->name );
gtk_message_dialog_set_markup( GTK_MESSAGE_DIALOG( data->message_dialog ), str );
g_free( str );
}
static void
wm_unsupported ()
{
GtkWidget *no_tool_dialog;
no_tool_dialog = gtk_message_dialog_new (NULL,
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
" ");
gtk_window_set_title (GTK_WINDOW (no_tool_dialog), "");
gtk_window_set_resizable (GTK_WINDOW (no_tool_dialog), FALSE);
gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (no_tool_dialog), _("The current window manager is unsupported"));
gtk_dialog_run (GTK_DIALOG (no_tool_dialog));
gtk_widget_destroy (no_tool_dialog);
}
/**
*初始化右边主界面,所有不可见
*@param str如果不为空，则弹出框显示str信息
*/
void init_right_main_view_hide_all(const char *str) {
if(str != NULL) {
dialog = gtk_message_dialog_new(GTK_WINDOW(mainWindow),
GTK_DIALOG_MODAL,
GTK_MESSAGE_INFO,
GTK_BUTTONS_OK,
str);
gtk_message_dialog_set_markup(GTK_MESSAGE_DIALOG(dialog),str);
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
}
gtk_entry_set_text(GTK_ENTRY(contentTitleEntry),"");
gtk_text_buffer_set_text(textBuffer,"",0);
gtk_text_view_set_buffer(GTK_TEXT_VIEW(contentContentTextView),textBuffer);
gtk_widget_hide(contentTitleEntry);
gtk_widget_hide(contentContentTextView);
gtk_widget_hide(saveButton);
gtk_widget_hide(deleteButton);
gtk_widget_hide(modifyButton);
}
void on_main_set_filter_button_clicked(GtkWidget * gw, gpointer data)
{
GtkEntry *filter_entry;
gchar *filter_rule;
filter_entry =
GTK_ENTRY(gtk_builder_get_object(builder, "main_filter_entry"));
filter_rule =
gtk_entry_buffer_get_text(gtk_entry_get_buffer(filter_entry));
sprintf(bpf_filter_str, "%s", filter_rule);
/*
* 预编译规则，检测书写是否正确
*/
pcap_t *handle;
char error_content[PCAP_ERRBUF_SIZE];
int ret;
struct bpf_program bpf_filter;
bpf_u_int32 net_mask;
bpf_u_int32 net_ip;
pcap_lookupnet(select_dev, &net_ip, &net_mask, error_content);
handle = pcap_open_live("eth0", BUFSIZ, 1, 0, error_content);
ret = pcap_compile(handle, &bpf_filter, bpf_filter_str, 0, net_ip);
if (-1 == ret) {
g_print("%s 不符合规则\n", bpf_filter_str);
GtkWidget *dialog;
dialog = gtk_message_dialog_new(NULL, GTK_RESPONSE_OK,
GTK_MESSAGE_OTHER,
GTK_BUTTONS_OK, NULL);
gtk_message_dialog_set_markup((GtkMessageDialog *)
dialog,
"<span foreground=\"red\" size=\"x-large\">:) 过滤规则书写不正确</span>");
gtk_window_set_title(GTK_WINDOW(dialog), "Set Filter rule");
gtk_dialog_run((GtkDialog *) dialog); // show the dialog
gtk_widget_destroy(dialog);
}
}
static void
show_sql (G_GNUC_UNUSED GtkButton *button, DemoData *data)
{
GdaServerProvider *prov;
if (!data->op)
return;
prov = get_provider_obj (data);
if (prov) {
gchar *sql, *msg;
GtkMessageType msg_type = GTK_MESSAGE_INFO;
GtkWidget *dlg;
GError *error = NULL;
sql = gda_server_provider_render_operation (prov, NULL, data->op, &error);
if (!sql) {
msg_type = GTK_MESSAGE_ERROR;
msg = g_strdup_printf ("<b>Can't render operation as SQL:</b>\n%s\n",
error && error->message ? error->message :
"No detail (This operation may not be accessible using SQL)");
if (error)
g_error_free (error);
}
else
msg = g_strdup_printf ("<b>SQL:</b>\n%s", sql);
dlg = gtk_message_dialog_new (GTK_WINDOW (data->top_window),
GTK_DIALOG_MODAL, msg_type, GTK_BUTTONS_CLOSE, NULL);
gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (dlg), msg);
g_free (sql);
g_free (msg);
gtk_dialog_run (GTK_DIALOG (dlg));
gtk_widget_destroy (dlg);
}
else
g_warning ("Could not get provider object");
}
static void
empathy_password_dialog_constructed (GObject *object)
{
EmpathyPasswordDialog *dialog;
EmpathyPasswordDialogPriv *priv;
TpAccount *account;
GtkWidget *icon;
GtkBox *box;
gchar *text;
dialog = EMPATHY_PASSWORD_DIALOG (object);
priv = dialog->priv;
g_assert (priv->handler != NULL);
priv->grabbing = FALSE;
account = empathy_server_sasl_handler_get_account (priv->handler);
tp_g_signal_connect_object (priv->handler, "invalidated",
G_CALLBACK (password_dialog_handler_invalidated_cb),
object, 0);
/* dialog */
gtk_dialog_add_button (GTK_DIALOG (dialog),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
priv->ok_button = gtk_dialog_add_button (GTK_DIALOG (dialog),
GTK_STOCK_OK, GTK_RESPONSE_OK);
gtk_widget_set_sensitive (priv->ok_button, FALSE);
text = g_strdup_printf (_("Enter your password for account\n<b>%s</b>"),
tp_account_get_display_name (account));
gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (dialog), text);
g_free (text);
gtk_window_set_icon_name (GTK_WINDOW (dialog),
GTK_STOCK_DIALOG_AUTHENTICATION);
box = GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog)));
/* dialog icon */
icon = gtk_image_new_from_icon_name (tp_account_get_icon_name (account),
GTK_ICON_SIZE_DIALOG);
gtk_message_dialog_set_image (GTK_MESSAGE_DIALOG (dialog), icon);
gtk_widget_show (icon);
/* entry */
priv->entry = gtk_entry_new ();
gtk_entry_set_visibility (GTK_ENTRY (priv->entry), FALSE);
/* entry clear icon */
gtk_entry_set_icon_from_stock (GTK_ENTRY (priv->entry),
GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_CLEAR);
gtk_entry_set_icon_sensitive (GTK_ENTRY (priv->entry),
GTK_ENTRY_ICON_SECONDARY, FALSE);
g_signal_connect (priv->entry, "icon-release",
G_CALLBACK (clear_icon_released_cb), NULL);
g_signal_connect (priv->entry, "changed",
G_CALLBACK (password_entry_changed_cb), dialog);
g_signal_connect (priv->entry, "activate",
G_CALLBACK (password_entry_activate_cb), dialog);
gtk_box_pack_start (box, priv->entry, FALSE, FALSE, 0);
gtk_widget_show (priv->entry);
/* remember password ticky box */
priv->ticky = gtk_check_button_new_with_label (_("Remember password"));
gtk_box_pack_start (box, priv->ticky, FALSE, FALSE, 0);
/* only show it if we actually support it */
if (empathy_server_sasl_handler_can_save_response_somewhere (priv->handler))
gtk_widget_show (priv->ticky);
g_signal_connect (dialog, "response",
G_CALLBACK (password_dialog_response_cb), dialog);
g_signal_connect (dialog, "window-state-event",
G_CALLBACK (password_dialog_window_state_changed), dialog);
g_signal_connect (dialog, "map-event",
G_CALLBACK (password_dialog_grab_keyboard), dialog);
g_signal_connect (dialog, "unmap-event",
G_CALLBACK (password_dialog_ungrab_keyboard), dialog);
gtk_widget_grab_focus (priv->entry);
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER_ALWAYS);
}
static GtkWidget *
csm_get_dialog (CsmDialogLogoutType type,
GdkScreen *screen,
guint32 activate_time)
{
CsmLogoutDialog *logout_dialog;
GtkWidget *hbox;
const char *primary_text;
const char *icon_name;
if (current_dialog != NULL) {
gtk_widget_destroy (GTK_WIDGET (current_dialog));
}
logout_dialog = g_object_new (CSM_TYPE_LOGOUT_DIALOG, NULL);
current_dialog = logout_dialog;
gtk_window_set_title (GTK_WINDOW (logout_dialog), _("Session"));
logout_dialog->priv->type = type;
GSettings *settings = g_settings_new (SESSION_SCHEMA);
logout_dialog->priv->delay_toggle = g_settings_get_boolean (settings, KEY_TOGGLE_DELAY);
logout_dialog->priv->delay = g_settings_get_int (settings, KEY_DELAY);
icon_name = NULL;
primary_text = NULL;
switch (type) {
case CSM_DIALOG_LOGOUT_TYPE_LOGOUT:
icon_name = CSM_ICON_LOGOUT;
primary_text = _("Log out of this system now?");
logout_dialog->priv->default_response = CSM_LOGOUT_RESPONSE_LOGOUT;
if (csm_logout_supports_switch_user (logout_dialog)) {
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
_("_Switch User"),
CSM_LOGOUT_RESPONSE_SWITCH_USER);
}
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
_("_Cancel"),
GTK_RESPONSE_CANCEL);
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
_("_Log Out"),
CSM_LOGOUT_RESPONSE_LOGOUT);
break;
case CSM_DIALOG_LOGOUT_TYPE_SHUTDOWN:
icon_name = CSM_ICON_SHUTDOWN;
primary_text = _("Shut down this system now?");
logout_dialog->priv->default_response = CSM_LOGOUT_RESPONSE_SHUTDOWN;
if (csm_system_can_suspend (logout_dialog->priv->system)) {
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
_("S_uspend"),
CSM_LOGOUT_RESPONSE_SLEEP);
}
if (csm_system_can_hibernate (logout_dialog->priv->system)) {
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
_("_Hibernate"),
CSM_LOGOUT_RESPONSE_HIBERNATE);
}
if (csm_logout_supports_reboot (logout_dialog)) {
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
_("_Restart"),
CSM_LOGOUT_RESPONSE_REBOOT);
}
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
_("_Cancel"),
GTK_RESPONSE_CANCEL);
if (csm_logout_supports_shutdown (logout_dialog)) {
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
_("_Shut Down"),
CSM_LOGOUT_RESPONSE_SHUTDOWN);
}
break;
case CSM_DIALOG_LOGOUT_TYPE_REBOOT:
icon_name = CSM_ICON_SHUTDOWN;
primary_text = _("Restart this system now?");
logout_dialog->priv->default_response = CSM_LOGOUT_RESPONSE_REBOOT;
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
_("_Cancel"),
GTK_RESPONSE_CANCEL);
if (csm_logout_supports_reboot (logout_dialog)) {
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
_("_Restart"),
CSM_LOGOUT_RESPONSE_REBOOT);
}
break;
default:
g_assert_not_reached ();
}
if (logout_dialog->priv->delay_toggle) {
hbox = gtk_box_new (FALSE, 0);
logout_dialog->priv->progressbar = gtk_progress_bar_new ();
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (logout_dialog->priv->progressbar), 1.0);
gtk_box_pack_start (GTK_BOX (hbox),
logout_dialog->priv->progressbar,
TRUE, TRUE, 12);
gtk_widget_show_all (hbox);
gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (logout_dialog))), hbox);
}
gtk_window_set_icon_name (GTK_WINDOW (logout_dialog), icon_name);
gtk_window_set_position (GTK_WINDOW (logout_dialog), GTK_WIN_POS_CENTER);
gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (logout_dialog), primary_text);
gtk_dialog_set_default_response (GTK_DIALOG (logout_dialog),
logout_dialog->priv->default_response);
gtk_window_set_screen (GTK_WINDOW (logout_dialog), screen);
g_object_unref(settings);
return GTK_WIDGET (logout_dialog);
}
static VALUE
rg_set_markup(VALUE self, VALUE str)
{
gtk_message_dialog_set_markup(_SELF(self), RVAL2CSTR(str));
return self;
}
static int run_ask_yes_no_save_generic_result_dialog(ask_yes_no_dialog_flags flags,
const char *key,
const char *message,
GtkWindow *parent)
{
INITIALIZE_LIBREPORT();
const char *ask_result = get_user_setting(key);
if (ask_result)
{
const bool ret = string_to_bool(ask_result);
if (!(flags & ASK_YES_NO__YESFOREVER))
return ret;
/* ASK_YES_NO__YESFOREVER */
if (ret == false)
/* Do you want to be asked? -> No, I don't. Do whatever you want */
return true;
/* CONTINUE becuase saved value is "yes" and it means 'Ask me!' */
}
GtkWidget *dialog = gtk_message_dialog_new(parent,
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_NONE,
"%s", message);
/* let's try to use the text as markup
* this allows us to use hyperlinks to man pages */
gtk_message_dialog_set_markup(GTK_MESSAGE_DIALOG(dialog), message);
/* Follow GTK3's yes-no-buttons order:
* [No] [Yes]
*/
GtkWidget *no_button = gtk_dialog_add_button(GTK_DIALOG(dialog), _("_No"), GTK_RESPONSE_NO);
gtk_dialog_add_button(GTK_DIALOG(dialog), _("_Yes"), GTK_RESPONSE_YES);
gint response = GTK_RESPONSE_NO;
g_signal_connect(G_OBJECT(dialog), "response",
G_CALLBACK(save_dialog_response), &response);
GtkWidget *ask_yes_no_cb = gtk_check_button_new_with_label(_("Don't ask me again"));
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))),
ask_yes_no_cb, TRUE, TRUE, 0);
if (flags & ASK_YES_NO__YESFOREVER)
{
/* Don't check the box by default. If the box is checked the 'No'
* button is disabled and we don't want to force users to click on
* 'Yes' button. */
g_signal_connect(ask_yes_no_cb, "toggled",
G_CALLBACK(on_toggle_ask_yes_no_yesforever_cb), (gpointer)no_button);
}
/* Esc -> No, Enter -> Yes */
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_YES);
gtk_widget_show(ask_yes_no_cb);
gtk_dialog_run(GTK_DIALOG(dialog));
if (flags & ASK_YES_NO__YESFOREVER)
/* the box is checked -> Don't ask me again and my response is always 'Yes' */
set_user_setting(key, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ask_yes_no_cb)) ? "no" : "yes");
else if (flags & ASK_YES_NO__SAVE_RESULT)
{
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ask_yes_no_cb)))
/* the box is checked -> remember my current answer */
set_user_setting(key, response == GTK_RESPONSE_YES ? "yes" : "no");
}
else /* should not happen */
error_msg("BUG:%s:%d %s() unknown type (0x%x) of ask_yes_no dialog",
__FILE__, __LINE__, __func__, flags);
gtk_widget_destroy(dialog);
return response == GTK_RESPONSE_YES;
}
static GtkWidget *
gsm_get_dialog (GsmDialogLogoutType type,
GdkScreen *screen,
guint32 activate_time)
{
GsmLogoutDialog *logout_dialog;
GtkWidget *dialog_image;
GtkWidget *hbox;
const char *primary_text;
const char *icon_name;
if (current_dialog != NULL) {
gtk_widget_destroy (GTK_WIDGET (current_dialog));
}
logout_dialog = g_object_new (GSM_TYPE_LOGOUT_DIALOG, NULL);
current_dialog = logout_dialog;
gtk_window_set_title (GTK_WINDOW (logout_dialog), "");
logout_dialog->priv->type = type;
icon_name = NULL;
primary_text = NULL;
switch (type) {
case GSM_DIALOG_LOGOUT_TYPE_LOGOUT:
icon_name = GSM_ICON_LOGOUT;
primary_text = _("Log out of this system now?");
logout_dialog->priv->default_response = GSM_LOGOUT_RESPONSE_LOGOUT;
if (gsm_logout_supports_switch_user (logout_dialog)) {
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
_("_Switch User"),
GSM_LOGOUT_RESPONSE_SWITCH_USER);
}
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
_("_Log Out"),
GSM_LOGOUT_RESPONSE_LOGOUT);
break;
case GSM_DIALOG_LOGOUT_TYPE_SHUTDOWN:
icon_name = GSM_ICON_SHUTDOWN;
primary_text = _("Shut down this system now?");
logout_dialog->priv->default_response = GSM_LOGOUT_RESPONSE_SHUTDOWN;
if (gsm_logout_supports_system_suspend (logout_dialog)) {
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
_("S_uspend"),
GSM_LOGOUT_RESPONSE_SLEEP);
}
if (gsm_logout_supports_system_hibernate (logout_dialog)) {
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
_("_Hibernate"),
GSM_LOGOUT_RESPONSE_HIBERNATE);
}
if (gsm_logout_supports_reboot (logout_dialog)) {
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
_("_Restart"),
GSM_LOGOUT_RESPONSE_REBOOT);
}
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
if (gsm_logout_supports_shutdown (logout_dialog)) {
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
_("_Shut Down"),
GSM_LOGOUT_RESPONSE_SHUTDOWN);
}
break;
default:
g_assert_not_reached ();
}
dialog_image = gtk_message_dialog_get_image (GTK_MESSAGE_DIALOG (logout_dialog));
#if GTK_CHECK_VERSION (3, 0, 0)
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
#else
hbox = gtk_hbox_new (FALSE, 0);
#endif
logout_dialog->priv->progressbar = gtk_progress_bar_new ();
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_progress_bar_set_show_text (GTK_PROGRESS_BAR (logout_dialog->priv->progressbar), TRUE);
#endif
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (logout_dialog->priv->progressbar), 1.0);
gtk_box_pack_start (GTK_BOX (hbox),
logout_dialog->priv->progressbar,
TRUE, TRUE, 12);
gtk_widget_show_all (hbox);
gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (logout_dialog))), hbox);
gtk_image_set_from_icon_name (GTK_IMAGE (dialog_image),
icon_name, GTK_ICON_SIZE_DIALOG);
gtk_window_set_icon_name (GTK_WINDOW (logout_dialog), icon_name);
gtk_window_set_position (GTK_WINDOW (logout_dialog), GTK_WIN_POS_CENTER_ALWAYS);
gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (logout_dialog), primary_text);
gtk_dialog_set_default_response (GTK_DIALOG (logout_dialog),
logout_dialog->priv->default_response);
gtk_window_set_screen (GTK_WINDOW (logout_dialog), screen);
return GTK_WIDGET (logout_dialog);
}
static void
delete_button_clicked (GtkWidget *button, GtrPreferencesDialog *dlg)
{
GtkTreeIter iter;
GtkTreeModel *model;
GtkTreeSelection *selection;
gboolean active;
GtkWidget *dialog;
gchar *markup;
model = gtk_tree_view_get_model (GTK_TREE_VIEW (dlg->priv->profile_treeview));
g_return_if_fail (model != NULL);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dlg->priv->profile_treeview));
if (gtk_tree_selection_get_selected (selection, &model, &iter))
{
gtk_tree_model_get (model, &iter, ACTIVE_PROFILE_COLUMN, &active, -1);
if (active)
{
dialog = gtk_message_dialog_new (GTK_WINDOW (dlg),
GTK_DIALOG_MODAL,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE, NULL);
markup = g_strdup_printf("<span weight=\"bold\" size=\"large\">%s</span>",
_("Impossible to remove the active profile"));
gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (dialog), markup);
g_free(markup);
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG
(dialog),
_("Another profile should be selected as active before"));
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
}
else
{
dialog = gtk_message_dialog_new (GTK_WINDOW (dlg),
GTK_DIALOG_MODAL,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_NONE, NULL);
markup = g_strdup_printf("<span weight=\"bold\" size=\"large\">%s</span>",
_("Are you sure you want to delete this profile?"));
gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (dialog), markup);
g_free(markup);
gtk_dialog_add_button (GTK_DIALOG (dialog),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
gtk_dialog_add_button (GTK_DIALOG (dialog),
GTK_STOCK_DELETE, GTK_RESPONSE_YES);
gtk_dialog_run (GTK_DIALOG (dialog));
g_signal_connect (GTK_DIALOG (dialog), "response",
G_CALLBACK (delete_confirm_dialog_cb), dlg);
}
}
}
/* ---------------------------------------------- */
gint
ghid_dialog_close_confirm ()
{
GtkWidget *dialog;
gint rv;
GHidPort *out = &ghid_port;
gchar *tmp;
gchar *str;
if (PCB->Filename == NULL)
{
tmp = g_strdup_printf (
_("Save the changes to layout before closing?"));
} else {
tmp = g_strdup_printf (
_("Save the changes to layout \"%s\" before closing?"),
PCB->Filename);
}
str = g_strconcat ("<big><b>", tmp, "</b></big>", NULL);
g_free (tmp);
tmp = _("If you don't save, all your changes will be permanently lost.");
str = g_strconcat (str, "\n\n", tmp, NULL);
dialog = gtk_message_dialog_new (GTK_WINDOW (out->top_window),
(GtkDialogFlags)(GTK_DIALOG_MODAL |
GTK_DIALOG_DESTROY_WITH_PARENT),
GTK_MESSAGE_WARNING,
GTK_BUTTONS_NONE, NULL);
gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (dialog), str);
gtk_dialog_add_buttons (GTK_DIALOG (dialog),
_("Close _without saving"), GTK_RESPONSE_NO,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_YES,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_YES);
/* Set the alternative button order (ok, cancel, help) for other systems */
gtk_dialog_set_alternative_button_order(GTK_DIALOG(dialog),
GTK_RESPONSE_YES,
GTK_RESPONSE_NO,
GTK_RESPONSE_CANCEL,
-1);
switch (gtk_dialog_run (GTK_DIALOG (dialog)))
{
case GTK_RESPONSE_NO:
{
rv = GUI_DIALOG_CLOSE_CONFIRM_NOSAVE;
break;
}
case GTK_RESPONSE_YES:
{
rv = GUI_DIALOG_CLOSE_CONFIRM_SAVE;
break;
}
case GTK_RESPONSE_CANCEL:
default:
{
rv = GUI_DIALOG_CLOSE_CONFIRM_CANCEL;
break;
}
}
gtk_widget_destroy (dialog);
return rv;
}
static GtkWidget *
csm_get_dialog (CsmDialogLogoutType type,
GdkScreen *screen,
guint32 activate_time)
{
CsmLogoutDialog *logout_dialog;
GtkWidget *dialog_image;
const char *primary_text;
const char *icon_name;
if (current_dialog != NULL) {
gtk_widget_destroy (GTK_WIDGET (current_dialog));
}
logout_dialog = g_object_new (CSM_TYPE_LOGOUT_DIALOG, NULL);
current_dialog = logout_dialog;
gtk_window_set_title (GTK_WINDOW (logout_dialog), _("Session"));
logout_dialog->priv->type = type;
icon_name = NULL;
primary_text = NULL;
switch (type) {
case CSM_DIALOG_LOGOUT_TYPE_LOGOUT:
icon_name = CSM_ICON_LOGOUT;
primary_text = _("Log out of this system now?");
logout_dialog->priv->default_response = CSM_LOGOUT_RESPONSE_LOGOUT;
if (csm_logout_supports_switch_user (logout_dialog)) {
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
_("_Switch User"),
CSM_LOGOUT_RESPONSE_SWITCH_USER);
}
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
_("_Log Out"),
CSM_LOGOUT_RESPONSE_LOGOUT);
break;
case CSM_DIALOG_LOGOUT_TYPE_SHUTDOWN:
icon_name = CSM_ICON_SHUTDOWN;
primary_text = _("Shut down this system now?");
logout_dialog->priv->default_response = CSM_LOGOUT_RESPONSE_SHUTDOWN;
if (csm_logout_supports_system_suspend (logout_dialog)) {
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
_("S_uspend"),
CSM_LOGOUT_RESPONSE_SLEEP);
}
if (csm_logout_supports_system_hibernate (logout_dialog)) {
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
_("_Hibernate"),
CSM_LOGOUT_RESPONSE_HIBERNATE);
}
if (csm_logout_supports_reboot (logout_dialog)) {
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
_("_Restart"),
CSM_LOGOUT_RESPONSE_REBOOT);
}
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
if (csm_logout_supports_shutdown (logout_dialog)) {
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
_("_Shut Down"),
CSM_LOGOUT_RESPONSE_SHUTDOWN);
}
break;
case CSM_DIALOG_LOGOUT_TYPE_REBOOT:
icon_name = CSM_ICON_SHUTDOWN;
primary_text = _("Restart this system now?");
logout_dialog->priv->default_response = CSM_LOGOUT_RESPONSE_REBOOT;
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
if (csm_logout_supports_reboot (logout_dialog)) {
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
_("_Restart"),
CSM_LOGOUT_RESPONSE_REBOOT);
}
break;
default:
g_assert_not_reached ();
}
dialog_image = gtk_message_dialog_get_image (GTK_MESSAGE_DIALOG (logout_dialog));
gtk_image_set_from_icon_name (GTK_IMAGE (dialog_image),
icon_name, GTK_ICON_SIZE_DIALOG);
gtk_window_set_icon_name (GTK_WINDOW (logout_dialog), icon_name);
gtk_window_set_position (GTK_WINDOW (logout_dialog), GTK_WIN_POS_CENTER);
gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (logout_dialog), primary_text);
gtk_dialog_set_default_response (GTK_DIALOG (logout_dialog),
logout_dialog->priv->default_response);
gtk_window_set_screen (GTK_WINDOW (logout_dialog), screen);
g_signal_connect (logout_dialog, "show", G_CALLBACK (on_show), NULL);
return GTK_WIDGET (logout_dialog);
}
GtkWidget *
gnomemeeting_warning_dialog_on_widget (GtkWindow *parent,
const char *key,
const char *primary_text,
const char *format,
...)
{
va_list args;
GtkWidget *button = NULL;
GtkWidget *dialog = NULL;
char buffer[1025];
gchar *prim_text = NULL;
gchar *dialog_text = NULL;
gboolean do_not_show = FALSE;
g_return_val_if_fail (parent != NULL, NULL);
g_return_val_if_fail (key != NULL, NULL);
/* if not set, do_not_show will get the value of 0 */
do_not_show = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (parent), key));
if (do_not_show)
/* doesn't show warning dialog as state is 'hide' */
return NULL;
va_start (args, format);
button =
gtk_check_button_new_with_label (_("Do not show this dialog again"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), do_not_show);
if (format == NULL)
buffer[0] = 0;
else
g_vsnprintf (buffer, 1024, format, args);
prim_text =
g_strdup_printf ("<span weight=\"bold\" size=\"larger\">%s</span>",
primary_text);
dialog_text =
g_strdup_printf ("%s\n\n%s", prim_text, buffer);
dialog = gtk_message_dialog_new (parent,
0,
GTK_MESSAGE_WARNING,
GTK_BUTTONS_OK,
NULL);
gtk_window_set_transient_for (GTK_WINDOW (dialog), parent);
gtk_window_set_title (GTK_WINDOW (dialog), "");
gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (dialog), dialog_text);
gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
button);
/* Can be called from threads */
gm_window_show (dialog);
g_signal_connect_data (dialog, "response",
G_CALLBACK (warning_dialog_destroyed_cb),
(gpointer) g_strdup (key),
(GClosureNotify) g_free,
(GConnectFlags) 0);
va_end (args);
g_free (prim_text);
g_free (dialog_text);
return dialog;
}
/**
* gs_app_notify_unavailable:
**/
GtkResponseType
gs_app_notify_unavailable (GsApp *app, GtkWindow *parent)
{
GsAppLicenceHint hint = GS_APP_LICENCE_FREE;
GtkResponseType response;
GtkWidget *dialog;
const gchar *licence;
gboolean already_enabled = FALSE; /* FIXME */
guint i;
struct {
const gchar *str;
GsAppLicenceHint hint;
} keywords[] = {
{ "NonFree", GS_APP_LICENCE_NONFREE },
{ "PatentConcern", GS_APP_LICENCE_PATENT_CONCERN },
{ "Proprietary", GS_APP_LICENCE_NONFREE },
{ NULL, 0 }
};
_cleanup_free_ gchar *origin_url = NULL;
_cleanup_object_unref_ GSettings *settings = NULL;
_cleanup_string_free_ GString *body = NULL;
_cleanup_string_free_ GString *title = NULL;
/* this is very crude */
licence = gs_app_get_licence (app);
if (licence != NULL) {
for (i = 0; keywords[i].str != NULL; i++) {
if (g_strstr_len (licence, -1, keywords[i].str) != NULL)
hint |= keywords[i].hint;
}
} else {
/* use the worst-case assumption */
hint = GS_APP_LICENCE_NONFREE | GS_APP_LICENCE_PATENT_CONCERN;
}
/* check if the user has already dismissed */
settings = g_settings_new ("org.gnome.software");
if (!g_settings_get_boolean (settings, "prompt-for-nonfree"))
return GTK_RESPONSE_OK;
title = g_string_new ("");
if (already_enabled) {
g_string_append_printf (title, "<b>%s</b>",
/* TRANSLATORS: window title */
_("Install Third-Party Software?"));
} else {
g_string_append_printf (title, "<b>%s</b>",
/* TRANSLATORS: window title */
_("Enable Third-Party Software Source?"));
}
dialog = gtk_message_dialog_new (parent,
GTK_DIALOG_MODAL,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_CANCEL,
NULL);
gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (dialog), title->str);
/* FIXME: get the URL somehow... */
origin_url = g_strdup_printf ("<a href=\"\">%s>/a>", gs_app_get_origin (app));
body = g_string_new ("");
if (hint & GS_APP_LICENCE_NONFREE) {
g_string_append_printf (body,
/* TRANSLATORS: the replacements are as follows:
* 1. Application name, e.g. "Firefox"
* 2. Software source name, e.g. fedora-optional
*/
_("%s is not <a href=\"https://en.wikipedia.org/wiki/Free_and_open-source_software\">"
"free and open source software</a>, "
"and is provided by “%s”."),
gs_app_get_name (app),
origin_url);
} else {
g_string_append_printf (body,
/* TRANSLATORS: the replacements are as follows:
* 1. Application name, e.g. "Firefox"
* 2. Software source name, e.g. fedora-optional */
_("%s is provided by “%s”."),
gs_app_get_name (app),
origin_url);
}
/* tell the use what needs to be done */
if (!already_enabled) {
g_string_append (body, " ");
g_string_append (body,
/* TRANSLATORS: a software source is a repo */
_("This software source must be "
"enabled to continue installation."));
}
/* be aware of patent clauses */
if (hint & GS_APP_LICENCE_PATENT_CONCERN) {
g_string_append (body, "\n\n");
if (gs_app_get_id_kind (app) != AS_ID_KIND_CODEC) {
g_string_append_printf (body,
/* TRANSLATORS: Laws are geographical, urgh... */
_("It may be illegal to install "
"or use %s in some countries."),
gs_app_get_name (app));
} else {
g_string_append (body,
/* TRANSLATORS: Laws are geographical, urgh... */
_("It may be illegal to install or use "
"this codec in some countries."));
}
}
gtk_message_dialog_format_secondary_markup (GTK_MESSAGE_DIALOG (dialog), "%s", body->str);
/* TRANSLATORS: this is button text to not ask about non-free content again */
if (0) gtk_dialog_add_button (GTK_DIALOG (dialog), _("Don't Warn Again"), GTK_RESPONSE_YES);
if (already_enabled) {
gtk_dialog_add_button (GTK_DIALOG (dialog),
/* TRANSLATORS: button text */
_("Install"),
GTK_RESPONSE_OK);
} else {
gtk_dialog_add_button (GTK_DIALOG (dialog),
/* TRANSLATORS: button text */
_("Enable and Install"),
GTK_RESPONSE_OK);
}
response = gtk_dialog_run (GTK_DIALOG (dialog));
if (response == GTK_RESPONSE_YES) {
response = GTK_RESPONSE_OK;
g_settings_set_boolean (settings, "prompt-for-nonfree", FALSE);
}
gtk_widget_destroy (dialog);
return response;
}
static void
anjuta_save_prompt_init(AnjutaSavePrompt *obj)
{
GtkWidget *vbox;
GtkWidget *treeview;
GtkListStore *store;
GtkTreeViewColumn *col;
GtkCellRenderer *renderer;
GtkWidget *label;
GtkWidget *scrolledwindow;
obj->priv = g_new0(AnjutaSavePromptPrivate, 1);
gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (obj), "Uninitialized");
gtk_window_set_resizable (GTK_WINDOW (obj), TRUE);
gtk_window_set_default_size (GTK_WINDOW (obj), 400, 300);
vbox = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (obj))),
vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
label = gtk_label_new (_("Select the items to save:"));
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
gtk_misc_set_padding (GTK_MISC (label), 10, -1);
gtk_misc_set_alignment (GTK_MISC (label), 0, -1);
gtk_widget_show (label);
store = gtk_list_store_new (N_COLS, G_TYPE_BOOLEAN,
G_TYPE_STRING, G_TYPE_POINTER,
G_TYPE_POINTER, G_TYPE_POINTER);
scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow),
GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (vbox), scrolledwindow, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (scrolledwindow), 10);
gtk_widget_show (scrolledwindow);
treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
g_object_unref (store);
gtk_container_add (GTK_CONTAINER (scrolledwindow), treeview);
gtk_widget_show (treeview);
label = gtk_label_new (_("If you do not save, all your changes will be lost."));
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
gtk_misc_set_padding (GTK_MISC (label), 10, -1);
gtk_misc_set_alignment (GTK_MISC (label), 0, -1);
gtk_widget_show (label);
renderer = gtk_cell_renderer_toggle_new ();
col = gtk_tree_view_column_new_with_attributes (_("Save"),
renderer,
"active", COL_SAVE_ENABLE,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), col);
renderer = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes (_("Item"),
renderer,
"markup", COL_LABEL,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), col);
gtk_dialog_add_buttons (GTK_DIALOG (obj), _("_Discard changes"),
ANJUTA_SAVE_PROMPT_RESPONSE_DISCARD,
GTK_STOCK_CANCEL,
ANJUTA_SAVE_PROMPT_RESPONSE_CANCEL,
GTK_STOCK_SAVE,
ANJUTA_SAVE_PROMPT_RESPONSE_SAVE_CLOSE,
NULL);
/* TRUE is the default and Gtk warns that this has no effect */
/* gtk_dialog_set_has_separator (GTK_DIALOG (obj), TRUE); */
gtk_dialog_set_default_response (GTK_DIALOG (obj),
ANJUTA_SAVE_PROMPT_RESPONSE_SAVE_CLOSE);
g_signal_connect (obj, "response",
G_CALLBACK (on_dialog_response),
obj);
obj->priv->treeview = treeview;
}
