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;
}
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;
}
GtkWidget * create_info_bar_import_music(struct con_win *cwin)
{
const gchar *dir = g_get_user_special_dir(G_USER_DIRECTORY_MUSIC);
GtkWidget *info_bar = gtk_info_bar_new();
GtkWidget *action_area = gtk_info_bar_get_action_area(GTK_INFO_BAR (info_bar));
GtkWidget *content_area = gtk_info_bar_get_content_area(GTK_INFO_BAR(info_bar));
gtk_orientable_set_orientation(GTK_ORIENTABLE(action_area), GTK_ORIENTATION_HORIZONTAL);
//GtkInfoBar has undocumented behavior for GTK_RESPONSE_CANCEL
gtk_info_bar_add_button(GTK_INFO_BAR(info_bar), GTK_STOCK_NO, GTK_RESPONSE_CANCEL);
gtk_info_bar_add_button(GTK_INFO_BAR(info_bar), GTK_STOCK_YES, GTK_RESPONSE_YES);
gchar *content = g_strdup_printf(_("Would you like to import %s to library?"), dir);
GtkWidget *label = gtk_label_new(content);
gtk_box_pack_start(GTK_BOX(content_area), label, FALSE, FALSE, 0);
g_signal_connect(info_bar, "response", G_CALLBACK(info_bar_response_cb), cwin);
gtk_widget_show_all(info_bar);
g_free(content);
return info_bar;
}
static void
nautilus_trash_bar_init (NautilusTrashBar *bar)
{
GtkWidget *content_area, *action_area, *w;
GtkWidget *label;
PangoAttrList *attrs;
bar->priv = NAUTILUS_TRASH_BAR_GET_PRIVATE (bar);
content_area = gtk_info_bar_get_content_area (GTK_INFO_BAR (bar));
action_area = gtk_info_bar_get_action_area (GTK_INFO_BAR (bar));
gtk_orientable_set_orientation (GTK_ORIENTABLE (action_area),
GTK_ORIENTATION_HORIZONTAL);
attrs = pango_attr_list_new ();
pango_attr_list_insert (attrs, pango_attr_weight_new (PANGO_WEIGHT_BOLD));
label = gtk_label_new (_("Trash"));
gtk_label_set_attributes (GTK_LABEL (label), attrs);
pango_attr_list_unref (attrs);
gtk_widget_show (label);
gtk_container_add (GTK_CONTAINER (content_area), label);
w = gtk_info_bar_add_button (GTK_INFO_BAR (bar),
_("_Restore"),
TRASH_BAR_RESPONSE_RESTORE);
gtk_widget_set_tooltip_text (w,
_("Restore selected items to their original position"));
w = gtk_info_bar_add_button (GTK_INFO_BAR (bar),
/* Translators: "Empty" is an action (for the trash) , not a state */
_("_Empty"),
TRASH_BAR_RESPONSE_EMPTY);
gtk_widget_set_tooltip_text (w,
_("Delete all items in the Trash"));
g_signal_connect_object (nautilus_trash_monitor_get (),
"trash-state-changed",
G_CALLBACK (nautilus_trash_bar_trash_state_changed),
bar,
0);
nautilus_trash_bar_trash_state_changed (nautilus_trash_monitor_get (),
FALSE, bar);
g_signal_connect (bar, "response",
G_CALLBACK (trash_bar_response_cb), bar);
}
static void
nemo_interesting_folder_bar_constructed (GObject *obj)
{
G_OBJECT_CLASS (nemo_interesting_folder_bar_parent_class)->constructed (obj);
NemoInterestingFolderBar *bar = NEMO_INTERESTING_FOLDER_BAR (obj);
GtkWidget *content_area, *action_area, *w;
GtkWidget *label;
content_area = gtk_info_bar_get_content_area (GTK_INFO_BAR (bar));
action_area = gtk_info_bar_get_action_area (GTK_INFO_BAR (bar));
gtk_orientable_set_orientation (GTK_ORIENTABLE (action_area),
GTK_ORIENTATION_HORIZONTAL);
switch (bar->priv->type) {
case TYPE_ACTIONS_FOLDER:
label = gtk_label_new (_("Actions: Action files can be added to this folder and will appear in the menu."));
w = gtk_info_bar_add_button (GTK_INFO_BAR (bar),
_("More info"),
INTERESTING_FOLDER_BAR_ACTION_OPEN_DOC);
gtk_widget_set_tooltip_text (w, _("View a sample action file with documentation"));
break;
case TYPE_SCRIPTS_FOLDER:
label = gtk_label_new (_("Scripts: All executable files in this folder will appear in the "
"Scripts menu."));
w = gtk_info_bar_add_button (GTK_INFO_BAR (bar),
_("More info"),
INTERESTING_FOLDER_BAR_SCRIPT_OPEN_DOC);
gtk_widget_set_tooltip_text (w, _("View additional information about creating scripts"));
break;
case TYPE_NONE_FOLDER:
default:
label = gtk_label_new ("undefined");
break;
}
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_style_context_add_class (gtk_widget_get_style_context (label),
"nemo-cluebar-label");
gtk_widget_show (label);
gtk_container_add (GTK_CONTAINER (content_area), label);
g_signal_connect (bar, "response",
G_CALLBACK (interesting_folder_bar_response_cb), bar);
}
static void
nemo_trash_bar_init (NemoTrashBar *bar)
{
GtkWidget *content_area, *action_area, *w;
GtkWidget *label;
bar->priv = NEMO_TRASH_BAR_GET_PRIVATE (bar);
content_area = gtk_info_bar_get_content_area (GTK_INFO_BAR (bar));
action_area = gtk_info_bar_get_action_area (GTK_INFO_BAR (bar));
gtk_orientable_set_orientation (GTK_ORIENTABLE (action_area),
GTK_ORIENTATION_HORIZONTAL);
label = gtk_label_new (_("Trash"));
gtk_style_context_add_class (gtk_widget_get_style_context (label),
"nemo-cluebar-label");
gtk_widget_show (label);
gtk_container_add (GTK_CONTAINER (content_area), label);
w = gtk_info_bar_add_button (GTK_INFO_BAR (bar),
_("Restore Selected Items"),
TRASH_BAR_RESPONSE_RESTORE);
gtk_widget_set_tooltip_text (w,
_("Restore selected items to their original position"));
w = gtk_info_bar_add_button (GTK_INFO_BAR (bar),
_("Empty _Trash"),
TRASH_BAR_RESPONSE_EMPTY);
gtk_widget_set_tooltip_text (w,
_("Delete all items in the Trash"));
g_signal_connect_object (nemo_trash_monitor_get (),
"trash_state_changed",
G_CALLBACK (nemo_trash_bar_trash_state_changed),
bar,
0);
nemo_trash_bar_trash_state_changed (nemo_trash_monitor_get (),
FALSE, bar);
g_signal_connect (bar, "response",
G_CALLBACK (trash_bar_response_cb), bar);
}
GtkWidget *create_info_bar_update_music(struct con_win *cwin)
{
GtkWidget *info_bar = gtk_info_bar_new();
GtkWidget *action_area = gtk_info_bar_get_action_area(GTK_INFO_BAR (info_bar));
GtkWidget *content_area = gtk_info_bar_get_content_area(GTK_INFO_BAR(info_bar));
gtk_orientable_set_orientation(GTK_ORIENTABLE(action_area), GTK_ORIENTATION_HORIZONTAL);
//GtkInfoBar has undocumented behavior for GTK_RESPONSE_CANCEL
gtk_info_bar_add_button(GTK_INFO_BAR(info_bar), GTK_STOCK_NO, GTK_RESPONSE_CANCEL);
gtk_info_bar_add_button(GTK_INFO_BAR(info_bar), GTK_STOCK_YES, GTK_RESPONSE_YES);
GtkWidget *label = gtk_label_new(_("Want to upgrade your music library?"));
gtk_box_pack_start(GTK_BOX(content_area), label, FALSE, FALSE, 0);
g_signal_connect(info_bar, "response", G_CALLBACK(info_bar_update_response_cb), cwin);
gtk_widget_show_all(info_bar);
return info_bar;
}
static void
info_bar_add_stock_button_with_text (GtkInfoBar *infobar,
const gchar *text,
const gchar *stock_id,
gint response_id)
{
GtkWidget *button;
GtkWidget *image;
button = gtk_info_bar_add_button (infobar, text, response_id);
image = gtk_image_new_from_stock (stock_id, GTK_ICON_SIZE_BUTTON);
gtk_button_set_image (GTK_BUTTON (button), image);
}
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;
}
JNIEXPORT jlong JNICALL
Java_org_gnome_gtk_GtkInfoBar_gtk_1info_1bar_1add_1button
(
JNIEnv* env,
jclass cls,
jlong _self,
jstring _buttonText,
jint _responseId
)
{
GtkWidget* result;
jlong _result;
GtkInfoBar* self;
const gchar* buttonText;
gint responseId;
// convert parameter self
self = (GtkInfoBar*) _self;
// convert parameter buttonText
buttonText = (const gchar*) bindings_java_getString(env, _buttonText);
if (buttonText == NULL) {
return 0L; // Java Exception already thrown
}
// convert parameter responseId
responseId = (gint) _responseId;
// call function
result = gtk_info_bar_add_button(self, buttonText, responseId);
// cleanup parameter self
// cleanup parameter buttonText
bindings_java_releaseString(buttonText);
// cleanup parameter responseId
// translate return value to JNI type
_result = (jlong) result;
// cleanup return value
if (result != NULL) {
bindings_java_memory_cleanup((GObject*)result, FALSE);
}
// and finally
return _result;
}
static void
nemo_thumbnail_problem_bar_constructed (GObject *obj)
{
G_OBJECT_CLASS (nemo_thumbnail_problem_bar_parent_class)->constructed (obj);
NemoThumbnailProblemBar *bar = NEMO_THUMBNAIL_PROBLEM_BAR (obj);
GtkWidget *content_area, *action_area;
G_GNUC_UNUSED GtkWidget *w;
GtkWidget *label;
content_area = gtk_info_bar_get_content_area (GTK_INFO_BAR (bar));
action_area = gtk_info_bar_get_action_area (GTK_INFO_BAR (bar));
gtk_orientable_set_orientation (GTK_ORIENTABLE (action_area),
GTK_ORIENTATION_HORIZONTAL);
label = gtk_label_new (_("A problem has been detected with your thumbnail cache. Fixing it will require administrative privileges."));
/* w is useless - this method creates the widget and adds/refs it to the info bar at the same time */
w = gtk_info_bar_add_button (GTK_INFO_BAR (bar),
_("Fix now"),
FIX_CACHE);
w = gtk_info_bar_add_button (GTK_INFO_BAR (bar),
_("Dismiss"),
DISMISS);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_style_context_add_class (gtk_widget_get_style_context (label),
"nemo-cluebar-label");
gtk_widget_show (label);
gtk_container_add (GTK_CONTAINER (content_area), label);
g_signal_connect (bar, "response",
G_CALLBACK (thumbnail_problem_bar_response_cb), bar);
}
static void
gedit_progress_message_area_set_has_cancel_button (GeditProgressMessageArea *area,
gboolean has_button)
{
if (has_button)
#if !GTK_CHECK_VERSION (2, 17, 1)
gedit_message_area_add_button (GEDIT_MESSAGE_AREA (area),
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
#else
gtk_info_bar_add_button (GTK_INFO_BAR (area),
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
#endif
g_object_notify (G_OBJECT (area), "has-cancel-button");
}
GtkWidget *wxInfoBar::GTKAddButton(wxWindowID btnid, const wxString& label)
{
// as GTK+ lays out the buttons vertically, adding another button changes
// our best size (at least in vertical direction)
InvalidateBestSize();
GtkWidget* button = gtk_info_bar_add_button(GTK_INFO_BAR(m_widget),
#ifdef __WXGTK4__
wxGTK_CONV(label.empty() ? wxConvertMnemonicsToGTK(wxGetStockLabel(btnid)) : label),
#else
label.empty() ? wxGetStockGtkID(btnid) : static_cast<const char*>(wxGTK_CONV(label)),
#endif
btnid);
wxASSERT_MSG( button, "unexpectedly failed to add button to info bar" );
return button;
}
int main(int argc, char *argv[])
{
GtkWidget *button;
GtkWidget *content_area;
gtk_init(&argc, &argv);
GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_signal_connect(window, "destroy", G_CALLBACK(destroy), NULL);
GtkWidget *vbox = gtk_vbox_new(FALSE, 5);
gtk_container_add(GTK_CONTAINER(window), vbox);
infobar = gtk_info_bar_new();
gtk_info_bar_add_button(GTK_INFO_BAR(infobar), GTK_STOCK_CLOSE, GTK_RESPONSE_OK);
g_signal_connect(infobar, "response", G_CALLBACK(gtk_widget_hide), NULL);
gtk_box_pack_start(GTK_BOX(vbox), infobar, TRUE, TRUE, 0);
label = gtk_label_new("InfoBar displaying information message");
content_area = gtk_info_bar_get_content_area(GTK_INFO_BAR(infobar));
gtk_box_pack_start(GTK_BOX(content_area), label, TRUE, TRUE, 0);
GtkWidget *hbox = gtk_hbox_new(TRUE, 5);
gtk_box_pack_end(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
button = gtk_button_new_with_label("Information");
g_signal_connect(button, "clicked", G_CALLBACK(button_clicked), "information");
gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label("Warning");
g_signal_connect(button, "clicked", G_CALLBACK(button_clicked), "warning");
gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label("Question");
g_signal_connect(button, "clicked", G_CALLBACK(button_clicked), "question");
gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label("Error");
g_signal_connect(button, "clicked", G_CALLBACK(button_clicked), "error");
gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 0);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
GtkWidget *wxInfoBar::GTKAddButton(wxWindowID btnid, const wxString& label)
{
// as GTK+ lays out the buttons vertically, adding another button changes
// our best size (at least in vertical direction)
InvalidateBestSize();
GtkWidget *button = gtk_info_bar_add_button
(
GTK_INFO_BAR(m_widget),
(label.empty()
? GTKConvertMnemonics(wxGetStockGtkID(btnid))
: label).utf8_str(),
btnid
);
wxASSERT_MSG( button, "unexpectedly failed to add button to info bar" );
return button;
}
static void
stlink_gui_build_ui (STlinkGUI *gui) {
GtkBuilder *builder;
GtkListStore *devmem_store;
GtkListStore *filemem_store;
gchar *ui_file = STLINK_UI_DIR "/stlink-gui.ui";
if (!g_file_test (ui_file, G_FILE_TEST_EXISTS)) {
ui_file = "stlink-gui.ui";
}
builder = gtk_builder_new ();
if (!gtk_builder_add_from_file (builder, ui_file, NULL)) {
g_printerr ("Failed to load UI file: %s\n", ui_file);
exit (1);
}
gui->window = GTK_WINDOW (gtk_builder_get_object (builder, "window"));
g_signal_connect (G_OBJECT (gui->window), "destroy",
G_CALLBACK (gtk_main_quit), NULL);
/* set up toolutton clicked callbacks */
gui->open_button =
GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "open_button"));
g_signal_connect (G_OBJECT (gui->open_button), "clicked",
G_CALLBACK (open_button_cb), gui);
gui->connect_button =
GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "connect_button"));
g_signal_connect (G_OBJECT (gui->connect_button), "clicked",
G_CALLBACK (connect_button_cb), gui);
gui->disconnect_button =
GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "disconnect_button"));
g_signal_connect (G_OBJECT (gui->disconnect_button), "clicked",
G_CALLBACK (disconnect_button_cb), gui);
gui->flash_button =
GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "flash_button"));
g_signal_connect (G_OBJECT (gui->flash_button), "clicked",
G_CALLBACK (flash_button_cb), gui);
gui->devmem_treeview =
GTK_TREE_VIEW (gtk_builder_get_object (builder, "devmem_treeview"));
gtk_tree_view_set_rules_hint (gui->devmem_treeview, TRUE);
mem_view_init_headers (gui->devmem_treeview);
devmem_store = gtk_list_store_new (5,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING);
gtk_tree_view_set_model (gui->devmem_treeview, GTK_TREE_MODEL (devmem_store));
g_object_unref (devmem_store);
gui->filemem_treeview =
GTK_TREE_VIEW (gtk_builder_get_object (builder, "filemem_treeview"));
gtk_tree_view_set_rules_hint (gui->filemem_treeview, TRUE);
mem_view_init_headers (gui->filemem_treeview);
filemem_store = gtk_list_store_new (5,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING);
gtk_tree_view_set_model (gui->filemem_treeview, GTK_TREE_MODEL (filemem_store));
g_object_unref (filemem_store);
gui->core_id_label =
GTK_LABEL (gtk_builder_get_object (builder, "core_id_value"));
gui->chip_id_label =
GTK_LABEL (gtk_builder_get_object (builder, "chip_id_value"));
gui->flash_size_label =
GTK_LABEL (gtk_builder_get_object (builder, "flash_size_value"));
gui->ram_size_label =
GTK_LABEL (gtk_builder_get_object (builder, "ram_size_value"));
gui->device_frame =
GTK_FRAME (gtk_builder_get_object (builder, "device_frame"));
gui->notebook =
GTK_NOTEBOOK (gtk_builder_get_object (builder, "mem_notebook"));
g_signal_connect (gui->notebook, "switch-page",
G_CALLBACK (notebook_switch_page_cb), gui);
gui->devmem_box =
GTK_BOX (gtk_builder_get_object (builder, "devmem_box"));
gui->filemem_box =
GTK_BOX (gtk_builder_get_object (builder, "filemem_box"));
gui->devmem_jmp_entry =
GTK_ENTRY (gtk_builder_get_object (builder, "devmem_jmp_entry"));
g_signal_connect (gui->devmem_jmp_entry, "activate",
G_CALLBACK (devmem_jmp_cb), gui);
gui->filemem_jmp_entry =
GTK_ENTRY (gtk_builder_get_object (builder, "filemem_jmp_entry"));
g_signal_connect (gui->filemem_jmp_entry, "activate",
G_CALLBACK (filemem_jmp_cb), gui);
gtk_editable_set_editable (GTK_EDITABLE (gui->filemem_jmp_entry), TRUE);
gui->progress.bar =
GTK_PROGRESS_BAR (gtk_builder_get_object (builder, "progressbar"));
gtk_progress_bar_set_show_text (gui->progress.bar, TRUE);
gui->progress.timer = g_timeout_add (100,
(GSourceFunc) progress_pulse_timeout,
gui);
gui->statusbar =
GTK_STATUSBAR (gtk_builder_get_object (builder, "statusbar"));
gui->infobar =
GTK_INFO_BAR (gtk_builder_get_object (builder, "infobar"));
gtk_info_bar_add_button (gui->infobar, GTK_STOCK_OK, GTK_RESPONSE_OK);
gui->infolabel = GTK_LABEL (gtk_label_new (""));
gtk_container_add (GTK_CONTAINER (gtk_info_bar_get_content_area (gui->infobar)),
GTK_WIDGET (gui->infolabel));
g_signal_connect (gui->infobar, "response", G_CALLBACK (gtk_widget_hide), NULL);
/* flash dialog */
gui->flash_dialog =
GTK_DIALOG (gtk_builder_get_object (builder, "flash_dialog"));
g_signal_connect_swapped (gui->flash_dialog, "response",
G_CALLBACK (gtk_widget_hide), gui->flash_dialog);
gui->flash_dialog_ok =
GTK_BUTTON (gtk_builder_get_object (builder, "flash_dialog_ok_button"));
gui->flash_dialog_cancel =
GTK_BUTTON (gtk_builder_get_object (builder, "flash_dialog_cancel_button"));
gui->flash_dialog_entry =
GTK_ENTRY (gtk_builder_get_object (builder, "flash_dialog_entry"));
/* make it so */
gtk_widget_show_all (GTK_WIDGET (gui->window));
gtk_widget_hide (GTK_WIDGET (gui->infobar));
gtk_widget_hide (GTK_WIDGET (gui->progress.bar));
stlink_gui_set_disconnected (gui);
}
static void
rejilla_burn_options_update_valid (RejillaBurnOptions *self)
{
RejillaBurnOptionsPrivate *priv;
RejillaSessionError valid;
priv = REJILLA_BURN_OPTIONS_PRIVATE (self);
valid = rejilla_session_cfg_get_error (priv->session);
priv->is_valid = REJILLA_SESSION_IS_VALID (valid);
rejilla_burn_options_setup_buttons (self);
gtk_widget_set_sensitive (priv->options, priv->is_valid);
gtk_widget_set_sensitive (priv->properties, priv->is_valid);
if (priv->message_input) {
gtk_widget_hide (priv->message_input);
rejilla_notify_message_remove (priv->message_input,
REJILLA_NOTIFY_CONTEXT_SIZE);
}
rejilla_notify_message_remove (priv->message_output,
REJILLA_NOTIFY_CONTEXT_SIZE);
if (valid == REJILLA_SESSION_NOT_READY) {
if (!priv->not_ready_id && !priv->status_dialog) {
gtk_widget_set_sensitive (GTK_WIDGET (self), FALSE);
priv->status_dialog = rejilla_status_dialog_new (REJILLA_BURN_SESSION (priv->session), GTK_WIDGET (self));
g_signal_connect (priv->status_dialog,
"response",
G_CALLBACK (rejilla_burn_options_not_ready_dialog_cancel_cb),
self);
g_signal_connect (priv->status_dialog,
"show",
G_CALLBACK (rejilla_burn_options_not_ready_dialog_shown_cb),
self);
g_signal_connect (priv->status_dialog,
"user-interaction",
G_CALLBACK (rejilla_burn_options_not_ready_dialog_shown_cb),
self);
priv->not_ready_id = g_timeout_add_seconds (1,
rejilla_burn_options_not_ready_dialog_show_cb,
self);
}
}
else {
gtk_widget_set_sensitive (GTK_WIDGET (self), TRUE);
if (priv->status_dialog) {
gtk_widget_destroy (priv->status_dialog);
priv->status_dialog = NULL;
}
if (priv->not_ready_id) {
g_source_remove (priv->not_ready_id);
priv->not_ready_id = 0;
}
}
if (valid == REJILLA_SESSION_INSUFFICIENT_SPACE) {
goffset min_disc_size;
goffset available_space;
min_disc_size = rejilla_session_span_get_max_space (REJILLA_SESSION_SPAN (priv->session));
/* One rule should be that the maximum batch size should not exceed the disc size
* FIXME: we could change it into a dialog telling the user what is the maximum
* size required. */
available_space = rejilla_burn_session_get_available_medium_space (REJILLA_BURN_SESSION (priv->session));
/* Here there is an alternative: we may be able to span the data
* across multiple media. So try that. */
if (available_space > min_disc_size
&& rejilla_session_span_possible (REJILLA_SESSION_SPAN (priv->session)) == REJILLA_BURN_RETRY) {
GtkWidget *message;
message = rejilla_notify_message_add (priv->message_output,
_("Would you like to burn the selection of files across several media?"),
_("The data size is too large for the disc even with the overburn option."),
-1,
REJILLA_NOTIFY_CONTEXT_SIZE);
gtk_widget_set_tooltip_text (gtk_info_bar_add_button (GTK_INFO_BAR (message),
_("_Burn Several Discs"),
GTK_RESPONSE_OK),
_("Burn the selection of files across several media"));
g_signal_connect (message,
"response",
G_CALLBACK (rejilla_burn_options_message_response_span_cb),
self);
}
else
rejilla_notify_message_add (priv->message_output,
_("Please choose another CD or DVD or insert a new one."),
_("The data size is too large for the disc even with the overburn option."),
-1,
REJILLA_NOTIFY_CONTEXT_SIZE);
}
else if (valid == REJILLA_SESSION_NO_OUTPUT) {
rejilla_notify_message_add (priv->message_output,
_("Please insert a writable CD or DVD."),
NULL,
-1,
REJILLA_NOTIFY_CONTEXT_SIZE);
}
else if (valid == REJILLA_SESSION_NO_CD_TEXT) {
rejilla_notify_message_add (priv->message_output,
_("No track information (artist, title, ...) will be written to the disc."),
_("This is not supported by the current active burning backend."),
-1,
REJILLA_NOTIFY_CONTEXT_SIZE);
}
else if (valid == REJILLA_SESSION_EMPTY) {
RejillaTrackType *type;
type = rejilla_track_type_new ();
rejilla_burn_session_get_input_type (REJILLA_BURN_SESSION (priv->session), type);
if (rejilla_track_type_get_has_data (type))
rejilla_notify_message_add (priv->message_output,
_("Please add files."),
_("There are no files to write to disc"),
-1,
REJILLA_NOTIFY_CONTEXT_SIZE);
else if (!REJILLA_STREAM_FORMAT_HAS_VIDEO (rejilla_track_type_get_stream_format (type)))
rejilla_notify_message_add (priv->message_output,
_("Please add songs."),
_("There are no songs to write to disc"),
-1,
REJILLA_NOTIFY_CONTEXT_SIZE);
else
rejilla_notify_message_add (priv->message_output,
_("Please add videos."),
_("There are no videos to write to disc"),
-1,
REJILLA_NOTIFY_CONTEXT_SIZE);
rejilla_track_type_free (type);
gtk_window_resize (GTK_WINDOW (self), 10, 10);
return;
}
else if (valid == REJILLA_SESSION_NO_INPUT_MEDIUM) {
GtkWidget *message;
if (priv->message_input) {
gtk_widget_show (priv->message_input);
message = rejilla_notify_message_add (priv->message_input,
_("Please insert a disc holding data."),
_("There is no inserted disc to copy."),
-1,
REJILLA_NOTIFY_CONTEXT_SIZE);
}
}
else if (valid == REJILLA_SESSION_NO_INPUT_IMAGE) {
GtkWidget *message;
if (priv->message_input) {
gtk_widget_show (priv->message_input);
message = rejilla_notify_message_add (priv->message_input,
_("Please select a disc image."),
_("There is no selected disc image."),
-1,
REJILLA_NOTIFY_CONTEXT_SIZE);
}
}
else if (valid == REJILLA_SESSION_UNKNOWN_IMAGE) {
GtkWidget *message;
if (priv->message_input) {
gtk_widget_show (priv->message_input);
message = rejilla_notify_message_add (priv->message_input,
/* Translators: this is a disc image not a picture */
C_("disc", "Please select another image."),
_("It doesn't appear to be a valid disc image or a valid cue file."),
-1,
REJILLA_NOTIFY_CONTEXT_SIZE);
}
}
else if (valid == REJILLA_SESSION_DISC_PROTECTED) {
GtkWidget *message;
if (priv->message_input) {
gtk_widget_show (priv->message_input);
message = rejilla_notify_message_add (priv->message_input,
_("Please insert a disc that is not copy protected."),
_("All required applications and libraries are not installed."),
-1,
REJILLA_NOTIFY_CONTEXT_SIZE);
}
}
else if (valid == REJILLA_SESSION_NOT_SUPPORTED) {
rejilla_notify_message_add (priv->message_output,
_("Please replace the disc with a supported CD or DVD."),
NULL,
-1,
REJILLA_NOTIFY_CONTEXT_SIZE);
}
else if (valid == REJILLA_SESSION_OVERBURN_NECESSARY) {
GtkWidget *message;
message = rejilla_notify_message_add (priv->message_output,
_("Would you like to burn beyond the disc's reported capacity?"),
_("The data size is too large for the disc and you must remove files from the selection otherwise."
"\nYou may want to use this option if you're using 90 or 100 min CD-R(W) which cannot be properly recognised and therefore need overburn option."
"\nNOTE: This option might cause failure."),
-1,
REJILLA_NOTIFY_CONTEXT_SIZE);
gtk_widget_set_tooltip_text (gtk_info_bar_add_button (GTK_INFO_BAR (message),
_("_Overburn"),
GTK_RESPONSE_OK),
_("Burn beyond the disc's reported capacity"));
g_signal_connect (message,
"response",
G_CALLBACK (rejilla_burn_options_message_response_cb),
self);
}
else if (rejilla_burn_session_same_src_dest_drive (REJILLA_BURN_SESSION (priv->session))) {
/* The medium is valid but it's a special case */
rejilla_notify_message_add (priv->message_output,
_("The drive that holds the source disc will also be the one used to record."),
_("A new writable disc will be required once the currently loaded one has been copied."),
-1,
REJILLA_NOTIFY_CONTEXT_SIZE);
gtk_widget_show_all (priv->message_output);
}
rejilla_burn_options_update_no_medium_warning (self);
gtk_window_resize (GTK_WINDOW (self), 10, 10);
}
GtkWidget *
gedit_no_backup_saving_error_message_area_new (const gchar *uri,
const GError *error)
{
GtkWidget *message_area;
GtkWidget *hbox_content;
GtkWidget *image;
GtkWidget *vbox;
gchar *primary_markup;
gchar *secondary_markup;
GtkWidget *primary_label;
GtkWidget *secondary_label;
gchar *primary_text;
const gchar *secondary_text;
gchar *full_formatted_uri;
gchar *uri_for_display;
gchar *temp_uri_for_display;
g_return_val_if_fail (uri != NULL, NULL);
g_return_val_if_fail (error != NULL, NULL);
g_return_val_if_fail (((error->domain == GEDIT_DOCUMENT_ERROR &&
error->code == GEDIT_DOCUMENT_ERROR_CANT_CREATE_BACKUP) ||
(error->domain == G_IO_ERROR &&
error->code == G_IO_ERROR_CANT_CREATE_BACKUP)), NULL);
full_formatted_uri = gedit_utils_uri_for_display (uri);
/* Truncate the URI so it doesn't get insanely wide. Note that even
* though the dialog uses wrapped text, if the URI doesn't contain
* white space then the text-wrapping code is too stupid to wrap it.
*/
temp_uri_for_display = gedit_utils_str_middle_truncate (full_formatted_uri,
MAX_URI_IN_DIALOG_LENGTH);
g_free (full_formatted_uri);
uri_for_display = g_markup_printf_escaped ("<i>%s</i>", temp_uri_for_display);
g_free (temp_uri_for_display);
#if !GTK_CHECK_VERSION (2, 17, 1)
message_area = gedit_message_area_new ();
gedit_message_area_add_stock_button_with_text (GEDIT_MESSAGE_AREA (message_area),
_("S_ave Anyway"),
GTK_STOCK_SAVE,
GTK_RESPONSE_YES);
gedit_message_area_add_button (GEDIT_MESSAGE_AREA (message_area),
_("D_on't Save"),
GTK_RESPONSE_CANCEL);
#else
message_area = gtk_info_bar_new ();
info_bar_add_stock_button_with_text (GTK_INFO_BAR (message_area),
_("S_ave Anyway"),
GTK_STOCK_SAVE,
GTK_RESPONSE_YES);
gtk_info_bar_add_button (GTK_INFO_BAR (message_area),
_("D_on't Save"),
GTK_RESPONSE_CANCEL);
gtk_info_bar_set_message_type (GTK_INFO_BAR (message_area),
GTK_MESSAGE_WARNING);
#endif
hbox_content = gtk_hbox_new (FALSE, 8);
image = gtk_image_new_from_stock ("gtk-dialog-warning", GTK_ICON_SIZE_DIALOG);
gtk_box_pack_start (GTK_BOX (hbox_content), image, FALSE, FALSE, 0);
gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0);
vbox = gtk_vbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (hbox_content), vbox, TRUE, TRUE, 0);
// FIXME: review this messages
if (gedit_prefs_manager_get_create_backup_copy ())
primary_text = g_strdup_printf (_("Could not create a backup file while saving %s"),
uri_for_display);
else
primary_text = g_strdup_printf (_("Could not create a temporary backup file while saving %s"),
uri_for_display);
g_free (uri_for_display);
primary_markup = g_strdup_printf ("<b>%s</b>", primary_text);
g_free (primary_text);
primary_label = gtk_label_new (primary_markup);
g_free (primary_markup);
gtk_box_pack_start (GTK_BOX (vbox), primary_label, TRUE, TRUE, 0);
gtk_label_set_use_markup (GTK_LABEL (primary_label), TRUE);
gtk_label_set_line_wrap (GTK_LABEL (primary_label), TRUE);
gtk_misc_set_alignment (GTK_MISC (primary_label), 0, 0.5);
GTK_WIDGET_SET_FLAGS (primary_label, GTK_CAN_FOCUS);
gtk_label_set_selectable (GTK_LABEL (primary_label), TRUE);
secondary_text = _("gedit could not back up the old copy of the file before saving the new one. "
"You can ignore this warning and save the file anyway, but if an error "
"occurs while saving, you could lose the old copy of the file. Save anyway?");
secondary_markup = g_strdup_printf ("<small>%s</small>",
secondary_text);
secondary_label = gtk_label_new (secondary_markup);
g_free (secondary_markup);
gtk_box_pack_start (GTK_BOX (vbox), secondary_label, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (secondary_label, GTK_CAN_FOCUS);
gtk_label_set_use_markup (GTK_LABEL (secondary_label), TRUE);
gtk_label_set_line_wrap (GTK_LABEL (secondary_label), TRUE);
gtk_label_set_selectable (GTK_LABEL (secondary_label), TRUE);
gtk_misc_set_alignment (GTK_MISC (secondary_label), 0, 0.5);
gtk_widget_show_all (hbox_content);
set_contents (message_area, hbox_content);
return message_area;
}
static void
show_page_account (GoaPanel *panel,
GoaObject *object)
{
GList *children;
GList *l;
GtkWidget *box;
GtkWidget *grid;
GtkWidget *left_grid;
GtkWidget *right_grid;
GtkWidget *bar;
GtkWidget *label;
GoaProvider *provider;
GoaAccount *account;
const gchar *provider_type;
provider = NULL;
show_page (panel, 1);
box = GTK_WIDGET (gtk_builder_get_object (panel->builder, "accounts-tree-box"));
gtk_widget_set_sensitive (box, TRUE);
label = GTK_WIDGET (gtk_builder_get_object (panel->builder, "accounts-tree-label"));
gtk_widget_hide (label);
/* Out with the old */
children = gtk_container_get_children (GTK_CONTAINER (panel->accounts_vbox));
for (l = children; l != NULL; l = l->next)
gtk_container_remove (GTK_CONTAINER (panel->accounts_vbox), GTK_WIDGET (l->data));
g_list_free (children);
account = goa_object_peek_account (object);
provider_type = goa_account_get_provider_type (account);
provider = goa_provider_get_for_provider_type (provider_type);
/* And in with the new */
if (goa_account_get_attention_needed (account))
{
bar = gtk_info_bar_new ();
label = gtk_label_new (_("Expired credentials. Please log in again."));
gtk_container_add (GTK_CONTAINER (gtk_info_bar_get_content_area (GTK_INFO_BAR (bar))), label);
if (provider != NULL)
gtk_info_bar_add_button (GTK_INFO_BAR (bar), _("_Log In"), GTK_RESPONSE_OK);
gtk_box_pack_start (GTK_BOX (panel->accounts_vbox), bar, FALSE, TRUE, 0);
g_signal_connect (bar, "response", G_CALLBACK (on_info_bar_response), panel);
}
left_grid = gtk_grid_new ();
gtk_widget_set_halign (left_grid, GTK_ALIGN_END);
gtk_widget_set_hexpand (left_grid, TRUE);
gtk_orientable_set_orientation (GTK_ORIENTABLE (left_grid), GTK_ORIENTATION_VERTICAL);
gtk_grid_set_row_spacing (GTK_GRID (left_grid), 0);
right_grid = gtk_grid_new ();
gtk_widget_set_hexpand (right_grid, TRUE);
gtk_orientable_set_orientation (GTK_ORIENTABLE (right_grid), GTK_ORIENTATION_VERTICAL);
gtk_grid_set_row_spacing (GTK_GRID (right_grid), 0);
if (provider != NULL)
{
goa_provider_show_account (provider,
panel->client,
object,
GTK_BOX (panel->accounts_vbox),
GTK_GRID (left_grid),
GTK_GRID (right_grid));
}
grid = gtk_grid_new ();
gtk_orientable_set_orientation (GTK_ORIENTABLE (grid), GTK_ORIENTATION_HORIZONTAL);
gtk_grid_set_column_spacing (GTK_GRID (grid), 12);
gtk_container_add (GTK_CONTAINER (grid), left_grid);
gtk_container_add (GTK_CONTAINER (grid), right_grid);
gtk_box_pack_start (GTK_BOX (panel->accounts_vbox), grid, FALSE, TRUE, 0);
gtk_widget_show_all (panel->accounts_vbox);
if (provider != NULL)
g_object_unref (provider);
}
GtkWidget *
gedit_file_already_open_warning_message_area_new (const gchar *uri)
{
GtkWidget *message_area;
GtkWidget *hbox_content;
GtkWidget *image;
GtkWidget *vbox;
gchar *primary_markup;
gchar *secondary_markup;
GtkWidget *primary_label;
GtkWidget *secondary_label;
gchar *primary_text;
const gchar *secondary_text;
gchar *full_formatted_uri;
gchar *uri_for_display;
gchar *temp_uri_for_display;
full_formatted_uri = gedit_utils_uri_for_display (uri);
/* Truncate the URI so it doesn't get insanely wide. Note that even
* though the dialog uses wrapped text, if the URI doesn't contain
* white space then the text-wrapping code is too stupid to wrap it.
*/
temp_uri_for_display = gedit_utils_str_middle_truncate (full_formatted_uri,
MAX_URI_IN_DIALOG_LENGTH);
g_free (full_formatted_uri);
uri_for_display = g_markup_printf_escaped ("<i>%s</i>", temp_uri_for_display);
g_free (temp_uri_for_display);
#if !GTK_CHECK_VERSION (2, 17, 1)
message_area = gedit_message_area_new ();
gedit_message_area_add_button (GEDIT_MESSAGE_AREA (message_area),
_("Edit Any_way"),
GTK_RESPONSE_YES);
gedit_message_area_add_button (GEDIT_MESSAGE_AREA (message_area),
_("D_on't Edit"),
GTK_RESPONSE_CANCEL);
#else
message_area = gtk_info_bar_new ();
gtk_info_bar_add_button (GTK_INFO_BAR (message_area),
/* Translators: the access key chosen for this string should be
different from other main menu access keys (Open, Edit, View...) */
_("Edit Any_way"),
GTK_RESPONSE_YES);
gtk_info_bar_add_button (GTK_INFO_BAR (message_area),
/* Translators: the access key chosen for this string should be
different from other main menu access keys (Open, Edit, View...) */
_("D_on't Edit"),
GTK_RESPONSE_CANCEL);
gtk_info_bar_set_message_type (GTK_INFO_BAR (message_area),
GTK_MESSAGE_WARNING);
#endif
hbox_content = gtk_hbox_new (FALSE, 8);
image = gtk_image_new_from_stock ("gtk-dialog-warning", GTK_ICON_SIZE_DIALOG);
gtk_box_pack_start (GTK_BOX (hbox_content), image, FALSE, FALSE, 0);
gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0);
vbox = gtk_vbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (hbox_content), vbox, TRUE, TRUE, 0);
primary_text = g_strdup_printf (_("This file (%s) is already open in another gedit window."), uri_for_display);
g_free (uri_for_display);
primary_markup = g_strdup_printf ("<b>%s</b>", primary_text);
g_free (primary_text);
primary_label = gtk_label_new (primary_markup);
g_free (primary_markup);
gtk_box_pack_start (GTK_BOX (vbox), primary_label, TRUE, TRUE, 0);
gtk_label_set_use_markup (GTK_LABEL (primary_label), TRUE);
gtk_label_set_line_wrap (GTK_LABEL (primary_label), TRUE);
gtk_misc_set_alignment (GTK_MISC (primary_label), 0, 0.5);
GTK_WIDGET_SET_FLAGS (primary_label, GTK_CAN_FOCUS);
gtk_label_set_selectable (GTK_LABEL (primary_label), TRUE);
secondary_text = _("gedit opened this instance of the file in a non-editable way. "
"Do you want to edit it anyway?");
secondary_markup = g_strdup_printf ("<small>%s</small>",
secondary_text);
secondary_label = gtk_label_new (secondary_markup);
g_free (secondary_markup);
gtk_box_pack_start (GTK_BOX (vbox), secondary_label, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (secondary_label, GTK_CAN_FOCUS);
gtk_label_set_use_markup (GTK_LABEL (secondary_label), TRUE);
gtk_label_set_line_wrap (GTK_LABEL (secondary_label), TRUE);
gtk_label_set_selectable (GTK_LABEL (secondary_label), TRUE);
gtk_misc_set_alignment (GTK_MISC (secondary_label), 0, 0.5);
gtk_widget_show_all (hbox_content);
set_contents (message_area, hbox_content);
return message_area;
}
GtkWidget *
gedit_externally_modified_saving_error_message_area_new (
const gchar *uri,
const GError *error)
{
GtkWidget *message_area;
GtkWidget *hbox_content;
GtkWidget *image;
GtkWidget *vbox;
gchar *primary_markup;
gchar *secondary_markup;
GtkWidget *primary_label;
GtkWidget *secondary_label;
gchar *primary_text;
const gchar *secondary_text;
gchar *full_formatted_uri;
gchar *uri_for_display;
gchar *temp_uri_for_display;
g_return_val_if_fail (uri != NULL, NULL);
g_return_val_if_fail (error != NULL, NULL);
g_return_val_if_fail (error->domain == GEDIT_DOCUMENT_ERROR, NULL);
g_return_val_if_fail (error->code == GEDIT_DOCUMENT_ERROR_EXTERNALLY_MODIFIED, NULL);
full_formatted_uri = gedit_utils_uri_for_display (uri);
/* Truncate the URI so it doesn't get insanely wide. Note that even
* though the dialog uses wrapped text, if the URI doesn't contain
* white space then the text-wrapping code is too stupid to wrap it.
*/
temp_uri_for_display = gedit_utils_str_middle_truncate (full_formatted_uri,
MAX_URI_IN_DIALOG_LENGTH);
g_free (full_formatted_uri);
uri_for_display = g_markup_printf_escaped ("<i>%s</i>", temp_uri_for_display);
g_free (temp_uri_for_display);
#if !GTK_CHECK_VERSION (2, 17, 1)
message_area = gedit_message_area_new ();
gedit_message_area_add_stock_button_with_text (GEDIT_MESSAGE_AREA (message_area),
_("S_ave Anyway"),
GTK_STOCK_SAVE,
GTK_RESPONSE_YES);
gedit_message_area_add_button (GEDIT_MESSAGE_AREA (message_area),
_("D_on't Save"),
GTK_RESPONSE_CANCEL);
#else
message_area = gtk_info_bar_new ();
info_bar_add_stock_button_with_text (GTK_INFO_BAR (message_area),
_("S_ave Anyway"),
GTK_STOCK_SAVE,
GTK_RESPONSE_YES);
gtk_info_bar_add_button (GTK_INFO_BAR (message_area),
_("D_on't Save"),
GTK_RESPONSE_CANCEL);
gtk_info_bar_set_message_type (GTK_INFO_BAR (message_area),
GTK_MESSAGE_WARNING);
#endif
hbox_content = gtk_hbox_new (FALSE, 8);
image = gtk_image_new_from_stock ("gtk-dialog-warning", GTK_ICON_SIZE_DIALOG);
gtk_box_pack_start (GTK_BOX (hbox_content), image, FALSE, FALSE, 0);
gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0);
vbox = gtk_vbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (hbox_content), vbox, TRUE, TRUE, 0);
// FIXME: review this message, it's not clear since for the user the "modification"
// could be interpreted as the changes he made in the document. beside "reading" is
// not accurate (since last load/save)
primary_text = g_strdup_printf (_("The file %s has been modified since reading it."),
uri_for_display);
g_free (uri_for_display);
primary_markup = g_strdup_printf ("<b>%s</b>", primary_text);
g_free (primary_text);
primary_label = gtk_label_new (primary_markup);
g_free (primary_markup);
gtk_box_pack_start (GTK_BOX (vbox), primary_label, TRUE, TRUE, 0);
gtk_label_set_use_markup (GTK_LABEL (primary_label), TRUE);
gtk_label_set_line_wrap (GTK_LABEL (primary_label), TRUE);
gtk_misc_set_alignment (GTK_MISC (primary_label), 0, 0.5);
GTK_WIDGET_SET_FLAGS (primary_label, GTK_CAN_FOCUS);
gtk_label_set_selectable (GTK_LABEL (primary_label), TRUE);
secondary_text = _("If you save it, all the external changes could be lost. Save it anyway?");
secondary_markup = g_strdup_printf ("<small>%s</small>",
secondary_text);
secondary_label = gtk_label_new (secondary_markup);
g_free (secondary_markup);
gtk_box_pack_start (GTK_BOX (vbox), secondary_label, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (secondary_label, GTK_CAN_FOCUS);
gtk_label_set_use_markup (GTK_LABEL (secondary_label), TRUE);
gtk_label_set_line_wrap (GTK_LABEL (secondary_label), TRUE);
gtk_label_set_selectable (GTK_LABEL (secondary_label), TRUE);
gtk_misc_set_alignment (GTK_MISC (secondary_label), 0, 0.5);
gtk_widget_show_all (hbox_content);
set_contents (message_area, hbox_content);
return message_area;
}
GtkWidget *
gedit_externally_modified_message_area_new (const gchar *uri,
gboolean document_modified)
{
gchar *full_formatted_uri;
gchar *uri_for_display;
gchar *temp_uri_for_display;
const gchar *primary_text;
const gchar *secondary_text;
GtkWidget *message_area;
g_return_val_if_fail (uri != NULL, NULL);
full_formatted_uri = gedit_utils_uri_for_display (uri);
/* Truncate the URI so it doesn't get insanely wide. Note that even
* though the dialog uses wrapped text, if the URI doesn't contain
* white space then the text-wrapping code is too stupid to wrap it.
*/
temp_uri_for_display = gedit_utils_str_middle_truncate (full_formatted_uri,
MAX_URI_IN_DIALOG_LENGTH);
g_free (full_formatted_uri);
uri_for_display = g_markup_printf_escaped ("<i>%s</i>", temp_uri_for_display);
g_free (temp_uri_for_display);
// FIXME: review this message, it's not clear since for the user the "modification"
// could be interpreted as the changes he made in the document. beside "reading" is
// not accurate (since last load/save)
primary_text = g_strdup_printf (_("The file %s changed on disk."),
uri_for_display);
g_free (uri_for_display);
if (document_modified)
secondary_text = _("Do you want to drop your changes and reload the file?");
else
secondary_text = _("Do you want to reload the file?");
#if !GTK_CHECK_VERSION (2, 17, 1)
message_area = gedit_message_area_new ();
gedit_message_area_add_stock_button_with_text (GEDIT_MESSAGE_AREA (message_area),
_("_Reload"),
GTK_STOCK_REFRESH,
GTK_RESPONSE_OK);
gedit_message_area_add_button (GEDIT_MESSAGE_AREA (message_area),
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
#else
message_area = gtk_info_bar_new ();
info_bar_add_stock_button_with_text (GTK_INFO_BAR (message_area),
_("_Reload"),
GTK_STOCK_REFRESH,
GTK_RESPONSE_OK);
gtk_info_bar_add_button (GTK_INFO_BAR (message_area),
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
gtk_info_bar_set_message_type (GTK_INFO_BAR (message_area),
GTK_MESSAGE_WARNING);
#endif
set_message_area_text_and_icon (message_area,
"gtk-dialog-warning",
primary_text,
secondary_text);
return message_area;
}
static GtkWidget *
create_conversion_error_message_area (const gchar *primary_text,
const gchar *secondary_text,
gboolean edit_anyway)
{
GtkWidget *message_area;
GtkWidget *hbox_content;
GtkWidget *image;
GtkWidget *vbox;
gchar *primary_markup;
gchar *secondary_markup;
GtkWidget *primary_label;
GtkWidget *secondary_label;
#if !GTK_CHECK_VERSION (2, 17, 1)
message_area = gedit_message_area_new ();
gedit_message_area_add_stock_button_with_text (GEDIT_MESSAGE_AREA (message_area),
_("_Retry"),
GTK_STOCK_REDO,
GTK_RESPONSE_OK);
if (edit_anyway)
{
gedit_message_area_add_button (GEDIT_MESSAGE_AREA (message_area),
_("Edit Any_way"),
GTK_RESPONSE_YES);
gedit_message_area_add_button (GEDIT_MESSAGE_AREA (message_area),
_("D_on't Edit"),
GTK_RESPONSE_NO);
}
else
{
gedit_message_area_add_button (GEDIT_MESSAGE_AREA (message_area),
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
}
#else
message_area = gtk_info_bar_new ();
info_bar_add_stock_button_with_text (GTK_INFO_BAR (message_area),
_("_Retry"),
GTK_STOCK_REDO,
GTK_RESPONSE_OK);
if (edit_anyway)
{
gtk_info_bar_add_button (GTK_INFO_BAR (message_area),
/* Translators: the access key chosen for this string should be
different from other main menu access keys (Open, Edit, View...) */
_("Edit Any_way"),
GTK_RESPONSE_YES);
gtk_info_bar_add_button (GTK_INFO_BAR (message_area),
/* Translators: the access key chosen for this string should be
different from other main menu access keys (Open, Edit, View...) */
_("D_on't Edit"),
GTK_RESPONSE_NO);
gtk_info_bar_set_message_type (GTK_INFO_BAR (message_area),
GTK_MESSAGE_WARNING);
}
else
{
gtk_info_bar_add_button (GTK_INFO_BAR (message_area),
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
gtk_info_bar_set_message_type (GTK_INFO_BAR (message_area),
GTK_MESSAGE_ERROR);
}
#endif
hbox_content = gtk_hbox_new (FALSE, 8);
image = gtk_image_new_from_stock ("gtk-dialog-error", GTK_ICON_SIZE_DIALOG);
gtk_box_pack_start (GTK_BOX (hbox_content), image, FALSE, FALSE, 0);
gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0);
vbox = gtk_vbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (hbox_content), vbox, TRUE, TRUE, 0);
primary_markup = g_strdup_printf ("<b>%s</b>", primary_text);
primary_label = gtk_label_new (primary_markup);
g_free (primary_markup);
gtk_box_pack_start (GTK_BOX (vbox), primary_label, TRUE, TRUE, 0);
gtk_label_set_use_markup (GTK_LABEL (primary_label), TRUE);
gtk_label_set_line_wrap (GTK_LABEL (primary_label), TRUE);
gtk_misc_set_alignment (GTK_MISC (primary_label), 0, 0.5);
GTK_WIDGET_SET_FLAGS (primary_label, GTK_CAN_FOCUS);
gtk_label_set_selectable (GTK_LABEL (primary_label), TRUE);
if (secondary_text != NULL)
{
secondary_markup = g_strdup_printf ("<small>%s</small>",
secondary_text);
secondary_label = gtk_label_new (secondary_markup);
g_free (secondary_markup);
gtk_box_pack_start (GTK_BOX (vbox), secondary_label, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (secondary_label, GTK_CAN_FOCUS);
gtk_label_set_use_markup (GTK_LABEL (secondary_label), TRUE);
gtk_label_set_line_wrap (GTK_LABEL (secondary_label), TRUE);
gtk_label_set_selectable (GTK_LABEL (secondary_label), TRUE);
gtk_misc_set_alignment (GTK_MISC (secondary_label), 0, 0.5);
}
create_combo_box (message_area, vbox);
gtk_widget_show_all (hbox_content);
set_contents (message_area, hbox_content);
return message_area;
}
static void
rb_grilo_source_constructed (GObject *object)
{
RBGriloSource *source;
RBShell *shell;
RBShellPlayer *shell_player;
const GList *source_keys;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
GtkWidget *scrolled;
GtkWidget *browserbox;
GtkWidget *vbox;
GtkWidget *mainbox;
GtkAdjustment *adjustment;
RB_CHAIN_GOBJECT_METHOD (rb_grilo_source_parent_class, constructed, object);
source = RB_GRILO_SOURCE (object);
g_object_get (source, "shell", &shell, NULL);
g_object_get (shell,
"db", &source->priv->db,
"shell-player", &shell_player,
NULL);
g_object_unref (shell);
g_object_get (source, "entry-type", &source->priv->entry_type, NULL);
source->priv->entry_view = rb_entry_view_new (source->priv->db, G_OBJECT (shell_player), TRUE, FALSE);
g_object_unref (shell_player);
g_signal_connect (source->priv->entry_view,
"notify::sort-order",
G_CALLBACK (notify_sort_order_cb),
source);
source_keys = grl_source_supported_keys (source->priv->grilo_source);
if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_TRACK_NUMBER))) {
rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_TRACK_NUMBER, FALSE);
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys,
GUINT_TO_POINTER(GRL_METADATA_KEY_TRACK_NUMBER));
}
if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_TITLE))) {
rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_TITLE, TRUE);
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys,
GUINT_TO_POINTER(GRL_METADATA_KEY_TITLE));
}
if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_GENRE))) {
rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_GENRE, FALSE);
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys,
GUINT_TO_POINTER(GRL_METADATA_KEY_GENRE));
}
if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_ARTIST))) {
rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_ARTIST, FALSE);
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys,
GUINT_TO_POINTER(GRL_METADATA_KEY_ARTIST));
}
if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_ALBUM))) {
rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_ALBUM, FALSE);
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys,
GUINT_TO_POINTER(GRL_METADATA_KEY_ALBUM));
}
/*
if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_DATE))) {
rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_YEAR, FALSE);
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys,
GUINT_TO_POINTER(GRL_METADATA_KEY_DATE));
}
*/
if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_DURATION))) {
rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_DURATION, FALSE);
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys,
GUINT_TO_POINTER(GRL_METADATA_KEY_DURATION));
}
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_CHILDCOUNT));
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_URL));
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_THUMBNAIL));
/* probably add an image column too? */
source->priv->browser_model = gtk_tree_store_new (4, GRL_TYPE_MEDIA, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT);
source->priv->browser_view = gtk_tree_view_new ();
gtk_tree_view_set_model (GTK_TREE_VIEW (source->priv->browser_view), GTK_TREE_MODEL (source->priv->browser_model));
column = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_set_title (column, _("Browse"));
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_add_attribute (column, renderer, "text", 1);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column (GTK_TREE_VIEW (source->priv->browser_view), column);
gtk_tree_view_set_show_expanders (GTK_TREE_VIEW (source->priv->browser_view), TRUE);
gtk_tree_view_set_expander_column (GTK_TREE_VIEW (source->priv->browser_view), column);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (source->priv->browser_view), TRUE);
gtk_tree_view_set_fixed_height_mode (GTK_TREE_VIEW (source->priv->browser_view), TRUE);
g_signal_connect (source->priv->browser_view, "row-expanded", G_CALLBACK (browser_row_expanded_cb), source);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (source->priv->browser_view));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); /* should be multiple eventually */
g_signal_connect (selection, "changed", G_CALLBACK (browser_selection_changed_cb), source);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN);
adjustment = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled));
g_signal_connect (adjustment, "changed", G_CALLBACK (scroll_adjust_changed_cb), source);
g_signal_connect (adjustment, "value-changed", G_CALLBACK (scroll_adjust_value_changed_cb), source);
browserbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
/* search bar (if the source supports searching) */
if (grl_source_supported_operations (source->priv->grilo_source) & GRL_OP_SEARCH) {
source->priv->search_entry = rb_search_entry_new (FALSE);
g_object_set (source->priv->search_entry, "explicit-mode", TRUE, NULL);
g_signal_connect (source->priv->search_entry, "search", G_CALLBACK (search_cb), source);
g_signal_connect (source->priv->search_entry, "activate", G_CALLBACK (search_cb), source);
gtk_box_pack_start (GTK_BOX (browserbox), GTK_WIDGET (source->priv->search_entry), FALSE, FALSE, 6);
}
gtk_container_add (GTK_CONTAINER (scrolled), source->priv->browser_view);
gtk_box_pack_start (GTK_BOX (browserbox), scrolled, TRUE, TRUE, 0);
mainbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (source), mainbox, TRUE, TRUE, 0);
/* info bar */
source->priv->info_bar_label = gtk_label_new ("");
source->priv->info_bar = gtk_info_bar_new ();
gtk_info_bar_set_message_type (GTK_INFO_BAR (source->priv->info_bar), GTK_MESSAGE_INFO);
gtk_info_bar_add_button (GTK_INFO_BAR (source->priv->info_bar), _("Fetch more tracks"), GTK_RESPONSE_OK);
gtk_container_add (GTK_CONTAINER (gtk_info_bar_get_content_area (GTK_INFO_BAR (source->priv->info_bar))),
source->priv->info_bar_label);
gtk_widget_show (GTK_WIDGET (source->priv->info_bar_label));
gtk_widget_set_no_show_all (GTK_WIDGET (source->priv->info_bar), TRUE);
g_signal_connect (source->priv->info_bar, "response", G_CALLBACK (fetch_more_cb), source);
/* don't allow the browser to be hidden? */
source->priv->paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
rb_source_bind_settings (RB_SOURCE (source), GTK_WIDGET (source->priv->entry_view), source->priv->paned, NULL);
gtk_paned_pack1 (GTK_PANED (source->priv->paned), browserbox, FALSE, FALSE);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (source->priv->entry_view), TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), source->priv->info_bar, FALSE, FALSE, 0);
gtk_paned_pack2 (GTK_PANED (source->priv->paned), vbox, TRUE, FALSE);
gtk_box_pack_start (GTK_BOX (mainbox), source->priv->paned, TRUE, TRUE, 0);
gtk_widget_show_all (GTK_WIDGET (source));
}
static GtkWidget *
create_infobar (PlumaWindow *window,
const gchar *version)
{
GtkWidget *infobar;
gchar *message;
#if !GTK_CHECK_VERSION (2, 17, 1)
infobar = pluma_message_area_new ();
pluma_message_area_add_stock_button_with_text (PLUMA_MESSAGE_AREA (infobar),
_("_Download"),
GTK_STOCK_SAVE,
GTK_RESPONSE_YES);
pluma_message_area_add_stock_button_with_text (PLUMA_MESSAGE_AREA (infobar),
_("_Ignore Version"),
GTK_STOCK_DISCARD,
GTK_RESPONSE_NO);
pluma_message_area_add_button (PLUMA_MESSAGE_AREA (infobar),
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
#else
GtkWidget *button;
infobar = gtk_info_bar_new ();
button = pluma_gtk_button_new_with_stock_icon (_("_Download"),
GTK_STOCK_SAVE);
gtk_widget_show (button);
gtk_info_bar_add_action_widget (GTK_INFO_BAR (infobar),
button,
GTK_RESPONSE_YES);
button = pluma_gtk_button_new_with_stock_icon (_("_Ignore Version"),
GTK_STOCK_DISCARD);
gtk_widget_show (button);
gtk_info_bar_add_action_widget (GTK_INFO_BAR (infobar),
button,
GTK_RESPONSE_NO);
gtk_info_bar_add_button (GTK_INFO_BAR (infobar),
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
gtk_info_bar_set_message_type (GTK_INFO_BAR (infobar),
GTK_MESSAGE_INFO);
#endif
message = g_strdup_printf ("%s (%s)", _("There is a new version of pluma"), version);
set_message_area_text_and_icon (infobar,
"gtk-dialog-info",
message,
_("You can download the new version of pluma"
" by clicking on the download button or"
" ignore that version and wait for a new one"));
g_free (message);
g_signal_connect (infobar, "response",
G_CALLBACK (on_response_cb),
window);
return infobar;
}
static void
theme_message_area_update (AppearanceData *data)
{
const MateThemeMetaInfo *theme;
gboolean show_apply_background = FALSE;
gboolean show_apply_font = FALSE;
gboolean show_revert_font = FALSE;
gboolean show_error;
const gchar *message;
gchar *font;
GError *error = NULL;
theme = theme_get_selected (GTK_ICON_VIEW (appearance_capplet_get_widget (data, "theme_list")), data);
if (!theme) {
if (data->theme_message_area != NULL)
gtk_widget_hide (data->theme_message_area);
return;
}
show_error = !mate_theme_meta_info_validate (theme, &error);
if (!show_error) {
if (theme->background_image != NULL) {
gchar *background;
background = mateconf_client_get_string (data->client, BACKGROUND_KEY, NULL);
show_apply_background =
(!background || strcmp (theme->background_image, background) != 0);
g_free (background);
}
if (theme->application_font) {
font = mateconf_client_get_string (data->client, APPLICATION_FONT_KEY, NULL);
show_apply_font =
(!font || strcmp (theme->application_font, font) != 0);
g_free (font);
}
if (!show_apply_font && theme->documents_font) {
font = mateconf_client_get_string (data->client, DOCUMENTS_FONT_KEY, NULL);
show_apply_font =
(!font || strcmp (theme->application_font, font) != 0);
g_free (font);
}
if (!show_apply_font && theme->desktop_font) {
font = mateconf_client_get_string (data->client, DESKTOP_FONT_KEY, NULL);
show_apply_font =
(!font || strcmp (theme->application_font, font) != 0);
g_free (font);
}
if (!show_apply_font && theme->windowtitle_font) {
font = mateconf_client_get_string (data->client, WINDOWTITLE_FONT_KEY, NULL);
show_apply_font =
(!font || strcmp (theme->application_font, font) != 0);
g_free (font);
}
if (!show_apply_font && theme->monospace_font) {
font = mateconf_client_get_string (data->client, MONOSPACE_FONT_KEY, NULL);
show_apply_font =
(!font || strcmp (theme->application_font, font) != 0);
g_free (font);
}
show_revert_font = (data->revert_application_font != NULL ||
data->revert_documents_font != NULL || data->revert_desktop_font != NULL ||
data->revert_windowtitle_font != NULL || data->revert_monospace_font != NULL);
}
if (data->theme_message_area == NULL) {
GtkWidget *hbox;
GtkWidget *parent;
GtkWidget *content;
if (!show_apply_background && !show_revert_font && !show_apply_font && !show_error)
return;
data->theme_message_area = gtk_info_bar_new ();
gtk_widget_set_no_show_all (data->theme_message_area, TRUE);
g_signal_connect (data->theme_message_area, "response",
(GCallback) theme_message_area_response_cb, data);
data->apply_background_button = gtk_info_bar_add_button (
GTK_INFO_BAR (data->theme_message_area),
_("Apply Background"),
RESPONSE_APPLY_BG);
data->apply_font_button = gtk_info_bar_add_button (
GTK_INFO_BAR (data->theme_message_area),
_("Apply Font"),
RESPONSE_APPLY_FONT);
data->revert_font_button = gtk_info_bar_add_button (
GTK_INFO_BAR (data->theme_message_area),
_("Revert Font"),
RESPONSE_REVERT_FONT);
data->install_button = gtk_info_bar_add_button (
GTK_INFO_BAR (data->theme_message_area),
_("Install"),
RESPONSE_INSTALL_ENGINE);
data->theme_message_label = gtk_label_new (NULL);
gtk_widget_show (data->theme_message_label);
gtk_label_set_line_wrap (GTK_LABEL (data->theme_message_label), TRUE);
gtk_misc_set_alignment (GTK_MISC (data->theme_message_label), 0.0, 0.5);
hbox = gtk_hbox_new (FALSE, 9);
gtk_widget_show (hbox);
data->theme_info_icon = gtk_image_new_from_stock (GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DIALOG);
data->theme_error_icon = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_DIALOG);
gtk_misc_set_alignment (GTK_MISC (data->theme_info_icon), 0.5, 0);
gtk_misc_set_alignment (GTK_MISC (data->theme_error_icon), 0.5, 0);
gtk_box_pack_start (GTK_BOX (hbox), data->theme_info_icon, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), data->theme_error_icon, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), data->theme_message_label, TRUE, TRUE, 0);
content = gtk_info_bar_get_content_area (GTK_INFO_BAR (data->theme_message_area));
gtk_container_add (GTK_CONTAINER (content), hbox);
parent = appearance_capplet_get_widget (data, "theme_list_vbox");
gtk_box_pack_start (GTK_BOX (parent), data->theme_message_area, FALSE, FALSE, 0);
}
if (show_error)
message = error->message;
else if (show_apply_background && show_apply_font && show_revert_font)
message = _("The current theme suggests a background and a font. Also, the last applied font suggestion can be reverted.");
else if (show_apply_background && show_revert_font)
message = _("The current theme suggests a background. Also, the last applied font suggestion can be reverted.");
else if (show_apply_background && show_apply_font)
message = _("The current theme suggests a background and a font.");
else if (show_apply_font && show_revert_font)
message = _("The current theme suggests a font. Also, the last applied font suggestion can be reverted.");
else if (show_apply_background)
message = _("The current theme suggests a background.");
else if (show_revert_font)
message = _("The last applied font suggestion can be reverted.");
else if (show_apply_font)
message = _("The current theme suggests a font.");
else
message = NULL;
if (show_apply_background)
gtk_widget_show (data->apply_background_button);
else
gtk_widget_hide (data->apply_background_button);
if (show_apply_font)
gtk_widget_show (data->apply_font_button);
else
gtk_widget_hide (data->apply_font_button);
if (show_revert_font)
gtk_widget_show (data->revert_font_button);
else
gtk_widget_hide (data->revert_font_button);
if (show_error
&& g_error_matches (error, MATE_THEME_ERROR, MATE_THEME_ERROR_GTK_ENGINE_NOT_AVAILABLE)
&& packagekit_available ())
gtk_widget_show (data->install_button);
else
gtk_widget_hide (data->install_button);
if (show_error || show_apply_background || show_apply_font || show_revert_font) {
gtk_widget_show (data->theme_message_area);
gtk_widget_queue_draw (data->theme_message_area);
if (show_error) {
gtk_widget_show (data->theme_error_icon);
gtk_widget_hide (data->theme_info_icon);
} else {
gtk_widget_show (data->theme_info_icon);
gtk_widget_hide (data->theme_error_icon);
}
} else {
gtk_widget_hide (data->theme_message_area);
}
gtk_label_set_text (GTK_LABEL (data->theme_message_label), message);
g_clear_error (&error);
}
static void
current_folder_changed_cb (GtkFileChooser *chooser, RBImportDialog *dialog)
{
GSettings *settings;
RBSource *source;
GtkWidget *label;
const char *uri;
char **locations;
int i;
uri = gtk_file_chooser_get_uri (chooser);
if (g_strcmp0 (uri, dialog->priv->current_uri) == 0)
return;
g_free (dialog->priv->current_uri);
dialog->priv->current_uri = g_strdup (uri);
if (dialog->priv->import_job != NULL) {
rhythmdb_import_job_cancel (dialog->priv->import_job);
}
clear_info_bar (dialog);
source = rb_shell_guess_source_for_uri (dialog->priv->shell, uri);
if (source != NULL) {
if (RB_IS_DEVICE_SOURCE (source)) {
char *msg;
char *name;
GtkWidget *content;
rhythmdb_entry_delete_by_type (dialog->priv->db, dialog->priv->entry_type);
rhythmdb_entry_delete_by_type (dialog->priv->db, dialog->priv->ignore_type);
rhythmdb_commit (dialog->priv->db);
dialog->priv->info_bar = gtk_info_bar_new ();
g_object_set (dialog->priv->info_bar, "hexpand", TRUE, NULL);
g_object_get (source, "name", &name, NULL);
/* this isn't a terribly helpful message. */
msg = g_strdup_printf (_("The location you have selected is on the device %s."), name);
label = gtk_label_new (msg);
g_free (msg);
content = gtk_info_bar_get_content_area (GTK_INFO_BAR (dialog->priv->info_bar));
gtk_container_add (GTK_CONTAINER (content), label);
msg = g_strdup_printf (_("Show %s"), name);
gtk_info_bar_add_button (GTK_INFO_BAR (dialog->priv->info_bar), msg, GTK_RESPONSE_ACCEPT);
g_free (msg);
g_signal_connect (dialog->priv->info_bar, "response", G_CALLBACK (device_info_bar_response_cb), dialog);
gtk_widget_show_all (dialog->priv->info_bar);
gtk_container_add (GTK_CONTAINER (dialog->priv->info_bar_container), dialog->priv->info_bar);
return;
}
}
/* disable copy if the selected location is already inside the library */
settings = g_settings_new ("org.gnome.rhythmbox.rhythmdb");
locations = g_settings_get_strv (settings, "locations");
gtk_widget_set_sensitive (dialog->priv->copy_check, TRUE);
for (i = 0; locations[i] != NULL; i++) {
if (g_str_has_prefix (uri, locations[i])) {
gtk_widget_set_sensitive (dialog->priv->copy_check, FALSE);
break;
}
}
g_strfreev (locations);
g_object_unref (settings);
if (dialog->priv->import_job != NULL) {
/* wait for the previous job to finish up */
rb_debug ("need to wait for previous import job to finish");
g_signal_connect (dialog->priv->import_job, "complete", G_CALLBACK (start_deferred_scan), dialog);
} else {
start_scanning (dialog);
}
}
static void update_message_area(AppearanceData* data)
{
GtkSettings* settings = gtk_settings_get_default();
gchar* theme = NULL;
gchar* engine;
g_object_get(settings, "gtk-theme-name", &theme, NULL);
engine = gtk_theme_info_missing_engine(theme, TRUE);
g_free(theme);
if (data->style_message_area == NULL)
{
GtkWidget* hbox;
GtkWidget* parent;
GtkWidget* icon;
GtkWidget* content;
if (engine == NULL)
{
return;
}
data->style_message_area = gtk_info_bar_new ();
g_signal_connect (data->style_message_area, "response", (GCallback) style_message_area_response_cb, data);
data->style_install_button = gtk_info_bar_add_button(GTK_INFO_BAR (data->style_message_area), _("Install"), GTK_RESPONSE_APPLY);
data->style_message_label = gtk_label_new (NULL);
gtk_label_set_line_wrap (GTK_LABEL (data->style_message_label), TRUE);
gtk_misc_set_alignment (GTK_MISC (data->style_message_label), 0.0, 0.5);
hbox = gtk_hbox_new (FALSE, 9);
icon = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_DIALOG);
gtk_misc_set_alignment (GTK_MISC (icon), 0.5, 0);
gtk_box_pack_start (GTK_BOX (hbox), icon, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), data->style_message_label, TRUE, TRUE, 0);
content = gtk_info_bar_get_content_area (GTK_INFO_BAR (data->style_message_area));
gtk_container_add (GTK_CONTAINER (content), hbox);
gtk_widget_show_all (data->style_message_area);
gtk_widget_set_no_show_all (data->style_message_area, TRUE);
parent = appearance_capplet_get_widget (data, "gtk_themes_vbox");
gtk_box_pack_start (GTK_BOX (parent), data->style_message_area, FALSE, FALSE, 0);
}
#if !GTK_CHECK_VERSION (3, 0, 0)
if (engine != NULL)
{
gchar* message = g_strdup_printf(_("This theme will not look as intended because the required GTK+ theme engine '%s' is not installed."), engine);
gtk_label_set_text(GTK_LABEL(data->style_message_label), message);
g_free(message);
g_free(engine);
if (packagekit_available())
{
gtk_widget_show(data->style_install_button);
}
else
{
gtk_widget_hide(data->style_install_button);
}
gtk_widget_show(data->style_message_area);
gtk_widget_queue_draw(data->style_message_area);
}
else
{
gtk_widget_hide(data->style_message_area);
}
#else
gtk_widget_hide(data->style_message_area);
#endif
}
