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