static void
show_info_bar(GtWin* self)
{
GtWinPrivate* priv = gt_win_get_instance_private(self);
QueuedInfoData* data = g_queue_pop_head(priv->info_queue);
if (data)
{
if (data->cb)
{
if (data->cb == G_CALLBACK(show_error_dialogue_cb))
{
gtk_widget_set_visible(priv->info_bar_ok_button, FALSE);
gtk_widget_set_visible(priv->info_bar_yes_button, FALSE);
gtk_widget_set_visible(priv->info_bar_no_button, FALSE);
gtk_widget_set_visible(priv->info_bar_details_button, TRUE);
gtk_widget_set_visible(priv->info_bar_close_button, TRUE);
gtk_label_set_markup(GTK_LABEL(priv->info_label), data->msg);
gtk_info_bar_set_message_type(GTK_INFO_BAR(priv->info_bar), GTK_MESSAGE_ERROR);
g_signal_connect(priv->info_bar, "response", G_CALLBACK(data->cb), data->udata);
}
else
{
g_signal_connect(priv->info_bar, "response", G_CALLBACK(data->cb), data->udata);
gtk_widget_set_visible(priv->info_bar_ok_button, FALSE);
gtk_widget_set_visible(priv->info_bar_yes_button, TRUE);
gtk_widget_set_visible(priv->info_bar_no_button, TRUE);
gtk_widget_set_visible(priv->info_bar_details_button, FALSE);
gtk_widget_set_visible(priv->info_bar_close_button, FALSE);
gtk_label_set_markup(GTK_LABEL(priv->info_label), data->msg);
gtk_info_bar_set_message_type(GTK_INFO_BAR(priv->info_bar), GTK_MESSAGE_QUESTION);
}
}
else
{
gtk_widget_set_visible(priv->info_bar_yes_button, FALSE);
gtk_widget_set_visible(priv->info_bar_no_button, FALSE);
gtk_widget_set_visible(priv->info_bar_ok_button, TRUE);
gtk_widget_set_visible(priv->info_bar_details_button, FALSE);
gtk_widget_set_visible(priv->info_bar_close_button, FALSE);
gtk_label_set_markup(GTK_LABEL(priv->info_label), data->msg);
gtk_info_bar_set_message_type(GTK_INFO_BAR(priv->info_bar), GTK_MESSAGE_INFO);
}
priv->cur_info_data = data;
gtk_revealer_set_reveal_child(GTK_REVEALER(priv->info_revealer), TRUE);
}
else
{
priv->cur_info_data = NULL;
gtk_revealer_set_reveal_child(GTK_REVEALER(priv->info_revealer), FALSE);
}
}
static void button_clicked(GtkWidget *button, gchar* message)
{
gchar *text = g_strdup_printf("InfoBar displaying %s message", message);
gtk_label_set_text(GTK_LABEL(label), text);
if (message == "information")
gtk_info_bar_set_message_type(GTK_INFO_BAR(infobar), GTK_MESSAGE_INFO);
else if (message == "warning")
gtk_info_bar_set_message_type(GTK_INFO_BAR(infobar), GTK_MESSAGE_WARNING);
else if (message == "question")
gtk_info_bar_set_message_type(GTK_INFO_BAR(infobar), GTK_MESSAGE_QUESTION);
else if (message == "error")
gtk_info_bar_set_message_type(GTK_INFO_BAR(infobar), GTK_MESSAGE_ERROR);
gtk_widget_show(GTK_WIDGET(infobar));
}
static void
spice_usb_device_widget_show_info_bar(SpiceUsbDeviceWidget *self,
const gchar *message,
GtkMessageType message_type,
const gchar *stock_icon_id)
{
SpiceUsbDeviceWidgetPrivate *priv = self->priv;
GtkWidget *info_bar, *content_area, *hbox, *widget;
spice_usb_device_widget_hide_info_bar(self);
info_bar = gtk_info_bar_new();
gtk_info_bar_set_message_type(GTK_INFO_BAR(info_bar), message_type);
content_area = gtk_info_bar_get_content_area(GTK_INFO_BAR(info_bar));
#if GTK_CHECK_VERSION(3,0,0)
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 12);
#else
hbox = gtk_hbox_new(FALSE, 12);
#endif
gtk_container_add(GTK_CONTAINER(content_area), hbox);
widget = gtk_image_new_from_stock(stock_icon_id,
GTK_ICON_SIZE_SMALL_TOOLBAR);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, FALSE, 0);
widget = gtk_label_new(message);
gtk_box_pack_start(GTK_BOX(hbox), widget, TRUE, TRUE, 0);
priv->info_bar = gtk_alignment_new(0.0, 0.0, 1.0, 0.0);
gtk_alignment_set_padding(GTK_ALIGNMENT(priv->info_bar), 0, 0, 12, 0);
gtk_container_add(GTK_CONTAINER(priv->info_bar), info_bar);
gtk_box_pack_start(GTK_BOX(self), priv->info_bar, FALSE, FALSE, 0);
gtk_widget_show_all(priv->info_bar);
}
void tabmanagergui_create_infobar (GuTabPage* tp) {
// we will probably want to make a separate file for infobar
// procedures that we can attach to hboxes in both the editor
// and the preview window, TODO for 0.7.0 -Alex
GtkWidget* infobar = NULL;
GtkWidget* message = NULL;
GtkWidget* area = NULL;
infobar = gtk_info_bar_new ();
gtk_widget_set_no_show_all (infobar, TRUE);
message = gtk_label_new ("");
gtk_label_set_line_wrap (GTK_LABEL(message), TRUE);
gtk_widget_show (message);
area = gtk_info_bar_get_content_area (GTK_INFO_BAR (infobar));
gtk_container_add (GTK_CONTAINER (area), message);
gtk_info_bar_add_button (GTK_INFO_BAR (infobar),
GTK_STOCK_YES, GTK_RESPONSE_YES);
gtk_info_bar_add_button (GTK_INFO_BAR (infobar),
GTK_STOCK_NO, GTK_RESPONSE_NO);
gtk_info_bar_set_message_type (GTK_INFO_BAR (infobar),
GTK_MESSAGE_WARNING);
tp->barlabel = message;
tp->infobar = infobar;
}
void
selections__gth_browser_update_extra_widget_cb (GthBrowser *browser)
{
GthFileData *location_data;
GtkWidget *info_bar;
int n_selection;
char *msg;
location_data = gth_browser_get_location_data (browser);
if (! _g_content_type_is_a (g_file_info_get_content_type (location_data->info), "gthumb/selection"))
return;
n_selection = g_file_info_get_attribute_int32 (location_data->info, "gthumb::n-selection");
if (n_selection <= 0)
return;
info_bar = gth_browser_get_list_info_bar (browser);
gtk_info_bar_set_message_type (GTK_INFO_BAR(info_bar), GTK_MESSAGE_INFO);
gth_info_bar_set_icon_name (GTH_INFO_BAR (info_bar), "dialog-information-symbolic", GTK_ICON_SIZE_MENU);
gth_info_bar_set_primary_text (GTH_INFO_BAR (info_bar), NULL);
msg = g_strdup_printf (_("Use Alt-%d to add files to this selection, Ctrl-%d to view this selection."), n_selection, n_selection);
gth_info_bar_set_secondary_text (GTH_INFO_BAR (info_bar), msg);
gtk_widget_show (info_bar);
g_free (msg);
}
void wxInfoBar::ShowMessage(const wxString& msg, int flags)
{
if ( !UseNative() )
{
wxInfoBarGeneric::ShowMessage(msg, flags);
return;
}
// if we don't have any buttons, create a standard close one to give the
// user at least some way to close the bar
if ( m_impl->m_buttons.empty() && !m_impl->m_close )
{
m_impl->m_close = GTKAddButton(wxID_CLOSE);
}
GtkMessageType type;
if ( wxGTKImpl::ConvertMessageTypeFromWX(flags, &type) )
gtk_info_bar_set_message_type(GTK_INFO_BAR(m_widget), type);
gtk_label_set_text(GTK_LABEL(m_impl->m_label), wxGTK_CONV(msg));
if ( !IsShown() )
Show();
UpdateParent();
}
void gtkui_cheats_par_add(GtkWidget *widget, gpointer userdata) {
// Add a Pro Action Rocky code to the list
GtkTreeIter iter;
Cheats cheats(emulator);
Cheats::Code code;
char codebuf[9];
char descbuf[512];
snprintf(codebuf, sizeof(codebuf), "%.8s", gtk_entry_get_text(GTK_ENTRY(paredit)));
snprintf(descbuf, sizeof(descbuf), "%s", gtk_entry_get_text(GTK_ENTRY(descedit)));
if (cheats.ProActionRockyDecode(codebuf, code) == Nes::RESULT_OK) {
gtk_tree_store_append(treestore, &iter, NULL);
gtk_tree_store_set(treestore, &iter,
0, true,
1, codebuf,
4, descbuf,
-1);
gtk_entry_set_text(GTK_ENTRY(descedit), "");
gtk_entry_set_text(GTK_ENTRY(ggedit), "");
gtk_entry_set_text(GTK_ENTRY(paredit), "");
gtk_widget_hide(infobar);
gtk_label_set_text(GTK_LABEL(infolabel), "");
cheats.SetCode(code);
}
else {
gtk_info_bar_set_message_type(GTK_INFO_BAR(infobar), GTK_MESSAGE_ERROR);
gtk_label_set_text(GTK_LABEL(infolabel), "Error: Invalid PAR code");
gtk_widget_show(infobar);
}
}
JNIEXPORT void JNICALL
Java_org_gnome_gtk_GtkInfoBar_gtk_1info_1bar_1set_1message_1type
(
JNIEnv* env,
jclass cls,
jlong _self,
jint _messageType
)
{
GtkInfoBar* self;
GtkMessageType messageType;
// convert parameter self
self = (GtkInfoBar*) _self;
// convert parameter messageType
messageType = (GtkMessageType) _messageType;
// call function
gtk_info_bar_set_message_type(self, messageType);
// cleanup parameter self
// cleanup parameter messageType
}
static void report_error(struct gui_entry *ge, GError *error)
{
struct gui *ui = ge->ui;
if (ui->error_info_bar == NULL) {
GtkWidget *container;
ui->error_info_bar = gtk_info_bar_new_with_buttons(GTK_STOCK_OK,
GTK_RESPONSE_OK, NULL);
g_signal_connect(ui->error_info_bar, "response", G_CALLBACK(on_info_bar_response), ui);
gtk_info_bar_set_message_type(GTK_INFO_BAR(ui->error_info_bar),
GTK_MESSAGE_ERROR);
ui->error_label = gtk_label_new(error->message);
container = gtk_info_bar_get_content_area(GTK_INFO_BAR(ui->error_info_bar));
gtk_container_add(GTK_CONTAINER(container), ui->error_label);
gtk_box_pack_start(GTK_BOX(ui->vbox), ui->error_info_bar, FALSE, FALSE, 0);
gtk_widget_show_all(ui->vbox);
} else {
char buffer[256];
snprintf(buffer, sizeof(buffer), "Failed to open file.");
gtk_label_set_text(GTK_LABEL(ui->error_label), buffer);
}
}
/* compare_on_changed */
static void _compare_on_changed(gpointer data)
{
Compare * compare = data;
GtkLabel * label = GTK_LABEL(compare->label);
char const * string1;
char const * string2;
GtkMessageType type = GTK_MESSAGE_OTHER;
string1 = gtk_entry_get_text(GTK_ENTRY(compare->entry1));
string2 = gtk_entry_get_text(GTK_ENTRY(compare->entry2));
if(string1[0] == '\0' && string2[0] == '\0')
gtk_label_set_text(label, "");
else if(strcmp(string1, string2) == 0)
{
gtk_label_set_text(label, _("The strings MATCH"));
type = GTK_MESSAGE_INFO;
}
else
{
gtk_label_set_text(label, _("The strings do NOT match"));
type = GTK_MESSAGE_ERROR;
}
#if GTK_CHECK_VERSION(2, 18, 0)
gtk_info_bar_set_message_type(GTK_INFO_BAR(compare->infobar), type);
#endif
}
/**
* e_webdav_discover_content_show_error:
* @content: a WebDAV discovery content, created by e_webdav_discover_content_new()
* @error: (allow-none): a #GError to show in the UI, or %NULL
*
* Shows the @error within @content, unless it's a #G_IO_ERROR_CANCELLED, or %NULL,
* which are safely ignored. The advantage of this function is that the error
* message is removed when the refresh operation is started.
*
* Since: 3.18
**/
void
e_webdav_discover_content_show_error (GtkWidget *content,
const GError *error)
{
EWebDAVDiscoverContentData *data;
GtkWidget *label;
g_return_if_fail (GTK_IS_GRID (content));
data = g_object_get_data (G_OBJECT (content), WEBDAV_DISCOVER_CONTENT_DATA_KEY);
g_return_if_fail (data != NULL);
if (data->info_bar) {
gtk_widget_destroy (GTK_WIDGET (data->info_bar));
data->info_bar = NULL;
}
if (!error || g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
return;
data->info_bar = GTK_INFO_BAR (gtk_info_bar_new ());
gtk_info_bar_set_message_type (data->info_bar, GTK_MESSAGE_ERROR);
gtk_info_bar_set_show_close_button (data->info_bar, TRUE);
label = gtk_label_new (error->message);
gtk_container_add (GTK_CONTAINER (gtk_info_bar_get_content_area (data->info_bar)), label);
gtk_widget_show (label);
gtk_widget_show (GTK_WIDGET (data->info_bar));
g_signal_connect (data->info_bar, "response", G_CALLBACK (e_webdav_discover_info_bar_error_response_cb), content);
gtk_grid_attach (GTK_GRID (content), GTK_WIDGET (data->info_bar), 0, 2, 1, 1);
}
void report_error(GError* error)
{
if (error == NULL)
{
return;
}
if (error_info_bar == NULL)
{
error_count = 1;
error_info_bar = gtk_info_bar_new_with_buttons(GTK_STOCK_OK,
GTK_RESPONSE_OK,
NULL);
g_signal_connect(error_info_bar, "response", G_CALLBACK(on_info_bar_response), NULL);
gtk_info_bar_set_message_type(GTK_INFO_BAR(error_info_bar),
GTK_MESSAGE_ERROR);
error_label = gtk_label_new(error->message);
GtkWidget *container = gtk_info_bar_get_content_area(GTK_INFO_BAR(error_info_bar));
gtk_container_add(GTK_CONTAINER(container), error_label);
gtk_box_pack_start(GTK_BOX(main_vbox), error_info_bar, FALSE, FALSE, 0);
gtk_widget_show_all(main_vbox);
}
else
{
error_count++;
char buffer[256];
snprintf(buffer, sizeof(buffer), "Failed to open %i files.", error_count);
gtk_label_set(GTK_LABEL(error_label), buffer);
}
}
static GtkWidget * gui_connection_infobar_new(GtkWidget **out_infobar_close,
GtkWidget **out_infobar_reconnect)
{
GtkWidget *infobar;
GtkWidget *msg_label, *content_area, *action_area;
msg_label = gtk_label_new("");
gtk_label_set_markup(GTK_LABEL(msg_label),
"<b>ERROR: Connection lost</b>");
gtk_widget_show(msg_label);
infobar = gtk_info_bar_new();
gtk_info_bar_set_message_type(GTK_INFO_BAR(infobar), GTK_MESSAGE_ERROR);
content_area = gtk_info_bar_get_content_area(GTK_INFO_BAR(infobar));
gtk_container_add(GTK_CONTAINER(content_area), msg_label);
*out_infobar_close = gtk_info_bar_add_button(GTK_INFO_BAR(infobar),
"Close", 0);
*out_infobar_reconnect = gtk_info_bar_add_button(GTK_INFO_BAR(infobar),
"Reconnect", 0);
gtk_widget_set_no_show_all(infobar, TRUE);
action_area = gtk_info_bar_get_action_area(GTK_INFO_BAR(infobar));
gtk_orientable_set_orientation(GTK_ORIENTABLE(action_area),
GTK_ORIENTATION_HORIZONTAL);
return infobar;
}
void
InterfaceGtk::msg_clear(void)
{
gtk_info_bar_set_message_type(GTK_INFO_BAR(info_widget),
GTK_MESSAGE_OTHER);
gtk_label_set_text(GTK_LABEL(message_widget), "");
}
static GtkWidget *
create_top_bar (EmpathyAppPluginWidget *self)
{
GtkWidget *bar, *content, *action, *label;
GtkCssProvider *css;
AgProvider *provider;
gchar *str;
GError *error = NULL;
bar = gtk_info_bar_new_with_buttons (
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
_("Done"), GTK_RESPONSE_OK,
NULL);
gtk_widget_set_hexpand (bar, TRUE);
gtk_info_bar_set_message_type (GTK_INFO_BAR (bar), GTK_MESSAGE_QUESTION);
action = gtk_info_bar_get_action_area (GTK_INFO_BAR (bar));
gtk_orientable_set_orientation (GTK_ORIENTABLE (action),
GTK_ORIENTATION_HORIZONTAL);
gtk_widget_set_name (bar, "authorization-infobar");
css = gtk_css_provider_new ();
if (gtk_css_provider_load_from_data (css,
"@define-color question_bg_color rgb (222, 222, 222);"
"GtkInfoBar#authorization-infobar"
"{"
" color: @fg_color;"
"}",
-1, &error))
{
GtkStyleContext *context = gtk_widget_get_style_context (bar);
gtk_style_context_add_provider (context, (GtkStyleProvider *) css,
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
}
else
{
g_warning ("Error processing CSS theme override: %s", error->message);
g_clear_error (&error);
}
g_object_unref (css);
content = gtk_info_bar_get_content_area (GTK_INFO_BAR (bar));
provider = ag_manager_get_provider (
ag_account_get_manager (self->priv->account),
ag_account_get_provider_name (self->priv->account));
str = g_strdup_printf (_("Edit %s account options"),
ag_provider_get_display_name (provider));
label = gtk_label_new (str);
gtk_container_add (GTK_CONTAINER (content), label);
gtk_widget_show (label);
ag_provider_unref (provider);
g_free (str);
g_signal_connect (bar, "response",
G_CALLBACK (response_cb), self);
return bar;
}
void
bisho_pane_set_banner (BishoPane *pane, const char *message)
{
if (message) {
gtk_info_bar_set_message_type (GTK_INFO_BAR (pane->banner), GTK_MESSAGE_INFO);
gtk_label_set_text (GTK_LABEL (pane->banner_label), message);
gtk_widget_show (pane->banner);
} else {
gtk_widget_hide (pane->banner);
}
}
static void
setup_root_info_bar (NemoToolbar *self) {
GtkWidget *root_bar = gtk_info_bar_new ();
gtk_info_bar_set_message_type (GTK_INFO_BAR (root_bar), GTK_MESSAGE_ERROR);
GtkWidget *content_area = gtk_info_bar_get_content_area (GTK_INFO_BAR (root_bar));
GtkWidget *label = gtk_label_new (_("Elevated Privileges"));
gtk_widget_show (label);
gtk_container_add (GTK_CONTAINER (content_area), label);
self->priv->root_bar = root_bar;
gtk_box_pack_start (GTK_BOX (self), self->priv->root_bar, TRUE, TRUE, 0);
}
GtkWidget *gnome_info_bar(gchar *message, GtkMessageType type)
{
GtkWidget *info_bar = gtk_info_bar_new();
gtk_widget_set_no_show_all(info_bar, TRUE);
GtkWidget *message_label = gtk_label_new(NULL);
gtk_widget_show(message_label);
GtkWidget *content_area = gtk_info_bar_get_content_area(GTK_INFO_BAR(info_bar));
gtk_container_add(GTK_CONTAINER(content_area), message_label);
gtk_label_set_markup(GTK_LABEL(message_label), message);
gtk_info_bar_set_message_type(GTK_INFO_BAR(info_bar), type);
gtk_widget_show(info_bar);
return info_bar;
}
static gboolean
set_info_error_message_idle (STlinkGUI *gui)
{
if (gui->error_message != NULL) {
gchar *markup;
markup = g_markup_printf_escaped ("<b>%s</b>", gui->error_message);
gtk_label_set_markup (gui->infolabel, markup);
gtk_info_bar_set_message_type (gui->infobar, GTK_MESSAGE_ERROR);
gtk_widget_show (GTK_WIDGET (gui->infobar));
g_free (markup);
g_free (gui->error_message);
gui->error_message = NULL;
}
return FALSE;
}
void
bisho_pane_set_banner_error (BishoPane *pane, const GError *error)
{
char *s;
if (error) {
s = g_strdup_printf (_("Sorry, we can't log in to %s. %s"),
pane->info->display_name,
error->message);
} else {
s = g_strdup_printf (_("Sorry, we can't log in to %s"),
pane->info->display_name);
}
gtk_info_bar_set_message_type (GTK_INFO_BAR (pane->banner), GTK_MESSAGE_WARNING);
gtk_label_set_text (GTK_LABEL (pane->banner_label), s);
gtk_widget_show (pane->banner);
g_free (s);
}
static int perf_gtk__warning_info_bar(const char *format, va_list args)
{
char *msg;
if (!perf_gtk__is_active_context(pgctx) ||
vasprintf(&msg, format, args) < 0) {
fprintf(stderr, "Warning:\n");
vfprintf(stderr, format, args);
fprintf(stderr, "\n");
return -1;
}
gtk_label_set_text(GTK_LABEL(pgctx->message_label), msg);
gtk_info_bar_set_message_type(GTK_INFO_BAR(pgctx->info_bar),
GTK_MESSAGE_WARNING);
gtk_widget_show(pgctx->info_bar);
free(msg);
return 0;
}
static GtkWidget *
create_io_loading_error_message_area (const gchar *primary_text,
const gchar *secondary_text,
gboolean recoverable_error)
{
GtkWidget *message_area;
#if !GTK_CHECK_VERSION (2, 17, 1)
message_area = gedit_message_area_new_with_buttons (
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
NULL);
#else
message_area = gtk_info_bar_new_with_buttons (
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
NULL);
gtk_info_bar_set_message_type (GTK_INFO_BAR (message_area),
GTK_MESSAGE_ERROR);
#endif
set_message_area_text_and_icon (message_area,
"gtk-dialog-error",
primary_text,
secondary_text);
if (recoverable_error)
{
#if !GTK_CHECK_VERSION (2, 17, 1)
gedit_message_area_add_stock_button_with_text (GEDIT_MESSAGE_AREA (message_area),
_("_Retry"),
GTK_STOCK_REFRESH,
GTK_RESPONSE_OK);
#else
info_bar_add_stock_button_with_text (GTK_INFO_BAR (message_area),
_("_Retry"),
GTK_STOCK_REFRESH,
GTK_RESPONSE_OK);
#endif
}
return message_area;
}
static void
wallpaper_data_set (WallpaperData *wdata)
{
GtkWidget *infobar;
wallpaper_style_set_as_current (&wdata->new_style);
infobar = gth_browser_get_infobar (wdata->browser);
gth_info_bar_set_icon (GTH_INFO_BAR (infobar), GTK_STOCK_DIALOG_INFO);
{
char *name;
char *msg;
name = _g_file_get_display_name (wdata->new_style.file);
msg = g_strdup_printf ("The image \"%s\" has been set as desktop background", name);
gth_info_bar_set_primary_text (GTH_INFO_BAR (infobar), msg);
g_free (msg);
g_free (name);
}
_gtk_info_bar_clear_action_area (GTK_INFO_BAR (infobar));
gtk_orientable_set_orientation (GTK_ORIENTABLE (gtk_info_bar_get_action_area (GTK_INFO_BAR (infobar))), GTK_ORIENTATION_HORIZONTAL);
gtk_info_bar_set_message_type (GTK_INFO_BAR (infobar), GTK_MESSAGE_INFO);
gtk_info_bar_add_buttons (GTK_INFO_BAR (infobar),
GTK_STOCK_PREFERENCES, _RESPONSE_PREFERENCES,
GTK_STOCK_UNDO, _RESPONSE_UNDO,
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
NULL);
gtk_info_bar_set_response_sensitive (GTK_INFO_BAR (infobar),
_RESPONSE_UNDO,
wdata->old_style.file != NULL);
wdata->response_id = g_signal_connect (infobar,
"response",
G_CALLBACK (infobar_response_cb),
wdata);
gtk_widget_show (infobar);
}
void
InterfaceGtk::vmsg(MessageType type, const gchar *fmt, va_list ap)
{
static const GtkMessageType type2gtk[] = {
/* [MSG_USER] = */ GTK_MESSAGE_OTHER,
/* [MSG_INFO] = */ GTK_MESSAGE_INFO,
/* [MSG_WARNING] = */ GTK_MESSAGE_WARNING,
/* [MSG_ERROR] = */ GTK_MESSAGE_ERROR
};
va_list aq;
gchar buf[255];
va_copy(aq, ap);
stdio_vmsg(type, fmt, ap);
g_vsnprintf(buf, sizeof(buf), fmt, aq);
va_end(aq);
gtk_info_bar_set_message_type(GTK_INFO_BAR(info_widget),
type2gtk[type]);
gtk_label_set_text(GTK_LABEL(message_widget), buf);
}
static GtkWidget *
create_error_message_area (const gchar *primary_text,
const gchar *secondary_text,
EogErrorMessageAreaButtons buttons)
{
GtkWidget *message_area;
/* create a new message area */
message_area = gtk_info_bar_new ();
/* add requested buttons to the message area */
if (buttons & EOG_ERROR_MESSAGE_AREA_CANCEL_BUTTON)
gtk_info_bar_add_button (GTK_INFO_BAR (message_area),
_("_Cancel"),
EOG_ERROR_MESSAGE_AREA_RESPONSE_CANCEL);
if (buttons & EOG_ERROR_MESSAGE_AREA_RELOAD_BUTTON)
gtk_info_bar_add_button (GTK_INFO_BAR (message_area),
_("_Reload"),
EOG_ERROR_MESSAGE_AREA_RESPONSE_RELOAD);
if (buttons & EOG_ERROR_MESSAGE_AREA_SAVEAS_BUTTON)
gtk_info_bar_add_button (GTK_INFO_BAR (message_area),
_("Save _As…"),
EOG_ERROR_MESSAGE_AREA_RESPONSE_SAVEAS);
/* set message type */
gtk_info_bar_set_message_type (GTK_INFO_BAR (message_area),
GTK_MESSAGE_ERROR);
/* set text and icon */
set_message_area_text_and_icon (GTK_INFO_BAR (message_area),
GTK_STOCK_DIALOG_ERROR,
primary_text,
secondary_text);
return message_area;
}
void ColorVisionDeficiencyConfig::type_combobox_change_cb(GtkWidget *widget, ColorVisionDeficiencyConfig *this_)
{
const char *descriptions[] = {
_("Altered spectral sensitivity of red receptors"),
_("Altered spectral sensitivity of green receptors"),
_("Altered spectral sensitivity of blue receptors"),
_("Absence of red receptors"),
_("Absence of green receptors"),
_("Absence of blue receptors"),
};
GtkTreeIter iter;
if (gtk_combo_box_get_active_iter(GTK_COMBO_BOX(this_->type), &iter)) {
GtkTreeModel* model = gtk_combo_box_get_model(GTK_COMBO_BOX(this_->type));
ColorVisionDeficiency::DeficiencyType type_id;
gtk_tree_model_get(model, &iter, 1, &type_id, -1);
gtk_label_set_text(GTK_LABEL(this_->info_label), descriptions[type_id]);
}else{
gtk_label_set_text(GTK_LABEL(this_->info_label), "");
}
gtk_info_bar_set_message_type(GTK_INFO_BAR(this_->info_bar), GTK_MESSAGE_INFO);
}
static GtkWidget *
create_error_message_area (const gchar *primary_text,
const gchar *secondary_text,
gboolean recoverable)
{
GtkWidget *message_area;
if (recoverable)
message_area = gtk_info_bar_new_with_buttons (_("_Retry"),
GTK_RESPONSE_OK,
NULL);
else
message_area = gtk_info_bar_new ();
gtk_info_bar_set_message_type (GTK_INFO_BAR (message_area),
GTK_MESSAGE_ERROR);
set_message_area_text_and_icon (GTK_INFO_BAR (message_area),
GTK_STOCK_DIALOG_ERROR,
primary_text,
secondary_text);
return message_area;
}
/**
* e_webdav_discover_content_refresh:
* @content: a WebDAV discovery content, created by e_webdav_discover_content_new()
* @display_name: (allow-none): optional display name to use for scratch sources
* @cancellable: (allow-none): optional #GCancellable object, or %NULL
* @callback: (scope async): a #GAsyncReadyCallback to call when the request
* is satisfied
* @user_data: (closure): data to pass to the callback function
*
* Asynchronously starts refresh of the @content. This means to access the server
* and search it for available sources. The @content shows a feedback and a Cancel
* button during the operation.
*
* The @display_name is used only if the @content wasn't created with an #ESource and
* it's shown in the password prompts, if there are required any.
*
* When the operation is finished, @callback will be called. You can then
* call e_webdav_discover_content_refresh_finish() to get the result of the operation.
*
* Since: 3.18
**/
void
e_webdav_discover_content_refresh (GtkWidget *content,
const gchar *display_name,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
EWebDAVDiscoverContentData *data;
RefreshData *rd;
ESource *source;
SoupURI *soup_uri;
GtkWidget *label;
g_return_if_fail (GTK_IS_GRID (content));
data = g_object_get_data (G_OBJECT (content), WEBDAV_DISCOVER_CONTENT_DATA_KEY);
g_return_if_fail (data != NULL);
g_return_if_fail (data->base_url != NULL);
soup_uri = soup_uri_new (data->base_url);
if (!soup_uri) {
GSimpleAsyncResult *simple;
simple = g_simple_async_result_new (G_OBJECT (content), callback, user_data, e_webdav_discover_content_refresh);
g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
_("Invalid URL"));
g_simple_async_result_complete_in_idle (simple);
g_object_unref (simple);
return;
}
if (!soup_uri_get_user (soup_uri)) {
GSimpleAsyncResult *simple;
soup_uri_free (soup_uri);
simple = g_simple_async_result_new (G_OBJECT (content), callback, user_data, e_webdav_discover_content_refresh);
g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
_("User name not filled"));
g_simple_async_result_complete_in_idle (simple);
g_object_unref (simple);
return;
}
rd = g_new0 (RefreshData, 1);
rd->content = g_object_ref (content);
rd->cancellable = cancellable ? g_object_ref (cancellable) : g_cancellable_new ();
rd->simple = g_simple_async_result_new (G_OBJECT (content), callback, user_data, e_webdav_discover_content_refresh);
rd->base_url = g_strdup (data->base_url);
rd->credentials = NULL;
if (data->source) {
source = g_object_ref (data->source);
} else {
ESourceWebdav *webdav_extension;
ESourceAuthentication *auth_extension;
source = e_source_new_with_uid (data->base_url, NULL, NULL);
g_return_if_fail (source != NULL);
webdav_extension = e_source_get_extension (source, E_SOURCE_EXTENSION_WEBDAV_BACKEND);
auth_extension = e_source_get_extension (source, E_SOURCE_EXTENSION_AUTHENTICATION);
if (display_name && *display_name)
e_source_set_display_name (source, display_name);
e_source_webdav_set_soup_uri (webdav_extension, soup_uri);
e_source_authentication_set_host (auth_extension, soup_uri_get_host (soup_uri));
e_source_authentication_set_port (auth_extension, soup_uri_get_port (soup_uri));
e_source_authentication_set_user (auth_extension, soup_uri_get_user (soup_uri));
}
gtk_list_store_clear (GTK_LIST_STORE (gtk_tree_view_get_model (data->sources_tree_view)));
if (data->email_addresses_combo)
gtk_combo_box_text_remove_all (GTK_COMBO_BOX_TEXT (data->email_addresses_combo));
if (data->info_bar)
gtk_widget_destroy (GTK_WIDGET (data->info_bar));
data->info_bar = GTK_INFO_BAR (gtk_info_bar_new_with_buttons (_("Cancel"), GTK_RESPONSE_CANCEL, NULL));
gtk_info_bar_set_message_type (data->info_bar, GTK_MESSAGE_INFO);
gtk_info_bar_set_show_close_button (data->info_bar, FALSE);
label = gtk_label_new (_("Searching server sources..."));
gtk_container_add (GTK_CONTAINER (gtk_info_bar_get_content_area (data->info_bar)), label);
gtk_widget_show (label);
gtk_widget_show (GTK_WIDGET (data->info_bar));
g_signal_connect (data->info_bar, "response", G_CALLBACK (e_webdav_discover_info_bar_response_cb), rd);
gtk_widget_set_sensitive (GTK_WIDGET (data->sources_tree_view), FALSE);
if (data->email_addresses_combo)
gtk_widget_set_sensitive (GTK_WIDGET (data->email_addresses_combo), FALSE);
gtk_grid_attach (GTK_GRID (content), GTK_WIDGET (data->info_bar), 0, 2, 1, 1);
e_webdav_discover_sources (source, rd->base_url, E_WEBDAV_DISCOVER_SUPPORTS_NONE, rd->credentials, rd->cancellable,
e_webdav_discover_content_refresh_done_cb, rd);
g_object_unref (source);
soup_uri_free (soup_uri);
}
GtkWidget *
do_infobar (GtkWidget *do_widget)
{
GtkWidget *frame;
GtkWidget *bar;
GtkWidget *vbox;
GtkWidget *vbox2;
GtkWidget *label;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (do_widget));
gtk_window_set_title (GTK_WINDOW (window), "Info Bars");
g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window);
gtk_container_set_border_width (GTK_CONTAINER (window), 8);
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
bar = gtk_info_bar_new ();
gtk_box_pack_start (GTK_BOX (vbox), bar, FALSE, FALSE, 0);
gtk_info_bar_set_message_type (GTK_INFO_BAR (bar), GTK_MESSAGE_INFO);
label = gtk_label_new ("This is an info bar with message type GTK_MESSAGE_INFO");
gtk_box_pack_start (GTK_BOX (gtk_info_bar_get_content_area (GTK_INFO_BAR (bar))), label, FALSE, FALSE, 0);
bar = gtk_info_bar_new ();
gtk_box_pack_start (GTK_BOX (vbox), bar, FALSE, FALSE, 0);
gtk_info_bar_set_message_type (GTK_INFO_BAR (bar), GTK_MESSAGE_WARNING);
label = gtk_label_new ("This is an info bar with message type GTK_MESSAGE_WARNING");
gtk_box_pack_start (GTK_BOX (gtk_info_bar_get_content_area (GTK_INFO_BAR (bar))), label, FALSE, FALSE, 0);
bar = gtk_info_bar_new_with_buttons (GTK_STOCK_OK, GTK_RESPONSE_OK, NULL);
g_signal_connect (bar, "response", G_CALLBACK (on_bar_response), window);
gtk_box_pack_start (GTK_BOX (vbox), bar, FALSE, FALSE, 0);
gtk_info_bar_set_message_type (GTK_INFO_BAR (bar), GTK_MESSAGE_QUESTION);
label = gtk_label_new ("This is an info bar with message type GTK_MESSAGE_QUESTION");
gtk_box_pack_start (GTK_BOX (gtk_info_bar_get_content_area (GTK_INFO_BAR (bar))), label, FALSE, FALSE, 0);
bar = gtk_info_bar_new ();
gtk_box_pack_start (GTK_BOX (vbox), bar, FALSE, FALSE, 0);
gtk_info_bar_set_message_type (GTK_INFO_BAR (bar), GTK_MESSAGE_ERROR);
label = gtk_label_new ("This is an info bar with message type GTK_MESSAGE_ERROR");
gtk_box_pack_start (GTK_BOX (gtk_info_bar_get_content_area (GTK_INFO_BAR (bar))), label, FALSE, FALSE, 0);
bar = gtk_info_bar_new ();
gtk_box_pack_start (GTK_BOX (vbox), bar, FALSE, FALSE, 0);
gtk_info_bar_set_message_type (GTK_INFO_BAR (bar), GTK_MESSAGE_OTHER);
label = gtk_label_new ("This is an info bar with message type GTK_MESSAGE_OTHER");
gtk_box_pack_start (GTK_BOX (gtk_info_bar_get_content_area (GTK_INFO_BAR (bar))), label, FALSE, FALSE, 0);
frame = gtk_frame_new ("Info bars");
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 8);
vbox2 = gtk_vbox_new (FALSE, 8);
gtk_container_set_border_width (GTK_CONTAINER (vbox2), 8);
gtk_container_add (GTK_CONTAINER (frame), vbox2);
/* Standard message dialog */
label = gtk_label_new ("An example of different info bars");
gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, FALSE, 0);
}
if (!GTK_WIDGET_VISIBLE (window))
{
gtk_widget_show_all (window);
}
else
{
gtk_widget_destroy (window);
window = NULL;
}
return window;
}
static void show_inline_message (GtkMessageType message_type, const char *message) {
gtk_widget_show(GTK_WIDGET (info_bar));
gtk_info_bar_set_message_type(GTK_INFO_BAR (info_bar),
message_type);
gtk_label_set_text(info_label, message);
}
