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
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);
}
/**
* 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);
}
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);
}
}
JNIEXPORT jlong JNICALL
Java_org_gnome_gtk_GtkInfoBar_gtk_1info_1bar_1get_1content_1area
(
JNIEnv* env,
jclass cls,
jlong _self
)
{
GtkWidget* result;
jlong _result;
GtkInfoBar* self;
// convert parameter self
self = (GtkInfoBar*) _self;
// call function
result = gtk_info_bar_get_content_area(self);
// cleanup parameter self
// 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;
}
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 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;
}
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;
}
/*! \private
* \brief Initialize GschemTranslateWidget instance
*
* \param [in,out] widget the GschemTranslateWidget
*/
static void
instance_init (GschemTranslateWidget *widget)
{
GtkWidget *action = gtk_info_bar_get_action_area (GTK_INFO_BAR (widget));
GtkWidget *button_box;
GtkWidget *cancel_button;
GtkWidget *content = gtk_info_bar_get_content_area (GTK_INFO_BAR (widget));
g_return_if_fail (widget != NULL);
gtk_widget_set_no_show_all (GTK_WIDGET (widget), TRUE);
widget->label = gtk_label_new (NULL);
gtk_widget_set_visible (widget->label, TRUE);
gtk_box_pack_start (GTK_BOX (content), widget->label, FALSE, FALSE, 0);
widget->entry = gtk_entry_new ();
gtk_widget_set_visible (widget->entry, TRUE);
gtk_box_pack_start (GTK_BOX (content), widget->entry, TRUE, TRUE, 0);
button_box = gtk_hbutton_box_new ();
gtk_widget_set_visible (button_box, TRUE);
gtk_box_pack_start (GTK_BOX (content), button_box, FALSE, FALSE, 0);
widget->evaluate_button = gtk_button_new_with_label (_("Translate"));
gtk_widget_set_sensitive (widget->evaluate_button, FALSE);
gtk_widget_set_visible (widget->evaluate_button, TRUE);
gtk_box_pack_start (GTK_BOX (button_box), widget->evaluate_button, FALSE, FALSE, 0);
cancel_button = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
gtk_widget_set_visible (cancel_button, TRUE);
gtk_box_pack_start (GTK_BOX (button_box), cancel_button, FALSE, FALSE, 0);
gtk_widget_set_no_show_all (action, TRUE);
gtk_widget_set_visible (action, FALSE);
g_signal_connect (G_OBJECT (widget->entry),
"activate",
G_CALLBACK (activate_entry),
widget);
g_signal_connect (G_OBJECT (cancel_button),
"clicked",
G_CALLBACK (click_cancel),
widget);
g_signal_connect (G_OBJECT (widget->evaluate_button),
"clicked",
G_CALLBACK (click_evaluate),
widget);
g_signal_connect (G_OBJECT (widget->entry),
"notify::text",
G_CALLBACK (notify_entry_text),
widget);
}
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);
}
static void
set_contents (GtkWidget *area,
GtkWidget *contents)
{
#if !GTK_CHECK_VERSION (2, 17, 1)
gedit_message_area_set_contents (GEDIT_MESSAGE_AREA (area),
contents);
#else
GtkWidget *content_area;
content_area = gtk_info_bar_get_content_area (GTK_INFO_BAR (area));
gtk_container_add (GTK_CONTAINER (content_area), contents);
#endif
}
static void
set_contents (GtkWidget *infobar,
GtkWidget *contents)
{
#if !GTK_CHECK_VERSION (2, 17, 1)
pluma_message_area_set_contents (PLUMA_MESSAGE_AREA (infobar),
contents);
#else
GtkWidget *content_area;
content_area = gtk_info_bar_get_content_area (GTK_INFO_BAR (infobar));
gtk_container_add (GTK_CONTAINER (content_area), contents);
#endif
}
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;
}
void
InterfaceGtk::main(int &argc, char **&argv)
{
GtkWidget *vbox;
GtkWidget *info_content;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), PACKAGE_NAME);
g_signal_connect(G_OBJECT(window), "delete-event",
G_CALLBACK(exit_app), NULL);
vbox = gtk_vbox_new(FALSE, 0);
editor_widget = scintilla_new();
scintilla_set_id(SCINTILLA(editor_widget), 0);
gtk_widget_set_usize(editor_widget, 500, 300);
gtk_widget_set_can_focus(editor_widget, FALSE);
g_signal_connect(G_OBJECT(editor_widget), SCINTILLA_NOTIFY,
G_CALLBACK(scintilla_notify), NULL);
gtk_box_pack_start(GTK_BOX(vbox), editor_widget, TRUE, TRUE, 0);
info_widget = gtk_info_bar_new();
info_content = gtk_info_bar_get_content_area(GTK_INFO_BAR(info_widget));
message_widget = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(message_widget), 0., 0.);
gtk_container_add(GTK_CONTAINER(info_content), message_widget);
gtk_box_pack_start(GTK_BOX(vbox), info_widget, FALSE, FALSE, 0);
cmdline_widget = gtk_entry_new();
gtk_entry_set_has_frame(GTK_ENTRY(cmdline_widget), FALSE);
gtk_editable_set_editable(GTK_EDITABLE(cmdline_widget), FALSE);
widget_set_font(cmdline_widget, "Courier");
g_signal_connect(G_OBJECT(cmdline_widget), "key-press-event",
G_CALLBACK(cmdline_key_pressed), NULL);
gtk_box_pack_start(GTK_BOX(vbox), cmdline_widget, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), vbox);
popup_widget = gtk_info_popup_new(cmdline_widget);
gtk_widget_grab_focus(cmdline_widget);
ssm(SCI_SETFOCUS, TRUE);
cmdline_update("");
}
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
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
bisho_pane_init (BishoPane *pane)
{
GtkWidget *align, *banner_content;
gtk_box_set_spacing (GTK_BOX (pane), 8);
pane->description = mux_label_new ();
gtk_widget_show (pane->description);
gtk_box_pack_start (GTK_BOX (pane), pane->description, FALSE, FALSE, 0);
align = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
gtk_widget_show (align);
pane->banner = gtk_info_bar_new ();
gtk_container_add (GTK_CONTAINER (align), pane->banner);
gtk_box_pack_start (GTK_BOX (pane), align, FALSE, FALSE, 0);
pane->banner_label = gtk_label_new (NULL);
gtk_label_set_line_wrap (GTK_LABEL (pane->banner_label), TRUE);
gtk_widget_show (pane->banner_label);
banner_content = gtk_info_bar_get_content_area (GTK_INFO_BAR (pane->banner));
gtk_container_add (GTK_CONTAINER (banner_content), pane->banner_label);
align = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
gtk_alignment_set_padding (GTK_ALIGNMENT (align), 0, 0, 32, 0);
gtk_widget_show (align);
pane->user_box = gtk_hbox_new (FALSE, 0);
pane->user_icon = gtk_image_new ();
gtk_widget_show (pane->user_icon);
gtk_box_pack_start (GTK_BOX (pane->user_box), pane->user_icon, FALSE, FALSE, 8);
pane->user_name = gtk_label_new (NULL);
gtk_box_pack_start (GTK_BOX (pane->user_box), pane->user_name, TRUE, TRUE, 8);
gtk_container_add (GTK_CONTAINER (align), pane->user_box);
gtk_box_pack_start (GTK_BOX (pane), align, FALSE, FALSE, 0);
pane->content = gtk_alignment_new (0.0, 0.0, 0.0, 0.0);
gtk_alignment_set_padding (GTK_ALIGNMENT (pane->content), 0, 0, 64, 64);
gtk_widget_show (pane->content);
gtk_box_pack_start (GTK_BOX (pane), pane->content, TRUE, TRUE, 0);
pane->disclaimer = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (pane->disclaimer), 0.0, 0.5);
gtk_misc_set_padding (GTK_MISC (pane->disclaimer), 6, 6);
gtk_widget_show (pane->disclaimer);
gtk_box_pack_start (GTK_BOX (pane), pane->disclaimer, FALSE, TRUE, 0);
}
static void
gedit_progress_message_area_init (GeditProgressMessageArea *area)
{
GtkWidget *vbox;
GtkWidget *hbox;
area->priv = GEDIT_PROGRESS_MESSAGE_AREA_GET_PRIVATE (area);
vbox = gtk_vbox_new (FALSE, 6);
gtk_widget_show (vbox);
hbox = gtk_hbox_new (FALSE, 4);
gtk_widget_show (hbox);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
area->priv->image = gtk_image_new_from_icon_name (GTK_STOCK_MISSING_IMAGE,
GTK_ICON_SIZE_SMALL_TOOLBAR);
gtk_widget_show (area->priv->image);
gtk_misc_set_alignment (GTK_MISC (area->priv->image), 0.5, 0.5);
gtk_box_pack_start (GTK_BOX (hbox), area->priv->image, FALSE, FALSE, 4);
area->priv->label = gtk_label_new ("");
gtk_widget_show (area->priv->label);
gtk_box_pack_start (GTK_BOX (hbox), area->priv->label, TRUE, TRUE, 0);
gtk_label_set_use_markup (GTK_LABEL (area->priv->label), TRUE);
gtk_misc_set_alignment (GTK_MISC (area->priv->label), 0, 0.5);
gtk_label_set_ellipsize (GTK_LABEL (area->priv->label),
PANGO_ELLIPSIZE_END);
area->priv->progress = gtk_progress_bar_new ();
gtk_widget_show (area->priv->progress);
gtk_box_pack_start (GTK_BOX (vbox), area->priv->progress, TRUE, FALSE, 0);
gtk_widget_set_size_request (area->priv->progress, -1, 15);
#if !GTK_CHECK_VERSION (2, 17, 1)
gedit_message_area_set_contents (GEDIT_MESSAGE_AREA (area),
vbox);
#else
GtkWidget *content;
content = gtk_info_bar_get_content_area (GTK_INFO_BAR (area));
gtk_container_add (GTK_CONTAINER (content), vbox);
#endif
}
ColorVisionDeficiencyConfig::ColorVisionDeficiencyConfig(ColorVisionDeficiency &transformation){
GtkWidget *table = gtk_table_new(2, 2, false);
GtkWidget *widget;
int table_y = 0;
table_y = 0;
gtk_table_attach(GTK_TABLE(table), gtk_label_aligned_new(_("Type:"), 0, 0.5, 0, 0), 0, 1, table_y, table_y + 1, GTK_FILL, GTK_FILL, 5, 5);
type = widget = create_type_list();
g_signal_connect(G_OBJECT(type), "changed", G_CALLBACK(ColorVisionDeficiencyConfig::type_combobox_change_cb), this);
gtk_table_attach(GTK_TABLE(table), widget, 1, 2, table_y, table_y + 1, GtkAttachOptions(GTK_FILL | GTK_EXPAND), GTK_FILL, 5, 0);
table_y++;
info_bar = widget = gtk_info_bar_new();
info_label = gtk_label_new("");
gtk_label_set_line_wrap(GTK_LABEL(info_label), true);
gtk_label_set_justify(GTK_LABEL(info_label), GTK_JUSTIFY_LEFT);
gtk_label_set_single_line_mode(GTK_LABEL(info_label), false);
gtk_misc_set_alignment(GTK_MISC(info_label), 0, 0.5);
gtk_widget_set_size_request(info_label, 1, -1);
GtkWidget *content_area = gtk_info_bar_get_content_area(GTK_INFO_BAR(info_bar));
gtk_container_add(GTK_CONTAINER(content_area), info_label);
gtk_widget_show_all(info_bar);
g_signal_connect(G_OBJECT(info_label), "size-allocate", G_CALLBACK(info_label_size_allocate_cb), this);
gtk_table_attach(GTK_TABLE(table), widget, 1, 2, table_y, table_y + 1, GtkAttachOptions(GTK_FILL | GTK_EXPAND), GTK_FILL, 5, 0);
table_y++;
gtk_combo_box_set_active(GTK_COMBO_BOX(type), transformation.type);
gtk_table_attach(GTK_TABLE(table), gtk_label_aligned_new(_("Strength:"), 0, 0.5, 0, 0), 0, 1, table_y, table_y + 1, GTK_FILL, GTK_FILL, 5, 5);
strength = widget = gtk_hscale_new_with_range(0, 100, 1);
gtk_range_set_value(GTK_RANGE(widget), transformation.strength * 100);
gtk_table_attach(GTK_TABLE(table), widget, 1, 2, table_y, table_y + 1, GtkAttachOptions(GTK_FILL | GTK_EXPAND), GTK_FILL, 5, 0);
table_y++;
main = table;
gtk_widget_show_all(main);
g_object_ref(main);
}
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;
}
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
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);
}
bool wxInfoBar::Create(wxWindow *parent, wxWindowID winid)
{
if ( !UseNative() )
return wxInfoBarGeneric::Create(parent, winid);
m_impl = new wxInfoBarGTKImpl;
// this control is created initially hidden
Hide();
if ( !CreateBase(parent, winid) )
return false;
// create the info bar widget itself
m_widget = gtk_info_bar_new();
wxCHECK_MSG( m_widget, false, "failed to create GtkInfoBar" );
g_object_ref(m_widget);
// also create a label which will be used to show our message
m_impl->m_label = gtk_label_new("");
gtk_widget_show(m_impl->m_label);
GtkWidget * const
contentArea = gtk_info_bar_get_content_area(GTK_INFO_BAR(m_widget));
wxCHECK_MSG( contentArea, false, "failed to get GtkInfoBar content area" );
gtk_container_add(GTK_CONTAINER(contentArea), m_impl->m_label);
// finish creation and connect to all the signals we're interested in
m_parent->DoAddChild(this);
PostCreation(wxDefaultSize);
GTKConnectWidget("response", G_CALLBACK(wxgtk_infobar_response));
GTKConnectWidget("close", G_CALLBACK(wxgtk_infobar_close));
return true;
}
static void
rb_import_errors_source_constructed (GObject *object)
{
GObject *shell_player;
RBImportErrorsSource *source;
RBShell *shell;
GPtrArray *query;
RhythmDBQueryModel *model;
RhythmDBEntryType *entry_type;
GtkWidget *box;
GtkWidget *label;
RB_CHAIN_GOBJECT_METHOD (rb_import_errors_source_parent_class, constructed, object);
source = RB_IMPORT_ERRORS_SOURCE (object);
g_object_get (source,
"shell", &shell,
"entry-type", &entry_type,
NULL);
g_object_get (shell, "db", &source->priv->db, NULL);
shell_player = rb_shell_get_player (shell);
g_object_unref (shell);
/* construct real query */
query = rhythmdb_query_parse (source->priv->db,
RHYTHMDB_QUERY_PROP_EQUALS,
RHYTHMDB_PROP_TYPE,
entry_type,
RHYTHMDB_QUERY_END);
model = rhythmdb_query_model_new (source->priv->db, query,
(GCompareDataFunc) rhythmdb_query_model_string_sort_func,
GUINT_TO_POINTER (RHYTHMDB_PROP_LOCATION), NULL, FALSE);
rhythmdb_query_free (query);
/* set up entry view */
source->priv->view = rb_entry_view_new (source->priv->db, shell_player,
NULL, FALSE, FALSE);
rb_entry_view_set_model (source->priv->view, model);
rb_entry_view_append_column (source->priv->view, RB_ENTRY_VIEW_COL_LOCATION, TRUE);
rb_entry_view_append_column (source->priv->view, RB_ENTRY_VIEW_COL_ERROR, TRUE);
g_signal_connect_object (source->priv->view, "show_popup",
G_CALLBACK (rb_import_errors_source_songs_show_popup_cb), source, 0);
g_object_set (source, "query-model", model, NULL);
g_object_unref (model);
/* set up query model for tracking missing plugin information */
query = rhythmdb_query_parse (source->priv->db,
RHYTHMDB_QUERY_PROP_EQUALS,
RHYTHMDB_PROP_TYPE,
entry_type,
RHYTHMDB_QUERY_PROP_NOT_EQUAL,
RHYTHMDB_PROP_COMMENT,
"",
RHYTHMDB_QUERY_END);
source->priv->missing_plugin_model = rhythmdb_query_model_new_empty (source->priv->db);
rhythmdb_do_full_query_async_parsed (source->priv->db,
RHYTHMDB_QUERY_RESULTS (source->priv->missing_plugin_model),
query);
rhythmdb_query_free (query);
/* set up info bar for triggering codec installation */
source->priv->infobar = gtk_info_bar_new_with_buttons (_("Install Plugins"), GTK_RESPONSE_OK, NULL);
g_signal_connect_object (source->priv->infobar,
"response",
G_CALLBACK (infobar_response_cb),
source, 0);
label = gtk_label_new (_("Additional GStreamer plugins are required to play some of these files."));
gtk_container_add (GTK_CONTAINER (gtk_info_bar_get_content_area (GTK_INFO_BAR (source->priv->infobar))),
label);
g_object_unref (entry_type);
box = gtk_vbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (box), GTK_WIDGET (source->priv->view), TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box), source->priv->infobar, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (source), box);
gtk_widget_show_all (GTK_WIDGET (source));
gtk_widget_hide (source->priv->infobar);
/* show the info bar when there are missing plugin entries */
g_signal_connect_object (source->priv->missing_plugin_model,
"row-inserted",
G_CALLBACK (missing_plugin_row_inserted_cb),
source, 0);
g_signal_connect_object (source->priv->missing_plugin_model,
"row-deleted",
G_CALLBACK (missing_plugin_row_deleted_cb),
source, 0);
}
static void
impl_constructed (GObject *object)
{
RBPodcastAddDialog *dialog;
GtkBuilder *builder;
GtkWidget *widget;
GtkWidget *paned;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
RBEntryView *episodes;
RBShellPlayer *shell_player;
RhythmDBQuery *query;
RhythmDBQueryModel *query_model;
const char *episode_strings[3];
RB_CHAIN_GOBJECT_METHOD (rb_podcast_add_dialog_parent_class, constructed, object);
dialog = RB_PODCAST_ADD_DIALOG (object);
g_object_get (dialog->priv->podcast_mgr, "db", &dialog->priv->db, NULL);
builder = rb_builder_load ("podcast-add-dialog.ui", NULL);
dialog->priv->info_bar_message = gtk_label_new ("");
dialog->priv->info_bar = gtk_info_bar_new ();
g_object_set (dialog->priv->info_bar, "spacing", 0, NULL);
gtk_container_add (GTK_CONTAINER (gtk_info_bar_get_content_area (GTK_INFO_BAR (dialog->priv->info_bar))),
dialog->priv->info_bar_message);
gtk_widget_set_no_show_all (dialog->priv->info_bar, TRUE);
gtk_box_pack_start (GTK_BOX (dialog), dialog->priv->info_bar, FALSE, FALSE, 0);
gtk_widget_show (dialog->priv->info_bar_message);
dialog->priv->subscribe_button = GTK_WIDGET (gtk_builder_get_object (builder, "subscribe-button"));
g_signal_connect_object (dialog->priv->subscribe_button, "clicked", G_CALLBACK (subscribe_clicked_cb), dialog, 0);
gtk_widget_set_sensitive (dialog->priv->subscribe_button, FALSE);
dialog->priv->feed_view = GTK_WIDGET (gtk_builder_get_object (builder, "feed-view"));
g_signal_connect (dialog->priv->feed_view, "row-activated", G_CALLBACK (feed_activated_cb), dialog);
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->priv->feed_view)),
"changed",
G_CALLBACK (feed_selection_changed_cb),
dialog);
dialog->priv->search_entry = rb_search_entry_new (FALSE);
gtk_widget_set_size_request (GTK_WIDGET (dialog->priv->search_entry), 400, -1);
g_object_set (dialog->priv->search_entry,"explicit-mode", TRUE, NULL);
g_signal_connect (dialog->priv->search_entry, "search", G_CALLBACK (search_cb), dialog);
g_signal_connect (dialog->priv->search_entry, "activate", G_CALLBACK (search_cb), dialog);
gtk_container_add (GTK_CONTAINER (gtk_builder_get_object (builder, "search-entry-box")),
GTK_WIDGET (dialog->priv->search_entry));
g_signal_connect (gtk_builder_get_object (builder, "close-button"),
"clicked",
G_CALLBACK (close_clicked_cb),
dialog);
dialog->priv->feed_model = gtk_list_store_new (7,
G_TYPE_STRING, /* name */
G_TYPE_STRING, /* author */
GDK_TYPE_PIXBUF, /* image */
G_TYPE_FILE, /* image file */
G_TYPE_INT, /* episode count */
G_TYPE_POINTER, /* RBPodcastChannel */
G_TYPE_ULONG); /* date */
gtk_tree_view_set_model (GTK_TREE_VIEW (dialog->priv->feed_view), GTK_TREE_MODEL (dialog->priv->feed_model));
column = gtk_tree_view_column_new_with_attributes (_("Title"), gtk_cell_renderer_pixbuf_new (), "pixbuf", FEED_COLUMN_IMAGE, NULL);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer, "text", FEED_COLUMN_TITLE, NULL);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->priv->feed_view), column);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
column = gtk_tree_view_column_new_with_attributes (_("Author"), renderer, "text", FEED_COLUMN_AUTHOR, NULL);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->priv->feed_view), column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Episodes"), renderer, NULL);
gtk_tree_view_column_set_cell_data_func (column, renderer, episode_count_column_cell_data_func, NULL, NULL);
episode_strings[0] = "0000";
episode_strings[1] = _("Episodes");
episode_strings[2] = NULL;
rb_set_tree_view_column_fixed_width (dialog->priv->feed_view, column, renderer, episode_strings, 6);
gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->priv->feed_view), column);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "podcast-add-dialog"));
gtk_box_pack_start (GTK_BOX (dialog), widget, TRUE, TRUE, 0);
/* set up episode view */
g_object_get (dialog->priv->shell, "shell-player", &shell_player, NULL);
episodes = rb_entry_view_new (dialog->priv->db, G_OBJECT (shell_player), TRUE, FALSE);
g_object_unref (shell_player);
g_signal_connect (episodes, "entry-activated", G_CALLBACK (episode_entry_activated_cb), dialog);
/* date column */
column = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_clickable (column, TRUE);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
{
const char *sample_strings[3];
sample_strings[0] = _("Date");
sample_strings[1] = rb_entry_view_get_time_date_column_sample ();
sample_strings[2] = NULL;
rb_entry_view_set_fixed_column_width (episodes, column, renderer, sample_strings);
}
gtk_tree_view_column_set_cell_data_func (column, renderer,
(GtkTreeCellDataFunc) podcast_post_date_cell_data_func,
dialog, NULL);
rb_entry_view_append_column_custom (episodes, column,
_("Date"), "Date",
(GCompareDataFunc) podcast_post_date_sort_func,
0, NULL);
rb_entry_view_append_column (episodes, RB_ENTRY_VIEW_COL_TITLE, TRUE);
rb_entry_view_append_column (episodes, RB_ENTRY_VIEW_COL_DURATION, TRUE);
rb_entry_view_set_sorting_order (RB_ENTRY_VIEW (episodes), "Date", GTK_SORT_DESCENDING);
g_signal_connect (episodes,
"notify::sort-order",
G_CALLBACK (episodes_sort_changed_cb),
dialog);
query = rhythmdb_query_parse (dialog->priv->db,
RHYTHMDB_QUERY_PROP_EQUALS,
RHYTHMDB_PROP_TYPE,
RHYTHMDB_ENTRY_TYPE_PODCAST_SEARCH,
RHYTHMDB_QUERY_END);
query_model = rhythmdb_query_model_new_empty (dialog->priv->db);
rb_entry_view_set_model (episodes, query_model);
rhythmdb_do_full_query_async_parsed (dialog->priv->db, RHYTHMDB_QUERY_RESULTS (query_model), query);
rhythmdb_query_free (query);
g_object_unref (query_model);
paned = GTK_WIDGET (gtk_builder_get_object (builder, "paned"));
g_signal_connect (paned, "size-allocate", G_CALLBACK (paned_size_allocate_cb), dialog);
gtk_paned_pack2 (GTK_PANED (paned),
GTK_WIDGET (episodes),
TRUE,
FALSE);
gtk_widget_show_all (GTK_WIDGET (dialog));
g_object_unref (builder);
}
GtkWidget *gtkui_cheats() {
// Create the Cheats window
if (cheatwindow) { return NULL; }
cheatwindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW (cheatwindow), "Cheat Manager");
GtkWidget *cheatbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add(GTK_CONTAINER(cheatwindow), cheatbox);
GtkWidget *scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_box_pack_start(GTK_BOX(cheatbox), scrolledwindow, TRUE, TRUE, 0);
gtk_widget_set_size_request(scrolledwindow, 512, 256);
treeview = gtk_tree_view_new();
gtk_container_add(GTK_CONTAINER (scrolledwindow), treeview);
infobar = gtk_info_bar_new();
infolabel = gtk_widget_new(GTK_TYPE_LABEL,"label", "", NULL);
gtk_box_pack_start(GTK_BOX(cheatbox), infobar, TRUE, TRUE, 0);
GtkWidget *content_area = gtk_info_bar_get_content_area(GTK_INFO_BAR(infobar));
gtk_box_pack_start(GTK_BOX(content_area), infolabel, TRUE, TRUE, 0);
GtkWidget *opensavebox = gtk_widget_new(GTK_TYPE_BOX, "halign", GTK_ALIGN_END, NULL);
gtk_box_pack_start(GTK_BOX(cheatbox), opensavebox, FALSE, FALSE, 0);
GtkWidget *cheatopen = gtk_widget_new(
GTK_TYPE_BUTTON,
"label", "Open",
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(opensavebox), cheatopen, FALSE, FALSE, 0);
GtkWidget *cheatclear = gtk_widget_new(
GTK_TYPE_BUTTON,
"label", "Clear",
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(opensavebox), cheatclear, FALSE, FALSE, 0);
GtkWidget *cheatremove = gtk_widget_new(
GTK_TYPE_BUTTON,
"label", "Remove",
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(opensavebox), cheatremove, FALSE, FALSE, 0);
GtkWidget *descbox = gtk_widget_new(
GTK_TYPE_BOX,
"halign", GTK_ALIGN_END,
NULL);
gtk_box_pack_start(GTK_BOX(cheatbox), descbox, FALSE, FALSE, 0);
GtkWidget *desclabel = gtk_widget_new(
GTK_TYPE_LABEL,
"label", "Description:",
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-left", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(descbox), desclabel, FALSE, FALSE, 0);
descedit = gtk_widget_new(
GTK_TYPE_ENTRY,
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(descbox), descedit, TRUE, TRUE, 0);
GtkWidget *ggbox = gtk_widget_new(
GTK_TYPE_BOX,
"halign", GTK_ALIGN_END,
NULL);
gtk_box_pack_start(GTK_BOX(cheatbox), ggbox, FALSE, FALSE, 0);
GtkWidget *gglabel = gtk_widget_new(
GTK_TYPE_LABEL,
"label", "Game Genie:",
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-left", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(ggbox), gglabel, FALSE, FALSE, 0);
ggedit = gtk_widget_new(
GTK_TYPE_ENTRY,
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(ggbox), ggedit, TRUE, TRUE, 0);
GtkWidget *genieadd = gtk_widget_new(
GTK_TYPE_BUTTON,
"label", "Add",
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(ggbox), genieadd, FALSE, FALSE, 0);
GtkWidget *parbox = gtk_widget_new(
GTK_TYPE_BOX,
"halign", GTK_ALIGN_END,
NULL);
gtk_box_pack_start(GTK_BOX(cheatbox), parbox, FALSE, FALSE, 0);
GtkWidget *parlabel = gtk_widget_new(
GTK_TYPE_LABEL,
"label", "Pro Action Rocky:",
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-left", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(parbox), parlabel, FALSE, FALSE, 0);
paredit = gtk_widget_new(
GTK_TYPE_ENTRY,
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(parbox), paredit, FALSE, FALSE, 0);
GtkWidget *paradd = gtk_widget_new(
GTK_TYPE_BUTTON,
"label", "Add",
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(parbox), paradd, FALSE, FALSE, 0);
GtkWidget *cheatok = gtk_widget_new(
GTK_TYPE_BUTTON,
"label", "OK",
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(cheatbox), cheatok, FALSE, FALSE, 0);
gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(treeview), FALSE);
treestore = gtk_tree_store_new(5, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
gtk_tree_view_set_model(GTK_TREE_VIEW(treeview), GTK_TREE_MODEL(treestore));
GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
GtkCellRenderer *checkbox = gtk_cell_renderer_toggle_new();
GtkTreeViewColumn *column[5];
// create the display columns
column[0] = gtk_tree_view_column_new_with_attributes("Enable", checkbox, "active", 0, NULL);
column[1] = gtk_tree_view_column_new_with_attributes("Game Genie", renderer, "text", 1, NULL);
column[2] = gtk_tree_view_column_new_with_attributes("PAR", renderer, "text", 2, NULL);
column[3] = gtk_tree_view_column_new_with_attributes("Raw", renderer, "text", 3, NULL);
column[4] = gtk_tree_view_column_new_with_attributes("Description", renderer, "text", 4, NULL);
// add the display column and renderer to the tree view
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column[0]);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column[1]);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column[2]);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column[3]);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column[4]);
gtkui_cheats_fill_tree(nstpaths.cheatpath);
/*g_signal_connect(G_OBJECT(checkbox), "toggled",
G_CALLBACK(gtkui_cheats_check), NULL);*/
g_signal_connect(G_OBJECT(treeview), "row-activated",
G_CALLBACK(gtkui_cheats_toggle), NULL);
g_signal_connect(G_OBJECT(cheatopen), "clicked",
G_CALLBACK(gtkui_cheats_load), NULL);
g_signal_connect(G_OBJECT(cheatclear), "clicked",
G_CALLBACK(gtkui_cheats_clear), NULL);
g_signal_connect(G_OBJECT(cheatremove), "clicked",
G_CALLBACK(gtkui_cheats_remove), NULL);
g_signal_connect(G_OBJECT(genieadd), "clicked",
G_CALLBACK(gtkui_cheats_gg_add), NULL);
g_signal_connect(G_OBJECT(paradd), "clicked",
G_CALLBACK(gtkui_cheats_par_add), NULL);
g_signal_connect(G_OBJECT(cheatok), "clicked",
G_CALLBACK(gtkui_cheats_ok), NULL);
g_signal_connect(G_OBJECT(cheatwindow), "destroy",
G_CALLBACK(gtkui_cheats_ok), NULL);
gtk_widget_show_all(cheatwindow);
gtk_widget_hide(infobar);
return cheatwindow;
}
/**
* 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);
}
static void
set_message_area_text_and_icon (GtkInfoBar *message_area,
const gchar *icon_stock_id,
const gchar *primary_text,
const gchar *secondary_text)
{
GtkWidget *hbox_content;
GtkWidget *image;
GtkWidget *vbox;
gchar *primary_markup;
gchar *secondary_markup;
GtkWidget *primary_label;
GtkWidget *secondary_label;
hbox_content = gtk_hbox_new (FALSE, 8);
gtk_widget_show (hbox_content);
image = gtk_image_new_from_stock (icon_stock_id, GTK_ICON_SIZE_DIALOG);
gtk_widget_show (image);
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_widget_show (vbox);
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_widget_show (primary_label);
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), FALSE);
gtk_misc_set_alignment (GTK_MISC (primary_label), 0, 0.5);
gtk_widget_set_can_focus (primary_label, TRUE);
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_widget_show (secondary_label);
gtk_box_pack_start (GTK_BOX (vbox), secondary_label, TRUE, TRUE, 0);
gtk_widget_set_can_focus (secondary_label, TRUE);
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_box_pack_start (GTK_BOX (gtk_info_bar_get_content_area (GTK_INFO_BAR (message_area))), hbox_content, TRUE, TRUE, 0);
}
