static void
populate_flowbox_wrappy (GtkFlowBox *flowbox)
{
GtkWidget *widget, *frame;
gint i;
const gchar *strings[] = {
"These are", "some wrappy label", "texts", "of various", "lengths.",
"They should always be", "shown", "consecutively. Except it's",
"hard to say", "where exactly the", "label", "will wrap", "and where exactly",
"the actual", "container", "will wrap.", "This label is really really really long !",
"Let's add some more", "labels to the",
"mix. Just to", "make sure we", "got something to work", "with here."
};
for (i = 0; i < G_N_ELEMENTS (strings); i++)
{
widget = gtk_label_new (strings[i]);
frame = gtk_frame_new (NULL);
gtk_widget_show (widget);
gtk_widget_show (frame);
if (text_orientation == GTK_ORIENTATION_VERTICAL)
gtk_label_set_angle (GTK_LABEL (widget), 90);
gtk_container_add (GTK_CONTAINER (frame), widget);
gtk_label_set_line_wrap (GTK_LABEL (widget), TRUE);
gtk_label_set_line_wrap_mode (GTK_LABEL (widget), PANGO_WRAP_WORD);
gtk_label_set_width_chars (GTK_LABEL (widget), 10);
g_object_set_data_full (G_OBJECT (frame), "id", (gpointer)g_strdup (strings[i]), g_free);
gtk_container_add (GTK_CONTAINER (flowbox), frame);
}
}
static void
hildon_banner_init (HildonBanner *self)
{
HildonBannerPrivate *priv = HILDON_BANNER_GET_PRIVATE (self);
g_assert (priv);
priv->parent = NULL;
priv->overrides_dnd = FALSE;
priv->require_override_dnd = FALSE;
priv->name_suffix = NULL;
priv->main_item = NULL;
/* Initialize the common layout inside banner */
priv->alignment = gtk_alignment_new (0.5, 0.5, 0, 0);
priv->layout = gtk_hbox_new (FALSE, HILDON_MARGIN_DEFAULT);
priv->label = g_object_new (GTK_TYPE_LABEL, NULL);
gtk_label_set_line_wrap (GTK_LABEL (priv->label), TRUE);
gtk_label_set_line_wrap_mode (GTK_LABEL (priv->label), PANGO_WRAP_WORD_CHAR);
gtk_label_set_justify (GTK_LABEL (priv->label), GTK_JUSTIFY_CENTER);
gtk_container_set_border_width (GTK_CONTAINER (priv->layout), HILDON_MARGIN_DEFAULT);
gtk_container_add (GTK_CONTAINER (self), priv->alignment);
gtk_container_add (GTK_CONTAINER (priv->alignment), priv->layout);
g_object_ref (priv->label);
gtk_box_pack_start (GTK_BOX (priv->layout), priv->label, FALSE, FALSE, 0);
gtk_window_set_accept_focus (GTK_WINDOW (self), FALSE);
gtk_widget_add_events (GTK_WIDGET (self), GDK_BUTTON_PRESS_MASK);
}
/**
* gtk_ellipsis_set_label:
* @ellipsis: a #GtkEllipsis
* @label: a string
*
* Sets the text of the label of the ellipsis to @label.
*
* This will also clear any previously set labels.
*
* Since: 2.4
**/
void
gtk_ellipsis_set_label (GtkEllipsis *ellipsis,
const gchar *label)
{
g_return_if_fail (GTK_IS_ELLIPSIS (ellipsis));
if (!label)
{
gtk_ellipsis_set_label_widget (ellipsis, NULL);
}
else
{
GtkWidget *child;
child = gtk_label_new (label);
gtk_label_set_line_wrap (GTK_LABEL (child), TRUE);
gtk_label_set_line_wrap_mode (GTK_LABEL (child), ellipsis->priv->wrap_mode);
gtk_label_set_use_underline (GTK_LABEL (child), ellipsis->priv->use_underline);
gtk_label_set_use_markup (GTK_LABEL (child), ellipsis->priv->use_markup);
gtk_widget_show (child);
gtk_ellipsis_set_label_widget (ellipsis, child);
}
g_object_notify (G_OBJECT (ellipsis), "label");
}
static void cookie_manager_page_init(CookieManagerPage *self)
{
GtkWidget *tree_swin;
GtkWidget *desc_swin;
GtkWidget *paned;
GtkWidget *filter_hbox;
GtkWidget *treeview;
CookieManagerPagePrivate *priv;
self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
COOKIE_MANAGER_PAGE_TYPE, CookieManagerPagePrivate);
priv = self->priv;
priv->ignore_changed_filter = FALSE;
cm_create_toolbar(self);
priv->desc_label = gtk_label_new(CM_EMPTY_LABEL_TEXT);
gtk_label_set_selectable(GTK_LABEL(priv->desc_label), TRUE);
gtk_label_set_line_wrap(GTK_LABEL(priv->desc_label), TRUE);
gtk_label_set_line_wrap_mode(GTK_LABEL(priv->desc_label), PANGO_WRAP_CHAR);
gtk_misc_set_alignment(GTK_MISC(priv->desc_label), 0, 0);
gtk_misc_set_padding(GTK_MISC(priv->desc_label), 3, 3);
gtk_widget_show(priv->desc_label);
desc_swin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(desc_swin),
GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(desc_swin), GTK_SHADOW_NONE);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(desc_swin), priv->desc_label);
gtk_widget_show(desc_swin);
treeview = cm_tree_prepare(self);
gtk_widget_show(treeview);
tree_swin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(tree_swin),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(tree_swin), treeview);
gtk_widget_show(tree_swin);
priv->filter_entry = sokoke_search_entry_new (_("Search Cookies by Name or Domain"));
gtk_widget_show(priv->filter_entry);
g_signal_connect(priv->filter_entry, "changed", G_CALLBACK(cm_filter_entry_changed_cb), self);
g_signal_connect(priv->filter_entry, "activate", G_CALLBACK(cm_filter_entry_changed_cb), self);
filter_hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(filter_hbox), priv->filter_entry, TRUE, TRUE, 3);
gtk_widget_show(filter_hbox);
paned = gtk_vpaned_new();
gtk_paned_pack1(GTK_PANED(paned), tree_swin, TRUE, FALSE);
gtk_paned_pack2(GTK_PANED(paned), desc_swin, FALSE, FALSE);
gtk_widget_show(paned);
gtk_box_pack_start(GTK_BOX(self), filter_hbox, FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(self), paned, TRUE, TRUE, 0);
}
void show_error_dialog(GmpvApplication *app, const gchar *prefix, const gchar *msg)
{
GmpvMainWindow *wnd;
GtkWidget *dialog;
GtkWidget *msg_area;
GList *iter;
wnd = gmpv_application_get_main_window(app);
dialog = gtk_message_dialog_new
( GTK_WINDOW(wnd),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
_("Error") );
msg_area = gtk_message_dialog_get_message_area
(GTK_MESSAGE_DIALOG(dialog));
iter = gtk_container_get_children(GTK_CONTAINER(msg_area));
while(iter)
{
if(GTK_IS_LABEL(iter->data))
{
GtkLabel *label = iter->data;
gtk_label_set_line_wrap_mode
(label, PANGO_WRAP_WORD_CHAR);
}
iter = g_list_next(iter);
}
g_list_free(iter);
if(prefix)
{
gchar *prefix_escaped = g_markup_printf_escaped("%s", prefix);
gchar *msg_escaped = g_markup_printf_escaped("%s", msg);
gtk_message_dialog_format_secondary_markup
( GTK_MESSAGE_DIALOG(dialog),
"<b>[%s]</b> %s",
prefix_escaped,
msg_escaped );
g_free(prefix_escaped);
g_free(msg_escaped);
}
else
{
gtk_message_dialog_format_secondary_text
(GTK_MESSAGE_DIALOG(dialog), "%s", msg);
}
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
}
void
FormDialog::multi_text (const std::string name,
const std::string description,
const std::string value,
bool advanced)
{
GtkWidget *label = NULL;
GtkWidget *scroller = NULL;
GtkWidget *widget = NULL;
GtkTextBuffer *buffer = NULL;
MultiTextSubmitter *submitter = NULL;
grow_fields (advanced);
label = gtk_label_new_with_mnemonic (description.c_str ());
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_line_wrap_mode (GTK_LABEL (label), PANGO_WRAP_WORD);
if (advanced) {
gtk_table_attach_defaults (GTK_TABLE (advanced_fields), label,
0, 2, advanced_rows -1, advanced_rows);
} else {
gtk_table_attach_defaults (GTK_TABLE (fields), label,
0, 2, rows -1, rows);
}
grow_fields (advanced);
widget = gtk_text_view_new ();
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (widget));
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (widget), GTK_WRAP_WORD);
gtk_text_buffer_set_text (buffer, value.c_str (), -1);
scroller = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroller),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (scroller), widget);
if (advanced) {
gtk_table_attach_defaults (GTK_TABLE (advanced_fields), scroller,
0, 2, advanced_rows -1, advanced_rows);
} else {
gtk_table_attach_defaults (GTK_TABLE (fields), scroller,
0, 2, rows -1, rows);
}
submitter = new MultiTextSubmitter (name, description, advanced, buffer);
submitters.push_back (submitter);
}
void
FormDialog::error (const std::string _error)
{
GtkWidget *widget = NULL;
if (!_error.empty ()) {
widget = gtk_label_new (NULL);
gtk_label_set_line_wrap (GTK_LABEL (widget), TRUE);
gtk_label_set_line_wrap_mode (GTK_LABEL (widget), PANGO_WRAP_WORD);
gtk_label_set_markup_with_mnemonic (GTK_LABEL (widget),
("<span foreground=\"red\">" + _error + "</span>").c_str ());
gtk_container_add (GTK_CONTAINER (preamble), widget);
}
}
void
FormDialog::instructions (const std::string _instructions)
{
GtkWidget *widget = NULL;
InstructionsSubmitter *submitter = NULL;
gchar * label_text = NULL;
widget = gtk_label_new (NULL);
label_text = g_strdup_printf ("<i>%s</i>", _instructions.c_str());
gtk_label_set_markup_with_mnemonic (GTK_LABEL (widget), label_text);
g_free (label_text);
gtk_label_set_line_wrap (GTK_LABEL (widget), TRUE);
gtk_label_set_line_wrap_mode (GTK_LABEL (widget), PANGO_WRAP_WORD);
gtk_box_pack_start (GTK_BOX (preamble), widget, FALSE, FALSE, 0);
submitter = new InstructionsSubmitter (_instructions);
submitters.push_back (submitter);
}
/**
* gtk_ellipsis_set_line_wrap_mode:
* @ellipsis: a #GtkEllipsis
* @use_underline: %TRUE if underlines in the text indicate mnemonics
*
* Controls how the line wrapping is done.
*
* Since: 2.10
**/
void
gtk_ellipsis_set_line_wrap_mode (GtkEllipsis *ellipsis,
PangoWrapMode wrap_mode)
{
GtkEllipsisPrivate *priv;
g_return_if_fail (GTK_IS_ELLIPSIS (ellipsis));
priv = ellipsis->priv;
if (priv->wrap_mode != wrap_mode)
{
priv->wrap_mode = wrap_mode;
if (priv->label && GTK_IS_LABEL (priv->label))
gtk_label_set_line_wrap_mode (GTK_LABEL (priv->label), wrap_mode);
g_object_notify (G_OBJECT (ellipsis), "wrap-mode");
}
}
struct info_popup_t *info_popup_create(char *text)
{
struct info_popup_t *popup;
/* Allocate */
popup = calloc(1, sizeof(struct info_popup_t));
if (!popup)
fatal("%s: out of memory", __FUNCTION__);
/* Create window */
GtkWidget *window;
window = gtk_window_new(GTK_WINDOW_POPUP);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_MOUSE);
gtk_window_set_modal(GTK_WINDOW(window), TRUE);
gtk_widget_add_events(window, GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK);
g_signal_connect(G_OBJECT(window), "button-press-event",
G_CALLBACK(info_popup_button_press_event), popup);
g_signal_connect(G_OBJECT(window), "motion-notify-event",
G_CALLBACK(info_popup_motion_event), popup);
g_signal_connect(G_OBJECT(window), "destroy",
G_CALLBACK(info_popup_destroy_event), popup);
popup->window = window;
/* Create label with text */
GtkWidget *label;
label = gtk_label_new(text);
gtk_widget_set_size_request(window, -1, 250);
//gtk_label_set_selectable(GTK_LABEL(label), TRUE);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_label_set_line_wrap_mode(GTK_LABEL(label), TRUE);
//gtk_label_select_region(GTK_LABEL(label), 0, 0);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0);
/* Label font */
PangoAttrList *attrs;
attrs = pango_attr_list_new();
PangoAttribute *attr_family = pango_attr_family_new("Courier");
PangoAttribute *attr_size = pango_attr_size_new(10 << 10);
pango_attr_list_insert(attrs, attr_family);
pango_attr_list_insert(attrs, attr_size);
gtk_label_set_attributes(GTK_LABEL(label), attrs);
/* Scrolled window */
GtkWidget *scrolled_window;
GtkWidget *viewport;
scrolled_window = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
viewport = gtk_viewport_new(NULL, NULL);
gtk_container_add(GTK_CONTAINER(viewport), label);
gtk_container_add(GTK_CONTAINER(scrolled_window), viewport);
gtk_container_add(GTK_CONTAINER(window), scrolled_window);
/* Background color */
GdkColor color;
gdk_color_parse("#ffffa0", &color);
gtk_widget_modify_bg(viewport, GTK_STATE_NORMAL, &color);
/* Return */
return popup;
}
static GtkWidget *
progress_widget_new (CajaProgressInfo *info)
{
ProgressWidgetData *data;
GtkWidget *label, *progress_bar, *hbox, *vbox, *box, *button, *image;
data = g_new0 (ProgressWidgetData, 1);
data->info = g_object_ref (info);
vbox = gtk_vbox_new (FALSE, 0);
gtk_box_set_spacing (GTK_BOX (vbox), 5);
data->widget = vbox;
g_object_set_data_full (G_OBJECT (data->widget),
"data", data,
(GDestroyNotify)progress_widget_data_free);
label = gtk_label_new ("status");
gtk_widget_set_size_request (label, 500, -1);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_line_wrap_mode (GTK_LABEL (label), PANGO_WRAP_WORD_CHAR);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (vbox),
label,
TRUE, FALSE,
0);
data->status = GTK_LABEL (label);
hbox = gtk_hbox_new (FALSE,10);
progress_bar = gtk_progress_bar_new ();
data->progress_bar = GTK_PROGRESS_BAR (progress_bar);
gtk_progress_bar_set_pulse_step (data->progress_bar, 0.05);
box = gtk_vbox_new (FALSE,0);
gtk_box_pack_start(GTK_BOX (box),
progress_bar,
TRUE,FALSE,
0);
gtk_box_pack_start(GTK_BOX (hbox),
box,
TRUE,TRUE,
0);
image = gtk_image_new_from_stock (GTK_STOCK_CANCEL,
GTK_ICON_SIZE_BUTTON);
button = gtk_button_new ();
gtk_container_add (GTK_CONTAINER (button), image);
gtk_box_pack_start (GTK_BOX (hbox),
button,
FALSE,FALSE,
0);
g_signal_connect (button, "clicked", (GCallback)cancel_clicked, data);
gtk_box_pack_start (GTK_BOX (vbox),
hbox,
FALSE,FALSE,
0);
label = gtk_label_new ("details");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_box_pack_start (GTK_BOX (vbox),
label,
TRUE, FALSE,
0);
data->details = GTK_LABEL (label);
gtk_widget_show_all (data->widget);
update_data (data);
update_progress (data);
g_signal_connect_swapped (data->info,
"changed",
(GCallback)update_data, data);
g_signal_connect_swapped (data->info,
"progress_changed",
(GCallback)update_progress, data);
g_signal_connect_swapped (data->info,
"finished",
(GCallback)op_finished, data);
return data->widget;
}
void create_infowin (void)
{
GtkWidget * hbox;
GtkWidget * hbox_status_and_bbox;
GtkWidget * vbox0;
GtkWidget * vbox2;
GtkWidget * label_title;
GtkWidget * label_artist;
GtkWidget * label_album;
GtkWidget * label_comment;
GtkWidget * label_genre;
GtkWidget * label_year;
GtkWidget * label_track;
GtkWidget * label_format;
GtkWidget * label_quality_label;
GtkWidget * label_bitrate_label;
GtkWidget * codec_hbox;
GtkWidget * codec_table;
GtkWidget * table1;
GtkWidget * bbox_close;
GtkWidget * btn_close;
GtkWidget * alignment;
infowin = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width ((GtkContainer *) infowin, 6);
gtk_window_set_title ((GtkWindow *) infowin, _("Track Information"));
gtk_window_set_type_hint ((GtkWindow *) infowin,
GDK_WINDOW_TYPE_HINT_DIALOG);
vbox0 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add ((GtkContainer *) infowin, vbox0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start ((GtkBox *) vbox0, hbox, TRUE, TRUE, 0);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start ((GtkBox *) hbox, vbox2, TRUE, TRUE, 0);
GtkWidget * vbox3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start ((GtkBox *) vbox2, vbox3, TRUE, FALSE, 0);
image_artwork = gtk_image_new ();
gtk_box_pack_start ((GtkBox *) vbox3, image_artwork, FALSE, FALSE, 0);
location_text = gtk_label_new ("");
gtk_widget_set_size_request (location_text, 200, -1);
gtk_label_set_line_wrap ((GtkLabel *) location_text, TRUE);
gtk_label_set_line_wrap_mode ((GtkLabel *) location_text,
PANGO_WRAP_WORD_CHAR);
gtk_label_set_selectable ((GtkLabel *) location_text, TRUE);
gtk_box_pack_start ((GtkBox *) vbox3, location_text, FALSE, FALSE, 0);
codec_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start ((GtkBox *) vbox2, codec_hbox, FALSE, FALSE, 0);
codec_table = gtk_table_new(3, 2, FALSE);
gtk_table_set_row_spacings ((GtkTable *) codec_table, 3);
gtk_table_set_col_spacings ((GtkTable *) codec_table, 12);
gtk_box_pack_start ((GtkBox *) codec_hbox, codec_table, FALSE, FALSE, 0);
label_format = gtk_label_new (_("<span size=\"small\">Format:</span>"));
gtk_label_set_use_markup ((GtkLabel *) label_format, TRUE);
gtk_misc_set_alignment ((GtkMisc *) label_format, 0, 0.5);
label_quality_label = gtk_label_new
(_("<span size=\"small\">Quality:</span>"));
gtk_label_set_use_markup ((GtkLabel *) label_quality_label, TRUE);
gtk_misc_set_alignment ((GtkMisc *) label_quality_label, 0, 0.5);
label_bitrate_label = gtk_label_new (_("<span size=\"small\">Bitrate:</span>"));
gtk_label_set_use_markup ((GtkLabel *) label_bitrate_label, TRUE);
gtk_misc_set_alignment ((GtkMisc *) label_bitrate_label, 0, 0.5);
label_format_name = gtk_label_new (_("<span size=\"small\">n/a</span>"));
gtk_label_set_use_markup ((GtkLabel *) label_format_name, TRUE);
gtk_misc_set_alignment ((GtkMisc *) label_format_name, 0, 0.5);
label_quality = gtk_label_new (_("<span size=\"small\">n/a</span>"));
gtk_label_set_use_markup ((GtkLabel *) label_quality, TRUE);
gtk_misc_set_alignment ((GtkMisc *) label_quality, 0, 0.5);
label_bitrate = gtk_label_new (_("<span size=\"small\">n/a</span>"));
gtk_label_set_use_markup ((GtkLabel *) label_bitrate, TRUE);
gtk_misc_set_alignment ((GtkMisc *) label_bitrate, 0, 0.5);
gtk_table_attach ((GtkTable *) codec_table, label_format, 0, 1, 0, 1,
GTK_EXPAND | GTK_FILL, 0, 0, 0);
gtk_table_attach ((GtkTable *) codec_table, label_format_name, 1, 2, 0, 1,
GTK_EXPAND | GTK_FILL, 0, 0, 0);
gtk_table_attach ((GtkTable *) codec_table, label_quality_label, 0, 1, 1, 2,
GTK_EXPAND | GTK_FILL, 0, 0, 0);
gtk_table_attach ((GtkTable *) codec_table, label_quality, 1, 2, 1, 2,
GTK_EXPAND | GTK_FILL, 0, 0, 0);
gtk_table_attach ((GtkTable *) codec_table, label_bitrate_label, 0, 1, 2, 3,
GTK_EXPAND | GTK_FILL, 0, 0, 0);
gtk_table_attach ((GtkTable *) codec_table, label_bitrate, 1, 2, 2, 3,
GTK_EXPAND | GTK_FILL, 0, 0, 0);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start ((GtkBox *) hbox, vbox2, TRUE, TRUE, 0);
label_title = gtk_label_new (_("<span size=\"small\">Title</span>"));
gtk_box_pack_start ((GtkBox *) vbox2, label_title, FALSE, FALSE, 0);
gtk_label_set_use_markup ((GtkLabel *) label_title, TRUE);
gtk_misc_set_alignment ((GtkMisc *) label_title, 0, 0);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_box_pack_start ((GtkBox *) vbox2, alignment, FALSE, FALSE, 0);
gtk_alignment_set_padding ((GtkAlignment *) alignment, 0, 6, 0, 0);
entry_title = gtk_entry_new ();
gtk_container_add ((GtkContainer *) alignment, entry_title);
g_signal_connect (entry_title, "changed", (GCallback) entry_changed, NULL);
label_artist = gtk_label_new (_("<span size=\"small\">Artist</span>"));
gtk_box_pack_start ((GtkBox *) vbox2, label_artist, FALSE, FALSE, 0);
gtk_label_set_use_markup ((GtkLabel *) label_artist, TRUE);
gtk_misc_set_alignment ((GtkMisc *) label_artist, 0, 0.5);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_box_pack_start ((GtkBox *) vbox2, alignment, FALSE, FALSE, 0);
gtk_alignment_set_padding ((GtkAlignment *) alignment, 0, 6, 0, 0);
entry_artist = gtk_entry_new ();
gtk_container_add ((GtkContainer *) alignment, entry_artist);
g_signal_connect (entry_artist, "changed", (GCallback) entry_changed, NULL);
label_album = gtk_label_new (_("<span size=\"small\">Album</span>"));
gtk_box_pack_start ((GtkBox *) vbox2, label_album, FALSE, FALSE, 0);
gtk_label_set_use_markup ((GtkLabel *) label_album, TRUE);
gtk_misc_set_alignment ((GtkMisc *) label_album, 0, 0.5);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_box_pack_start ((GtkBox *) vbox2, alignment, FALSE, FALSE, 0);
gtk_alignment_set_padding ((GtkAlignment *) alignment, 0, 6, 0, 0);
entry_album = gtk_entry_new ();
gtk_container_add ((GtkContainer *) alignment, entry_album);
g_signal_connect (entry_album, "changed", (GCallback) entry_changed, NULL);
label_comment = gtk_label_new (_("<span size=\"small\">Comment</span>"));
gtk_box_pack_start ((GtkBox *) vbox2, label_comment, FALSE, FALSE, 0);
gtk_label_set_use_markup ((GtkLabel *) label_comment, TRUE);
gtk_misc_set_alignment ((GtkMisc *) label_comment, 0, 0.5);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_box_pack_start ((GtkBox *) vbox2, alignment, FALSE, FALSE, 0);
gtk_alignment_set_padding ((GtkAlignment *) alignment, 0, 6, 0, 0);
entry_comment = gtk_entry_new ();
gtk_container_add ((GtkContainer *) alignment, entry_comment);
g_signal_connect (entry_comment, "changed", (GCallback) entry_changed, NULL);
label_genre = gtk_label_new (_("<span size=\"small\">Genre</span>"));
gtk_box_pack_start ((GtkBox *) vbox2, label_genre, FALSE, FALSE, 0);
gtk_label_set_use_markup ((GtkLabel *) label_genre, TRUE);
gtk_misc_set_alignment ((GtkMisc *) label_genre, 0, 0.5);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_box_pack_start ((GtkBox *) vbox2, alignment, FALSE, FALSE, 0);
gtk_alignment_set_padding ((GtkAlignment *) alignment, 0, 6, 0, 0);
entry_genre = gtk_combo_box_text_new_with_entry ();
gtk_container_add ((GtkContainer *) alignment, entry_genre);
g_signal_connect (entry_genre, "changed", (GCallback) entry_changed, NULL);
g_idle_add ((GSourceFunc) genre_fill, entry_genre);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_box_pack_start ((GtkBox *) vbox2, alignment, FALSE, FALSE, 0);
gtk_alignment_set_padding ((GtkAlignment *) alignment, 0, 6, 0, 0);
table1 = gtk_table_new (2, 2, FALSE);
gtk_container_add ((GtkContainer *) alignment, table1);
gtk_table_set_col_spacings ((GtkTable *) table1, 6);
label_year = gtk_label_new (_("<span size=\"small\">Year</span>"));
gtk_table_attach ((GtkTable *) table1, label_year, 0, 1, 0, 1, GTK_FILL, 0,
0, 0);
gtk_label_set_use_markup ((GtkLabel *) label_year, TRUE);
gtk_misc_set_alignment ((GtkMisc *) label_year, 0, 0.5);
entry_year = gtk_entry_new ();
gtk_table_attach ((GtkTable *) table1, entry_year, 0, 1, 1, 2, GTK_EXPAND |
GTK_FILL, 0, 0, 0);
g_signal_connect (entry_year, "changed", (GCallback) entry_changed, NULL);
label_track = gtk_label_new (_("<span size=\"small\">Track Number</span>"));
gtk_table_attach ((GtkTable *) table1, label_track, 1, 2, 0, 1, GTK_FILL, 0,
0, 0);
gtk_label_set_use_markup ((GtkLabel *) label_track, TRUE);
gtk_misc_set_alignment ((GtkMisc *) label_track, 0, 0.5);
entry_track = gtk_entry_new ();
gtk_table_attach ((GtkTable *) table1, entry_track, 1, 2, 1, 2, GTK_EXPAND |
GTK_FILL, 0, 0, 0);
g_signal_connect (entry_track, "changed", (GCallback) entry_changed, NULL);
hbox_status_and_bbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start ((GtkBox *) vbox0, hbox_status_and_bbox, FALSE, FALSE, 0);
label_mini_status = gtk_label_new ("<span size=\"small\"></span>");
gtk_label_set_use_markup ((GtkLabel *) label_mini_status, TRUE);
gtk_misc_set_alignment ((GtkMisc *) label_mini_status, 0, 0.5);
gtk_box_pack_start ((GtkBox *) hbox_status_and_bbox, label_mini_status,
TRUE, TRUE, 0);
bbox_close = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_set_spacing ((GtkBox *) bbox_close, 6);
gtk_box_pack_start ((GtkBox *) hbox_status_and_bbox, bbox_close, FALSE,
FALSE, 0);
gtk_button_box_set_layout ((GtkButtonBox *) bbox_close, GTK_BUTTONBOX_END);
btn_apply = gtk_button_new_from_stock (GTK_STOCK_SAVE);
gtk_container_add ((GtkContainer *) bbox_close, btn_apply);
g_signal_connect (btn_apply, "clicked", (GCallback) infowin_update_tuple,
NULL);
gtk_widget_set_sensitive (btn_apply, FALSE);
btn_close = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
gtk_container_add ((GtkContainer *) bbox_close, btn_close);
g_signal_connect_swapped (btn_close, "clicked", (GCallback) gtk_widget_hide,
infowin);
audgui_hide_on_delete (infowin);
audgui_hide_on_escape (infowin);
gtk_widget_show_all (vbox0);
gtk_widget_grab_focus (entry_title);
}
static void
contact_widget_contact_setup (EmpathyContactWidget *information)
{
/* Setup label_status as a KludgeLabel */
information->label_status = empathy_kludge_label_new ("");
gtk_label_set_line_wrap_mode (GTK_LABEL (information->label_status),
PANGO_WRAP_WORD_CHAR);
gtk_label_set_line_wrap (GTK_LABEL (information->label_status),
TRUE);
if (!(information->flags & EMPATHY_CONTACT_WIDGET_FOR_TOOLTIP))
gtk_label_set_selectable (GTK_LABEL (information->label_status), TRUE);
gtk_box_pack_start (GTK_BOX (information->hbox_presence),
information->label_status, TRUE, TRUE, 0);
gtk_widget_show (information->label_status);
/* Setup account label/chooser */
if (information->flags & EMPATHY_CONTACT_WIDGET_EDIT_ACCOUNT)
{
information->widget_account = empathy_account_chooser_new ();
g_signal_connect_swapped (information->widget_account, "changed",
G_CALLBACK (contact_widget_change_contact),
information);
}
else
{
/* Pack the protocol icon with the account name in an hbox */
information->widget_account = gtk_hbox_new (FALSE, 6);
information->label_account = gtk_label_new (NULL);
if (!(information->flags & EMPATHY_CONTACT_WIDGET_FOR_TOOLTIP)) {
gtk_label_set_selectable (GTK_LABEL (information->label_account), TRUE);
}
gtk_misc_set_alignment (GTK_MISC (information->label_account), 0, 0.5);
gtk_widget_show (information->label_account);
information->image_account = gtk_image_new ();
gtk_widget_show (information->image_account);
gtk_box_pack_start (GTK_BOX (information->widget_account),
information->image_account, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (information->widget_account),
information->label_account, FALSE, TRUE, 0);
}
gtk_table_attach_defaults (GTK_TABLE (information->table_contact),
information->widget_account,
1, 2, 0, 1);
gtk_widget_show (information->widget_account);
/* Set up avatar chooser/display */
if (information->flags & EMPATHY_CONTACT_WIDGET_EDIT_AVATAR)
{
information->widget_avatar = empathy_avatar_chooser_new ();
g_signal_connect (information->widget_avatar, "changed",
G_CALLBACK (contact_widget_avatar_changed_cb),
information);
if (information->flags & EMPATHY_CONTACT_WIDGET_EDIT_ACCOUNT)
{
g_signal_connect (information->widget_account, "changed",
G_CALLBACK (update_avatar_chooser_account_cb),
information->widget_avatar);
update_avatar_chooser_account_cb (
EMPATHY_ACCOUNT_CHOOSER (information->widget_account),
EMPATHY_AVATAR_CHOOSER (information->widget_avatar));
}
}
else
{
information->widget_avatar = empathy_avatar_image_new ();
g_signal_connect (information->widget_avatar, "popup-menu",
G_CALLBACK (widget_avatar_popup_menu_cb), information);
g_signal_connect (information->widget_avatar, "button-press-event",
G_CALLBACK (widget_avatar_button_press_event_cb), information);
}
gtk_box_pack_start (GTK_BOX (information->vbox_avatar),
information->widget_avatar,
FALSE, FALSE,
6);
gtk_widget_show (information->widget_avatar);
/* Setup id label/entry */
if (information->flags & EMPATHY_CONTACT_WIDGET_EDIT_ID)
{
information->widget_id = gtk_entry_new ();
g_signal_connect (information->widget_id, "focus-out-event",
G_CALLBACK (contact_widget_id_focus_out_cb),
information);
g_signal_connect (information->widget_id, "changed",
G_CALLBACK (contact_widget_id_changed_cb),
information);
}
else
{
information->widget_id = gtk_label_new (NULL);
if (!(information->flags & EMPATHY_CONTACT_WIDGET_FOR_TOOLTIP)) {
gtk_label_set_selectable (GTK_LABEL (information->widget_id), TRUE);
}
gtk_misc_set_alignment (GTK_MISC (information->widget_id), 0, 0.5);
}
gtk_table_attach_defaults (GTK_TABLE (information->table_contact),
information->widget_id,
1, 2, 1, 2);
gtk_widget_show (information->widget_id);
/* Setup alias label/entry */
if (information->flags & EMPATHY_CONTACT_WIDGET_EDIT_ALIAS)
{
information->widget_alias = gtk_entry_new ();
if (!(information->flags & EMPATHY_CONTACT_WIDGET_NO_SET_ALIAS))
g_signal_connect (information->widget_alias, "focus-out-event",
G_CALLBACK (contact_widget_entry_alias_focus_event_cb),
information);
/* Make return activate the window default (the Close button) */
gtk_entry_set_activates_default (GTK_ENTRY (information->widget_alias),
TRUE);
}
else
{
information->widget_alias = gtk_label_new (NULL);
if (!(information->flags & EMPATHY_CONTACT_WIDGET_FOR_TOOLTIP)) {
gtk_label_set_selectable (GTK_LABEL (information->widget_alias), TRUE);
}
gtk_misc_set_alignment (GTK_MISC (information->widget_alias), 0, 0.5);
}
gtk_table_attach_defaults (GTK_TABLE (information->table_contact),
information->widget_alias,
1, 2, 2, 3);
if (information->flags & EMPATHY_CONTACT_WIDGET_FOR_TOOLTIP) {
gtk_label_set_selectable (GTK_LABEL (information->label_status), FALSE);
}
gtk_widget_show (information->widget_alias);
#if HAVE_FAVOURITE_CONTACTS
/* Favorite */
if (information->flags & EMPATHY_CONTACT_WIDGET_EDIT_FAVOURITE)
{
information->favourite_checkbox = gtk_check_button_new_with_label (
_("Favorite"));
g_signal_connect (information->favourite_checkbox, "toggled",
G_CALLBACK (favourite_toggled_cb), information);
gtk_table_attach_defaults (GTK_TABLE (information->table_contact),
information->favourite_checkbox, 0, 2, 3, 4);
information->fav_sig_id = g_signal_connect (information->manager,
"favourites-changed",
G_CALLBACK (contact_widget_favourites_changed_cb), information);
gtk_widget_show (information->favourite_checkbox);
}
#endif
}
/*
* Function: init_interface
*
* Creates the GUI according to 'arguments' structure.
*/
void init_interface(app_elems * interface, args * arguments, int source)
{
interface->askedforkill = FALSE;
GdkPixbuf *pixbuf;
GError *error = NULL;
int i, size = 10;
/* Heading label text (sub-program command line) */
for (i = 0; arguments->program[i] != NULL; i++) {
size += strlen(arguments->program[i]) + 1;
}
char command[size];
command[0] = '\0';
for (i = 0; arguments->program[i] != NULL; i++) {
strcat(command, arguments->program[i]);
strncat(command, " ", size);
}
/* Main window */
interface->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(interface->window), arguments->title);
gtk_window_set_default_size(GTK_WINDOW(interface->window),
arguments->width, arguments->height);
gtk_container_set_border_width(GTK_CONTAINER(interface->window), 10);
g_signal_connect(G_OBJECT(interface->window), "destroy",
G_CALLBACK(cb_close_or_reduce), interface);
/* Notification icon */
interface->icon = gtk_status_icon_new_from_file(arguments->iconpath);
pixbuf = gdk_pixbuf_new_from_file(arguments->iconpath, &error);
if (pixbuf == NULL) {
fprintf(stderr, _("Can't find specified icon\n"));
} else {
gtk_window_set_icon(GTK_WINDOW(interface->window), pixbuf);
}
gtk_status_icon_set_tooltip_text(GTK_STATUS_ICON(interface->icon),
arguments->tooltip);
gtk_status_icon_set_visible(GTK_STATUS_ICON(interface->icon), TRUE);
g_signal_connect(GTK_STATUS_ICON(interface->icon), "activate",
G_CALLBACK(cb_toggle_display), interface);
/* Body */
/* To compile with GTK+2.0, replace by:
GtkWidget *vb1 = gtk_vbox_new(FALSE, VPADDING);
GtkWidget *hb1 = gtk_hbox_new(FALSE, HPADDING);
*/
GtkWidget *vb1 = gtk_box_new(GTK_ORIENTATION_VERTICAL, VPADDING);
GtkWidget *hb1 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, HPADDING);
/* Quit button */
GtkWidget *b1 = gtk_button_new_with_mnemonic(_("_Hide"));
gtk_button_set_image(GTK_BUTTON(b1),
gtk_image_new_from_stock(GTK_STOCK_QUIT,
GTK_ICON_SIZE_BUTTON));
g_signal_connect(G_OBJECT(b1), "clicked",
G_CALLBACK(cb_close_or_reduce), interface);
interface->quitbutton = b1;
/* Kill button */
GtkWidget *b2 = gtk_button_new_with_mnemonic(_("_Stop (SIGINT)"));
gtk_button_set_image(GTK_BUTTON(b2),
gtk_image_new_from_stock(GTK_STOCK_STOP,
GTK_ICON_SIZE_BUTTON));
g_signal_connect(G_OBJECT(b2), "clicked", G_CALLBACK(cb_kill_child),
interface);
interface->killbutton = b2;
//STDOUT & STDERR Scrolling TextView
GtkWidget *stdout_child = gtk_text_view_new();
gtk_text_view_set_editable(GTK_TEXT_VIEW(stdout_child), FALSE);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(stdout_child), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(stdout_child),
GTK_WRAP_CHAR);
gtk_widget_modify_font(stdout_child,
pango_font_description_from_string
("monospace"));
add_textview_refresher(GTK_TEXT_VIEW(stdout_child), source);
GtkWidget *scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll),
GTK_SHADOW_IN);
gtk_container_add(GTK_CONTAINER(scroll), stdout_child);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
/* Heading label */
GtkWidget *command_line = gtk_label_new(command);
gtk_label_set_line_wrap(GTK_LABEL(command_line), TRUE);
gtk_label_set_line_wrap_mode(GTK_LABEL(command_line), GTK_WRAP_CHAR);
gtk_widget_modify_font(command_line,
pango_font_description_from_string("bold"));
/* Line break checkbox */
GtkWidget *ch1 = gtk_check_button_new_with_mnemonic(_("_Line breaks"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ch1), TRUE);
g_signal_connect(G_OBJECT(ch1), "toggled",
G_CALLBACK(cb_toggle_line_break), stdout_child);
/* Link all widgets together */
gtk_box_pack_end(GTK_BOX(hb1), b1, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(hb1), b2, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hb1), ch1, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vb1), command_line, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vb1), scroll, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vb1), hb1, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(interface->window), vb1);
}
static void
nautilus_progress_info_widget_constructed (GObject *obj)
{
GtkWidget *label, *progress_bar, *hbox, *box, *button, *image;
NautilusProgressInfoWidget *self = NAUTILUS_PROGRESS_INFO_WIDGET (obj);
G_OBJECT_CLASS (nautilus_progress_info_widget_parent_class)->constructed (obj);
label = gtk_label_new ("status");
gtk_widget_set_size_request (label, 500, -1);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_line_wrap_mode (GTK_LABEL (label), PANGO_WRAP_WORD_CHAR);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (self),
label,
TRUE, FALSE,
0);
self->priv->status = label;
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
progress_bar = gtk_progress_bar_new ();
self->priv->progress_bar = progress_bar;
gtk_progress_bar_set_pulse_step (GTK_PROGRESS_BAR (progress_bar), 0.05);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start(GTK_BOX (box),
progress_bar,
TRUE, FALSE,
0);
gtk_box_pack_start(GTK_BOX (hbox),
box,
TRUE, TRUE,
0);
image = gtk_image_new_from_icon_name ("gtk-cancel",
GTK_ICON_SIZE_BUTTON);
button = gtk_button_new ();
gtk_container_add (GTK_CONTAINER (button), image);
gtk_box_pack_start (GTK_BOX (hbox),
button,
FALSE,FALSE,
0);
g_signal_connect (button, "clicked",
G_CALLBACK (cancel_clicked), self);
gtk_box_pack_start (GTK_BOX (self),
hbox,
FALSE,FALSE,
0);
label = gtk_label_new ("details");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_box_pack_start (GTK_BOX (self),
label,
TRUE, FALSE,
0);
self->priv->details = label;
gtk_widget_show_all (GTK_WIDGET (self));
update_data (self);
update_progress (self);
g_signal_connect_swapped (self->priv->info,
"changed",
G_CALLBACK (update_data), self);
g_signal_connect_swapped (self->priv->info,
"progress-changed",
G_CALLBACK (update_progress), self);
g_signal_connect_swapped (self->priv->info,
"finished",
G_CALLBACK (info_finished), self);
}
G_MODULE_EXPORT gboolean
display_show(NOTIFICATION_INFO* ni) {
GdkColor color;
GtkWidget* vbox;
GtkWidget* hbox;
GtkWidget* label;
GtkWidget* image;
GdkScreen* screen;
gint n, pos, len;
gint x, y;
gint monitor_num;
GdkRectangle rect;
DISPLAY_INFO* di = g_new0(DISPLAY_INFO, 1);
if (!di) {
perror("g_new0");
return FALSE;
}
di->ni = ni;
len = g_list_length(notifications);
for (pos = 0; pos < len; pos++) {
DISPLAY_INFO* p = g_list_nth_data(notifications, pos);
if (pos != p->pos) break;
}
screen = gdk_screen_get_default();
monitor_num = gdk_screen_get_primary_monitor(screen);
gdk_screen_get_monitor_geometry(screen, monitor_num, &rect);
x = rect.x + rect.width - 250;
y = rect.y + rect.height - 110;
for (n = 0; n < pos; n++) {
y -= 110;
if (y < 0) {
x -= 250;
if (x < 0) {
return FALSE;
}
y = rect.y + rect.height - 110;
}
}
di->pos = pos;
notifications = g_list_insert_sorted(notifications, di, notifications_compare);
di->x = x;
di->y = y;
di->popup = gtk_window_new(GTK_WINDOW_POPUP);
gtk_window_set_title(GTK_WINDOW(di->popup), "growl-for-linux");
gtk_window_set_resizable(GTK_WINDOW(di->popup), FALSE);
gtk_window_set_decorated(GTK_WINDOW(di->popup), FALSE);
gtk_window_set_keep_above(GTK_WINDOW(di->popup), TRUE);
gtk_window_stick(GTK_WINDOW(di->popup));
vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 18);
gtk_container_add(GTK_CONTAINER(di->popup), vbox);
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
if (di->ni->icon && *di->ni->icon) {
GdkPixbuf* pixbuf;
if (di->ni->local) {
gchar* newurl = g_filename_from_uri(di->ni->icon, NULL, NULL);
GError* error = NULL;
pixbuf = gdk_pixbuf_new_from_file(newurl ? newurl : di->ni->icon, &error);
if (newurl) g_free(newurl);
} else
pixbuf = url2pixbuf(di->ni->icon, NULL);
if (pixbuf) {
GdkPixbuf* tmp = gdk_pixbuf_scale_simple(pixbuf, 32, 32, GDK_INTERP_TILES);
if (tmp) {
g_object_unref(pixbuf);
pixbuf = tmp;
}
image = gtk_image_new_from_pixbuf(pixbuf);
gtk_box_pack_start(GTK_BOX(hbox), image, FALSE, FALSE, 0);
g_object_unref(pixbuf);
}
}
PangoFontDescription* font_desc;
font_desc = pango_font_description_new();
pango_font_description_set_family(font_desc, "Sans");
pango_font_description_set_size(font_desc, 12 * PANGO_SCALE);
label = gtk_label_new(di->ni->title);
gdk_color_parse("white", &color);
gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &color);
gtk_widget_modify_font(label, font_desc);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
pango_font_description_free(font_desc);
font_desc = pango_font_description_new();
pango_font_description_set_family(font_desc, "Sans");
pango_font_description_set_size(font_desc, 8 * PANGO_SCALE);
label = gtk_label_new(di->ni->text);
gdk_color_parse("white", &color);
gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &color);
gtk_widget_modify_font(label, font_desc);
g_signal_connect(G_OBJECT(label), "size-allocate", G_CALLBACK(label_size_allocate), NULL);
gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_label_set_line_wrap_mode(GTK_LABEL(label), PANGO_WRAP_CHAR);
gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, FALSE, 0);
pango_font_description_free(font_desc);
gtk_widget_set_events(di->popup, GDK_BUTTON_PRESS_MASK);
g_signal_connect(G_OBJECT(di->popup), "button-press-event", G_CALLBACK(display_clicked), di);
di->offset = 0;
di->timeout = 500;
gtk_window_move(GTK_WINDOW(di->popup), di->x, di->y);
gtk_window_set_opacity(GTK_WINDOW(di->popup), 0);
gtk_widget_set_app_paintable(di->popup, TRUE);
gtk_widget_show_all(di->popup);
if (pixmap == NULL) {
pixmap = gdk_pixmap_create_from_xpm_d(di->popup->window, &bitmap, NULL, balloon);
}
gdk_drawable_get_size(pixmap, &pixmap_width, &pixmap_height);
gtk_widget_set_size_request(di->popup, pixmap_width, pixmap_height);
gdk_window_shape_combine_mask(di->popup->window, bitmap, 0, 0);
g_signal_connect(G_OBJECT(di->popup), "expose-event", G_CALLBACK(display_expose), di);
g_timeout_add(10, display_animation_func, di);
return FALSE;
}
static void
populate_spread_table_wrappy (EggSpreadTable *spread_table)
{
GList *children, *l;
GtkWidget *widget, *frame;
gsize i;
const gchar *strings[] = {
"These are", "some wrappy label", "texts", "of various", "lengths.",
"They should always be", "shown", "consecutively. Except it's",
"hard to say", "where exactly the", "label", "will wrap", "and where exactly",
"the actual", "container", "will wrap.", "This label is really really really long !",
"Let's add some more", "labels to the",
"mix. Just to", "make sure we", "got something to work", "with here."
};
/* Remove all children first */
children = gtk_container_get_children (GTK_CONTAINER (paper));
for (l = children; l; l = l->next)
{
GtkWidget *child = l->data;
gtk_container_remove (GTK_CONTAINER (paper), child);
}
g_list_free (children);
for (i = 0; i < G_N_ELEMENTS (strings); i++)
{
widget = gtk_label_new (strings[i]);
frame = gtk_frame_new (NULL);
gtk_widget_show (widget);
gtk_widget_show (frame);
gtk_container_add (GTK_CONTAINER (frame), widget);
gtk_label_set_line_wrap (GTK_LABEL (widget), TRUE);
gtk_label_set_line_wrap_mode (GTK_LABEL (widget), PANGO_WRAP_WORD);
gtk_label_set_width_chars (GTK_LABEL (widget), 10);
gtk_widget_set_halign (frame, child_halign);
egg_spread_table_insert_child (EGG_SPREAD_TABLE (spread_table), frame, -1);
}
/* Insert an image into the mix */
if (test_image)
{
widget = gtk_image_new_from_file ("apple-red.png");
switch (test_image)
{
case IMAGE_SMALL:
gtk_widget_set_size_request (widget, 100, 100);
break;
case IMAGE_LARGE:
gtk_widget_set_size_request (widget, 150, 200);
break;
case IMAGE_HUGE:
gtk_widget_set_size_request (widget, 200, 300);
break;
default:
break;
}
frame = gtk_frame_new (NULL);
gtk_widget_show (widget);
gtk_widget_show (frame);
gtk_container_add (GTK_CONTAINER (frame), widget);
egg_spread_table_insert_child (EGG_SPREAD_TABLE (spread_table), frame, test_image_index);
}
}
static void
inf_gtk_certificate_manager_certificate_func(InfXmppConnection* connection,
gnutls_session_t session,
InfCertificateChain* chain,
gpointer user_data)
{
InfGtkCertificateManager* manager;
InfGtkCertificateManagerPrivate* priv;
InfGtkCertificateDialogFlags flags;
gnutls_x509_crt_t presented_cert;
gnutls_x509_crt_t known_cert;
gchar* hostname;
gboolean match_hostname;
gboolean issuer_known;
gnutls_x509_crt_t root_cert;
int ret;
unsigned int verify;
GHashTable* table;
gboolean cert_equal;
time_t expiration_time;
InfGtkCertificateManagerQuery* query;
gchar* text;
GtkWidget* vbox;
GtkWidget* button;
GtkWidget* image;
GtkWidget* label;
GError* error;
manager = INF_GTK_CERTIFICATE_MANAGER(user_data);
priv = INF_GTK_CERTIFICATE_MANAGER_PRIVATE(manager);
g_object_get(G_OBJECT(connection), "remote-hostname", &hostname, NULL);
presented_cert = inf_certificate_chain_get_own_certificate(chain);
match_hostname = gnutls_x509_crt_check_hostname(presented_cert, hostname);
/* First, validate the certificate */
ret = gnutls_certificate_verify_peers2(session, &verify);
error = NULL;
if(ret != GNUTLS_E_SUCCESS)
inf_gnutls_set_error(&error, ret);
/* Remove the GNUTLS_CERT_ISSUER_NOT_KNOWN flag from the verification
* result, and if the certificate is still invalid, then set an error. */
if(error == NULL)
{
issuer_known = TRUE;
if(verify & GNUTLS_CERT_SIGNER_NOT_FOUND)
{
issuer_known = FALSE;
/* Re-validate the certificate for other failure reasons --
* unfortunately the gnutls_certificate_verify_peers2() call
* does not tell us whether the certificate is otherwise invalid
* if a signer is not found already. */
/* TODO: Here it would be good to use the verify flags from the
* certificate credentials, but GnuTLS does not have API to
* retrieve them. */
root_cert = inf_certificate_chain_get_root_certificate(chain);
ret = gnutls_x509_crt_list_verify(
inf_certificate_chain_get_raw(chain),
inf_certificate_chain_get_n_certificates(chain),
&root_cert,
1,
NULL,
0,
GNUTLS_VERIFY_ALLOW_X509_V1_CA_CRT,
&verify
);
if(ret != GNUTLS_E_SUCCESS)
inf_gnutls_set_error(&error, ret);
else if(verify & GNUTLS_CERT_INVALID)
inf_gnutls_certificate_verification_set_error(&error, verify);
}
}
/* Look up the host in our database of pinned certificates if we could not
* fully verify the certificate, i.e. if either the issuer is not known or
* the hostname of the connection does not match the certificate. */
table = NULL;
if(error == NULL)
{
known_cert = NULL;
if(!match_hostname || !issuer_known)
{
/* If we cannot load the known host file, then cancel the connection.
* Otherwise it might happen that someone shows us a certificate that we
* tell the user we don't know, if though actually for that host we expect
* a different certificate. */
table = inf_gtk_certificate_manager_ref_known_hosts(manager, &error);
if(table != NULL)
known_cert = g_hash_table_lookup(table, hostname);
}
}
/* Next, configure the flags for the dialog to be shown based on the
* verification result, and on whether the pinned certificate matches
* the one presented by the host or not. */
flags = 0;
if(error == NULL)
{
if(known_cert != NULL)
{
cert_equal = inf_gtk_certificate_manager_compare_fingerprint(
known_cert,
presented_cert,
&error
);
if(error == NULL && cert_equal == FALSE)
{
if(!match_hostname)
flags |= INF_GTK_CERTIFICATE_DIALOG_CERT_HOSTNAME_MISMATCH;
if(!issuer_known)
flags |= INF_GTK_CERTIFICATE_DIALOG_CERT_ISSUER_NOT_KNOWN;
flags |= INF_GTK_CERTIFICATE_DIALOG_CERT_UNEXPECTED;
expiration_time = gnutls_x509_crt_get_expiration_time(known_cert);
if(expiration_time != (time_t)(-1))
{
expiration_time -= INF_GTK_CERTIFICATE_MANAGER_EXPIRATION_TOLERANCE;
if(time(NULL) > expiration_time)
{
flags |= INF_GTK_CERTIFICATE_DIALOG_CERT_OLD_EXPIRED;
}
}
}
}
else
{
if(!match_hostname)
flags |= INF_GTK_CERTIFICATE_DIALOG_CERT_HOSTNAME_MISMATCH;
if(!issuer_known)
flags |= INF_GTK_CERTIFICATE_DIALOG_CERT_ISSUER_NOT_KNOWN;
}
}
/* Now proceed either by accepting the connection, rejecting it, or
* bothering the user with an annoying dialog. */
if(error == NULL)
{
if(flags == 0)
{
if(match_hostname && issuer_known)
{
/* Remove the pinned entry if we now have a valid certificate for
* this host. */
if(table != NULL && g_hash_table_remove(table, hostname) == TRUE)
{
inf_gtk_certificate_manager_write_known_hosts_with_warning(
manager,
table
);
}
}
inf_xmpp_connection_certificate_verify_continue(connection);
}
else
{
query = g_slice_new(InfGtkCertificateManagerQuery);
query->manager = manager;
query->known_hosts = table;
query->connection = connection;
query->dialog = inf_gtk_certificate_dialog_new(
priv->parent_window,
0,
flags,
hostname,
chain
);
query->certificate_chain = chain;
table = NULL;
g_object_ref(query->connection);
inf_certificate_chain_ref(chain);
g_signal_connect(
G_OBJECT(connection),
"notify::status",
G_CALLBACK(inf_gtk_certificate_manager_notify_status_cb),
query
);
g_signal_connect(
G_OBJECT(query->dialog),
"response",
G_CALLBACK(inf_gtk_certificate_manager_response_cb),
query
);
image = gtk_image_new_from_stock(GTK_STOCK_CANCEL, GTK_ICON_SIZE_BUTTON);
gtk_widget_show(image);
button = gtk_dialog_add_button(
GTK_DIALOG(query->dialog),
_("_Cancel connection"),
GTK_RESPONSE_REJECT
);
gtk_button_set_image(GTK_BUTTON(button), image);
image = gtk_image_new_from_stock(GTK_STOCK_CONNECT, GTK_ICON_SIZE_BUTTON);
gtk_widget_show(image);
button = gtk_dialog_add_button(
GTK_DIALOG(query->dialog),
_("C_ontinue connection"),
GTK_RESPONSE_ACCEPT
);
gtk_button_set_image(GTK_BUTTON(button), image);
text = g_strdup_printf(
_("Do you want to continue the connection to host \"%s\"? If you "
"choose to continue, this certificate will be trusted in the "
"future when connecting to this host."),
hostname
);
label = gtk_label_new(text);
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_label_set_line_wrap_mode(GTK_LABEL(label), PANGO_WRAP_WORD_CHAR);
gtk_label_set_width_chars(GTK_LABEL(label), 60);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);
gtk_widget_show(label);
g_free(text);
vbox = gtk_dialog_get_content_area(GTK_DIALOG(query->dialog));
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
priv->queries = g_slist_prepend(priv->queries, query);
gtk_window_present(GTK_WINDOW(query->dialog));
}
}
else
{
inf_xmpp_connection_certificate_verify_cancel(connection, error);
g_error_free(error);
}
if(table != NULL) g_hash_table_unref(table);
g_free(hostname);
}
static void
nemo_mime_application_chooser_build_ui (NemoMimeApplicationChooser *chooser)
{
GtkWidget *box, *button;
GAppInfo *info;
gtk_container_set_border_width (GTK_CONTAINER (chooser), 8);
gtk_box_set_spacing (GTK_BOX (chooser), 0);
gtk_box_set_homogeneous (GTK_BOX (chooser), FALSE);
chooser->details->label = gtk_label_new ("");
gtk_misc_set_alignment (GTK_MISC (chooser->details->label), 0.0, 0.5);
gtk_label_set_line_wrap (GTK_LABEL (chooser->details->label), TRUE);
gtk_label_set_line_wrap_mode (GTK_LABEL (chooser->details->label),
PANGO_WRAP_WORD_CHAR);
gtk_box_pack_start (GTK_BOX (chooser), chooser->details->label,
FALSE, FALSE, 0);
gtk_widget_show (chooser->details->label);
chooser->details->open_with_widget = gtk_app_chooser_widget_new (chooser->details->content_type);
gtk_app_chooser_widget_set_show_default (GTK_APP_CHOOSER_WIDGET (chooser->details->open_with_widget),
TRUE);
gtk_app_chooser_widget_set_show_fallback (GTK_APP_CHOOSER_WIDGET (chooser->details->open_with_widget),
TRUE);
gtk_box_pack_start (GTK_BOX (chooser), chooser->details->open_with_widget,
TRUE, TRUE, 6);
gtk_widget_show (chooser->details->open_with_widget);
g_signal_connect (chooser->details->open_with_widget, "application-selected",
G_CALLBACK (application_selected_cb),
chooser);
g_signal_connect (chooser->details->open_with_widget, "populate-popup",
G_CALLBACK (populate_popup_cb),
chooser);
gtk_app_chooser_widget_set_show_other (GTK_APP_CHOOSER_WIDGET (chooser->details->open_with_widget),
TRUE);
gtk_app_chooser_widget_set_show_recommended (GTK_APP_CHOOSER_WIDGET (chooser->details->open_with_widget),
TRUE);
GtkWidget *custom_label = gtk_label_new (_("You can also type or select a custom executable file to use to open this file type. "
"You can use this command just once, or set it as default for all files of this type."));
gtk_misc_set_alignment (GTK_MISC (custom_label), 0.0, 0.5);
gtk_label_set_line_wrap (GTK_LABEL (custom_label), TRUE);
gtk_label_set_line_wrap_mode (GTK_LABEL (custom_label),
PANGO_WRAP_WORD_CHAR);
gtk_box_pack_start (GTK_BOX (chooser), custom_label, FALSE, FALSE, 0);
gtk_widget_show (GTK_WIDGET (custom_label));
GtkWidget *custom_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (chooser), custom_box, TRUE, TRUE, 0);
GtkWidget *entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (custom_box), entry, TRUE, TRUE, 0);
gtk_entry_set_placeholder_text (GTK_ENTRY (entry), _("Enter a custom command..."));
g_signal_connect (entry, "changed",
G_CALLBACK (custom_entry_changed_cb),
chooser);
chooser->details->custom_entry = entry;
button = gtk_file_chooser_button_new (_("Custom application"), GTK_FILE_CHOOSER_ACTION_OPEN);
g_signal_connect (button, "file-set",
G_CALLBACK (custom_app_set_cb),
chooser);
gtk_widget_show (button);
gtk_box_pack_start (GTK_BOX (custom_box), button, FALSE, FALSE, 6);
gtk_widget_show_all (custom_box);
chooser->details->custom_picker = button;
box = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_set_spacing (GTK_BOX (box), 6);
gtk_button_box_set_layout (GTK_BUTTON_BOX (box), GTK_BUTTONBOX_CENTER);
gtk_box_pack_start (GTK_BOX (chooser), box, FALSE, FALSE, 6);
gtk_widget_show (box);
GtkFileFilter *filter = gtk_file_filter_new ();
gtk_file_filter_add_mime_type (filter, "application/*");
gtk_file_filter_set_name (filter, _("Executables"));
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (button), filter);
button = gtk_button_new_with_label (_("Add to list"));
g_signal_connect (button, "clicked",
G_CALLBACK (add_clicked_cb),
chooser);
gtk_widget_show (button);
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
chooser->details->add_button = button;
button = gtk_button_new_with_label (_("Set as default"));
g_signal_connect (button, "clicked",
G_CALLBACK (set_as_default_clicked_cb),
chooser);
gtk_widget_show (button);
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
chooser->details->set_as_default_button = button;
button = gtk_button_new_with_label (_("Reset to system defaults"));
g_signal_connect (button, "clicked",
G_CALLBACK (reset_clicked_cb),
chooser);
gtk_widget_show (button);
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
/* initialize sensitivity */
info = gtk_app_chooser_get_app_info (GTK_APP_CHOOSER (chooser->details->open_with_widget));
if (info != NULL) {
application_selected_cb (GTK_APP_CHOOSER_WIDGET (chooser->details->open_with_widget),
info, chooser);
g_object_unref (info);
}
}
GtkWidget* ShortcutsListDlg::create_dialog (GtkWidget* parent)
{
GtkWidget *shortcuts_dialog;
GtkWidget *dialog_vbox8;
GtkWidget *hbox3;
GtkWidget *label33;
GtkWidget *label34;
GtkWidget *combobox4;
GtkWidget *scrolledwindow5;
GtkWidget *treeview3;
GtkWidget *label35;
GtkWidget *dialog_action_area8;
GtkWidget *cancelbutton8;
GtkWidget *okbutton8;
GtkWidget *clearall_btn;
GtkWidget *resetall_btn;
shortcuts_dialog = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (shortcuts_dialog), _("Shortcut editor"));
gtk_window_set_type_hint (GTK_WINDOW (shortcuts_dialog), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_default_size(GTK_WINDOW(shortcuts_dialog), 420, 450);
gtk_window_set_modal (GTK_WINDOW (shortcuts_dialog), TRUE);
gtk_window_set_destroy_with_parent (GTK_WINDOW (shortcuts_dialog), TRUE);
#ifndef _WIN32 //TOFIX API is buggy on Win32 (kills modal dialog state)
gtk_window_set_skip_taskbar_hint (GTK_WINDOW (shortcuts_dialog), TRUE);
#endif
gtk_window_set_skip_pager_hint (GTK_WINDOW (shortcuts_dialog), TRUE);
gtk_window_set_transient_for(GTK_WINDOW (shortcuts_dialog), GTK_WINDOW(window1)); //set parent
dialog_vbox8 = GTK_DIALOG (shortcuts_dialog)->vbox;
gtk_widget_show (dialog_vbox8);
hbox3 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox3);
gtk_box_pack_start (GTK_BOX (dialog_vbox8), hbox3, FALSE, TRUE, 0);
label33 = gtk_label_new (_("Context:"));
gtk_widget_show (label33);
gtk_box_pack_start (GTK_BOX (hbox3), label33, FALSE, TRUE, 2);
gtk_misc_set_alignment (GTK_MISC (label33), 0, 0.5);
combobox4 = gtk_combo_box_new_text ();
gtk_widget_show (combobox4);
gtk_box_pack_start (GTK_BOX (hbox3), combobox4, TRUE, TRUE, 2);
gtk_combo_box_append_text(GTK_COMBO_BOX(combobox4), _("Global"));
gtk_combo_box_append_text(GTK_COMBO_BOX(combobox4), _("Tree widget"));
gtk_combo_box_set_active (GTK_COMBO_BOX(combobox4), 0);
g_signal_connect(combobox4, "changed", G_CALLBACK (on_context_combo_selected), this);
label34 = gtk_label_new ("");
gtk_widget_show (label34);
gtk_box_pack_start (GTK_BOX (hbox3), label34, FALSE, TRUE, 2);
gtk_misc_set_alignment (GTK_MISC (label34), 1.0, 0.5);
scrolledwindow5 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow5);
gtk_box_pack_start (GTK_BOX (dialog_vbox8), scrolledwindow5, TRUE, TRUE, 0);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow5), GTK_SHADOW_IN);
// create shortcuts list
GtkListStore *store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
treeview3 = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
g_object_unref (G_OBJECT (store)); //tree now holds reference
gtk_widget_show (treeview3);
gtk_container_add (GTK_CONTAINER (scrolledwindow5), treeview3);
g_signal_connect (treeview3, "key_press_event", G_CALLBACK (treeview_keyboard_handler), this);
GtkTreeViewColumn *col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, _("Action"));
gtk_tree_view_column_set_clickable(col, TRUE); //allow column header clicks
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_fixed_width(col, 300);
// g_signal_connect (col, "clicked", G_CALLBACK (on_header_clicked), this);
GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_add_attribute(col, renderer, "text", 0);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview3), col);
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, _("Shortcut"));
gtk_tree_view_column_set_clickable(col, TRUE); //allow column header clicks
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_fixed_width(col, 50);
// g_signal_connect (col, "clicked", G_CALLBACK (on_header_clicked), this);
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_add_attribute(col, renderer, "text", 1);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview3), col);
GtkWidget *hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (dialog_vbox8), hbox1, FALSE, TRUE, 5);
GdkPixbuf *pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **)&bulb);
GtkWidget *icon = gtk_image_new_from_pixbuf (pixbuf);
gtk_widget_show (icon);
gtk_box_pack_start (GTK_BOX (hbox1), icon, FALSE, TRUE, 2);
label35 = gtk_label_new (_("Use mouse click to select an action, and then press key combination to assign the shortcut to it. Some actions are listed in more than one context so they can have more than one shortcut attached."));
gtk_widget_show (label35);
gtk_box_pack_start (GTK_BOX (hbox1), label35, TRUE, TRUE, 2);
gtk_misc_set_alignment (GTK_MISC (label35), 0.5, 0.5);
gtk_label_set_line_wrap(GTK_LABEL(label35), true);
#if GTK_CHECK_VERSION(2,10,0) //minimal version for this api
gtk_label_set_line_wrap_mode(GTK_LABEL(label35), PANGO_WRAP_WORD_CHAR);
#endif
//action area
dialog_action_area8 = GTK_DIALOG (shortcuts_dialog)->action_area;
gtk_widget_show (dialog_action_area8);
gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area8), GTK_BUTTONBOX_END);
clearall_btn = gtk_button_new_with_mnemonic(_("Clear All"));
gtk_widget_show (clearall_btn);
gtk_container_add (GTK_CONTAINER(dialog_action_area8), clearall_btn);
GTK_WIDGET_SET_FLAGS (clearall_btn, GTK_CAN_DEFAULT);
g_signal_connect(clearall_btn, "clicked", G_CALLBACK (on_clear_all_clicked), this);
resetall_btn = gtk_button_new_with_mnemonic(_("Reset All"));
gtk_widget_show (resetall_btn);
gtk_container_add (GTK_CONTAINER(dialog_action_area8), resetall_btn);
GTK_WIDGET_SET_FLAGS (resetall_btn, GTK_CAN_DEFAULT);
g_signal_connect(resetall_btn, "clicked", G_CALLBACK (on_reset_all_clicked), this);
cancelbutton8 = gtk_button_new_with_mnemonic (_("Cancel"));
gtk_widget_show (cancelbutton8);
gtk_dialog_add_action_widget (GTK_DIALOG (shortcuts_dialog), cancelbutton8, GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS (cancelbutton8, GTK_CAN_DEFAULT);
g_signal_connect(cancelbutton8, "clicked", G_CALLBACK (on_cancel_clicked), this);
okbutton8 = gtk_button_new_with_mnemonic (_("OK"));
gtk_widget_show (okbutton8);
gtk_container_add (GTK_CONTAINER(dialog_action_area8), okbutton8);
GTK_WIDGET_SET_FLAGS (okbutton8, GTK_CAN_DEFAULT);
g_signal_connect(okbutton8, "clicked", G_CALLBACK (on_ok_clicked), this);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (shortcuts_dialog, shortcuts_dialog, "shortcuts_dialog");
GLADE_HOOKUP_OBJECT_NO_REF (shortcuts_dialog, dialog_vbox8, "dialog_vbox8");
GLADE_HOOKUP_OBJECT (shortcuts_dialog, label33, "label33");
GLADE_HOOKUP_OBJECT (shortcuts_dialog, label34, "label34");
GLADE_HOOKUP_OBJECT (shortcuts_dialog, combobox4, "combobox4");
GLADE_HOOKUP_OBJECT (shortcuts_dialog, scrolledwindow5, "scrolledwindow5");
GLADE_HOOKUP_OBJECT (shortcuts_dialog, treeview3, "treeview3");
GLADE_HOOKUP_OBJECT_NO_REF (shortcuts_dialog, dialog_action_area8, "dialog_action_area8");
GLADE_HOOKUP_OBJECT (shortcuts_dialog, cancelbutton8, "cancelbutton8");
GLADE_HOOKUP_OBJECT (shortcuts_dialog, okbutton8, "okbutton8");
GLADE_HOOKUP_OBJECT (shortcuts_dialog, resetall_btn, "resetall_btn");
GLADE_HOOKUP_OBJECT (shortcuts_dialog, clearall_btn, "clearall_btn");
return shortcuts_dialog;
}
static void
nautilus_mime_application_chooser_build_ui (NautilusMimeApplicationChooser *chooser)
{
GtkWidget *box, *button;
GAppInfo *info;
gtk_container_set_border_width (GTK_CONTAINER (chooser), 8);
gtk_box_set_spacing (GTK_BOX (chooser), 0);
gtk_box_set_homogeneous (GTK_BOX (chooser), FALSE);
chooser->details->label = gtk_label_new ("");
gtk_label_set_xalign (GTK_LABEL (chooser->details->label), 0);
gtk_label_set_line_wrap (GTK_LABEL (chooser->details->label), TRUE);
gtk_label_set_line_wrap_mode (GTK_LABEL (chooser->details->label),
PANGO_WRAP_WORD_CHAR);
gtk_box_pack_start (GTK_BOX (chooser), chooser->details->label,
FALSE, FALSE, 0);
gtk_widget_show (chooser->details->label);
chooser->details->open_with_widget = gtk_app_chooser_widget_new (chooser->details->content_type);
gtk_app_chooser_widget_set_show_default (GTK_APP_CHOOSER_WIDGET (chooser->details->open_with_widget),
TRUE);
gtk_app_chooser_widget_set_show_fallback (GTK_APP_CHOOSER_WIDGET (chooser->details->open_with_widget),
TRUE);
gtk_app_chooser_widget_set_show_other (GTK_APP_CHOOSER_WIDGET (chooser->details->open_with_widget),
TRUE);
gtk_box_pack_start (GTK_BOX (chooser), chooser->details->open_with_widget,
TRUE, TRUE, 6);
gtk_widget_show (chooser->details->open_with_widget);
box = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_set_spacing (GTK_BOX (box), 6);
gtk_button_box_set_layout (GTK_BUTTON_BOX (box), GTK_BUTTONBOX_END);
gtk_box_pack_start (GTK_BOX (chooser), box, FALSE, FALSE, 6);
gtk_widget_show (box);
button = gtk_button_new_with_label (_("Reset"));
g_signal_connect (button, "clicked",
G_CALLBACK (reset_clicked_cb),
chooser);
gtk_widget_show (button);
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
gtk_button_box_set_child_secondary (GTK_BUTTON_BOX (box), button, TRUE);
button = gtk_button_new_with_mnemonic (_("_Add"));
g_signal_connect (button, "clicked",
G_CALLBACK (add_clicked_cb),
chooser);
gtk_widget_show (button);
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
chooser->details->add_button = button;
button = gtk_button_new_with_label (_("Set as default"));
g_signal_connect (button, "clicked",
G_CALLBACK (set_as_default_clicked_cb),
chooser);
gtk_widget_show (button);
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
chooser->details->set_as_default_button = button;
/* initialize sensitivity */
info = gtk_app_chooser_get_app_info (GTK_APP_CHOOSER (chooser->details->open_with_widget));
if (info != NULL) {
application_selected_cb (GTK_APP_CHOOSER_WIDGET (chooser->details->open_with_widget),
info, chooser);
g_object_unref (info);
}
g_signal_connect (chooser->details->open_with_widget,
"application-selected",
G_CALLBACK (application_selected_cb),
chooser);
g_signal_connect (chooser->details->open_with_widget,
"populate-popup",
G_CALLBACK (populate_popup_cb),
chooser);
}
static inline DISPLAY_INFO*
create_popup_skelton() {
DISPLAY_INFO* const di = g_new0(DISPLAY_INFO, 1);
if (!di) return NULL;
di->widget.popup = gtk_window_new(GTK_WINDOW_POPUP);
if (!di->widget.popup) {
free_display_info(di);
return NULL;
}
gtk_window_set_title(GTK_WINDOW(di->widget.popup), "growl-for-linux");
gtk_window_set_resizable(GTK_WINDOW(di->widget.popup), FALSE);
gtk_window_set_decorated(GTK_WINDOW(di->widget.popup), FALSE);
gtk_window_set_keep_above(GTK_WINDOW(di->widget.popup), TRUE);
gtk_window_stick(GTK_WINDOW(di->widget.popup));
gtk_widget_modify_bg(di->widget.popup, GTK_STATE_NORMAL, color_lightgray);
GtkWidget* const ebox = gtk_event_box_new();
if (!ebox) {
free_display_info(di);
return NULL;
}
gtk_event_box_set_visible_window(GTK_EVENT_BOX(ebox), FALSE);
g_signal_connect(G_OBJECT(ebox), "button-press-event", G_CALLBACK(display_clicked), di);
g_signal_connect(G_OBJECT(ebox), "enter-notify-event", G_CALLBACK(display_enter), di);
g_signal_connect(G_OBJECT(ebox), "leave-notify-event", G_CALLBACK(display_leave), di);
gtk_container_add(GTK_CONTAINER(di->widget.popup), ebox);
GtkWidget* const vbox = gtk_vbox_new(FALSE, 5);
if (!vbox) {
free_display_info(di);
return NULL;
}
gtk_container_set_border_width(GTK_CONTAINER(vbox), 5);
gtk_container_add(GTK_CONTAINER(ebox), vbox);
GtkWidget* const hbox = gtk_hbox_new(FALSE, 5);
if (!hbox) {
free_display_info(di);
return NULL;
}
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
di->widget.title = gtk_label_new(NULL);
if (!di->widget.title) {
free_display_info(di);
return NULL;
}
gtk_widget_modify_fg(di->widget.title, GTK_STATE_NORMAL, color_black);
gtk_widget_modify_font(di->widget.title, font_sans12_desc);
gtk_box_pack_start(GTK_BOX(hbox), di->widget.title, FALSE, FALSE, 0);
di->widget.text = gtk_label_new(NULL);
if (!di->widget.text) {
free_display_info(di);
return NULL;
}
gtk_widget_modify_fg(di->widget.text, GTK_STATE_NORMAL, color_black);
gtk_widget_modify_font(di->widget.text, font_sans8_desc);
g_signal_connect(G_OBJECT(di->widget.text), "size-allocate", G_CALLBACK(label_size_allocate), NULL);
gtk_label_set_line_wrap(GTK_LABEL(di->widget.text), TRUE);
gtk_label_set_line_wrap_mode(GTK_LABEL(di->widget.text), PANGO_WRAP_CHAR);
gtk_box_pack_start(GTK_BOX(vbox), di->widget.text, FALSE, FALSE, 0);
gtk_widget_set_size_request(di->widget.popup, 180, 1);
#ifdef _WIN32
SetWindowPos(GDK_WINDOW_HWND(di->widget.popup->window), HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
#endif
return di;
}
static void
file_list_ready_cb (GList *files,
gpointer user_data)
{
CajaFileConflictDialog *fcd = user_data;
CajaFile *src, *dest, *dest_dir;
time_t src_mtime, dest_mtime;
gboolean source_is_dir, dest_is_dir, should_show_type;
CajaFileConflictDialogPrivate *details;
char *primary_text, *message, *secondary_text;
const gchar *message_extra;
char *dest_name, *dest_dir_name, *edit_name;
char *label_text;
char *size, *date, *type = NULL;
GdkPixbuf *pixbuf;
GtkWidget *label;
GString *str;
PangoAttrList *attr_list;
details = fcd->details;
details->handle = NULL;
dest_dir = g_list_nth_data (files, 0);
dest = g_list_nth_data (files, 1);
src = g_list_nth_data (files, 2);
src_mtime = caja_file_get_mtime (src);
dest_mtime = caja_file_get_mtime (dest);
dest_name = caja_file_get_display_name (dest);
dest_dir_name = caja_file_get_display_name (dest_dir);
source_is_dir = caja_file_is_directory (src);
dest_is_dir = caja_file_is_directory (dest);
type = caja_file_get_mime_type (dest);
should_show_type = !caja_file_is_mime_type (src, type);
g_free (type);
type = NULL;
/* Set up the right labels */
if (dest_is_dir)
{
if (source_is_dir)
{
primary_text = g_strdup_printf
(_("Merge folder \"%s\"?"),
dest_name);
message_extra =
_("Merging will ask for confirmation before replacing any files in "
"the folder that conflict with the files being copied.");
if (src_mtime > dest_mtime)
{
message = g_strdup_printf (
_("An older folder with the same name already exists in \"%s\"."),
dest_dir_name);
}
else if (src_mtime < dest_mtime)
{
message = g_strdup_printf (
_("A newer folder with the same name already exists in \"%s\"."),
dest_dir_name);
}
else
{
message = g_strdup_printf (
_("Another folder with the same name already exists in \"%s\"."),
dest_dir_name);
}
}
else
{
message_extra =
_("Replacing it will remove all files in the folder.");
primary_text = g_strdup_printf
(_("Replace folder \"%s\"?"), dest_name);
message = g_strdup_printf
(_("A folder with the same name already exists in \"%s\"."),
dest_dir_name);
}
}
else
{
primary_text = g_strdup_printf
(_("Replace file \"%s\"?"), dest_name);
message_extra = _("Replacing it will overwrite its content.");
if (src_mtime > dest_mtime)
{
message = g_strdup_printf (
_("An older file with the same name already exists in \"%s\"."),
dest_dir_name);
}
else if (src_mtime < dest_mtime)
{
message = g_strdup_printf (
_("A newer file with the same name already exists in \"%s\"."),
dest_dir_name);
}
else
{
message = g_strdup_printf (
_("Another file with the same name already exists in \"%s\"."),
dest_dir_name);
}
}
secondary_text = g_strdup_printf ("%s\n%s", message, message_extra);
g_free (message);
label = gtk_label_new (primary_text);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_line_wrap_mode (GTK_LABEL (label), PANGO_WRAP_WORD_CHAR);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_box_pack_start (GTK_BOX (details->titles_vbox),
label, FALSE, FALSE, 0);
gtk_widget_show (label);
attr_list = pango_attr_list_new ();
pango_attr_list_insert (attr_list, pango_attr_weight_new (PANGO_WEIGHT_BOLD));
pango_attr_list_insert (attr_list, pango_attr_scale_new (PANGO_SCALE_LARGE));
g_object_set (label,
"attributes", attr_list,
NULL);
pango_attr_list_unref (attr_list);
label = gtk_label_new (secondary_text);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_max_width_chars (GTK_LABEL (label), 60);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_box_pack_start (GTK_BOX (details->titles_vbox),
label, FALSE, FALSE, 0);
gtk_widget_show (label);
g_free (primary_text);
g_free (secondary_text);
/* Set up file icons */
pixbuf = caja_file_get_icon_pixbuf (dest,
CAJA_ICON_SIZE_LARGE,
TRUE,
gtk_widget_get_scale_factor (fcd->details->titles_vbox),
CAJA_FILE_ICON_FLAGS_USE_THUMBNAILS);
details->dest_image = gtk_image_new_from_pixbuf (pixbuf);
gtk_box_pack_start (GTK_BOX (details->first_hbox),
details->dest_image, FALSE, FALSE, 0);
gtk_widget_show (details->dest_image);
g_object_unref (pixbuf);
pixbuf = caja_file_get_icon_pixbuf (src,
CAJA_ICON_SIZE_LARGE,
TRUE,
gtk_widget_get_scale_factor (fcd->details->titles_vbox),
CAJA_FILE_ICON_FLAGS_USE_THUMBNAILS);
details->src_image = gtk_image_new_from_pixbuf (pixbuf);
gtk_box_pack_start (GTK_BOX (details->second_hbox),
details->src_image, FALSE, FALSE, 0);
gtk_widget_show (details->src_image);
g_object_unref (pixbuf);
/* Set up labels */
label = gtk_label_new (NULL);
date = caja_file_get_string_attribute (dest,
"date_modified");
size = caja_file_get_string_attribute (dest, "size");
if (should_show_type)
{
type = caja_file_get_string_attribute (dest, "type");
}
str = g_string_new (NULL);
if (dest_is_dir) {
g_string_append_printf (str, "<b>%s</b>\n", _("Original folder"));
g_string_append_printf (str, "%s %s\n", _("Items:"), size);
}
else {
g_string_append_printf (str, "<b>%s</b>\n", _("Original file"));
g_string_append_printf (str, "%s %s\n", _("Size:"), size);
}
if (should_show_type)
{
g_string_append_printf (str, "%s %s\n", _("Type:"), type);
}
g_string_append_printf (str, "%s %s", _("Last modified:"), date);
label_text = str->str;
gtk_label_set_markup (GTK_LABEL (label),
label_text);
gtk_box_pack_start (GTK_BOX (details->first_hbox),
label, FALSE, FALSE, 0);
gtk_widget_show (label);
g_free (size);
g_free (type);
g_free (date);
g_string_erase (str, 0, -1);
/* Second label */
label = gtk_label_new (NULL);
date = caja_file_get_string_attribute (src,
"date_modified");
size = caja_file_get_string_attribute (src, "size");
if (should_show_type)
{
type = caja_file_get_string_attribute (src, "type");
}
if (source_is_dir) {
g_string_append_printf (str, "<b>%s</b>\n", dest_is_dir ? _("Merge with") : _("Replace with"));
g_string_append_printf (str, "%s %s\n", _("Items:"), size);
}
else {
g_string_append_printf (str, "<b>%s</b>\n", _("Replace with"));
g_string_append_printf (str, "%s %s\n", _("Size:"), size);
}
if (should_show_type)
{
g_string_append_printf (str, "%s %s\n", _("Type:"), type);
}
g_string_append_printf (str, "%s %s", _("Last modified:"), date);
label_text = g_string_free (str, FALSE);
gtk_label_set_markup (GTK_LABEL (label),
label_text);
gtk_box_pack_start (GTK_BOX (details->second_hbox),
label, FALSE, FALSE, 0);
gtk_widget_show (label);
g_free (size);
g_free (date);
g_free (type);
g_free (label_text);
/* Populate the entry */
edit_name = caja_file_get_edit_name (dest);
details->conflict_name = edit_name;
gtk_entry_set_text (GTK_ENTRY (details->entry), edit_name);
if (source_is_dir && dest_is_dir)
{
gtk_button_set_label (GTK_BUTTON (details->replace_button),
_("Merge"));
}
/* If meld is installed, and source and destination arent binary
* files, show the diff button
*/
gtk_widget_hide (details->diff_button);
if (!source_is_dir && !dest_is_dir)
{
gchar *meld_found = g_find_program_in_path ("meld");
if (meld_found) {
g_free (meld_found);
gboolean src_is_binary;
gboolean dest_is_binary;
src_is_binary = caja_file_is_binary (details->source);
dest_is_binary = caja_file_is_binary (details->destination);
if (!src_is_binary && !dest_is_binary)
gtk_widget_show (details->diff_button);
}
}
caja_file_monitor_add (src, fcd, CAJA_FILE_ATTRIBUTES_FOR_ICON);
caja_file_monitor_add (dest, fcd, CAJA_FILE_ATTRIBUTES_FOR_ICON);
details->src_handler_id = g_signal_connect (src, "changed",
G_CALLBACK (file_icons_changed), fcd);
details->dest_handler_id = g_signal_connect (dest, "changed",
G_CALLBACK (file_icons_changed), fcd);
}
void
FormDialog::single_choice (const std::string name,
const std::string description,
const std::string value,
const std::map<std::string, std::string> choices,
bool advanced)
{
GtkWidget *label = NULL;
gchar* label_text = NULL;
GtkListStore *model = NULL;
GtkWidget *widget = NULL;
GtkCellRenderer *renderer = NULL;
GtkTreeIter iter;
SingleChoiceSubmitter *submitter = NULL;
grow_fields (advanced);
label = gtk_label_new (NULL);
gtk_size_group_add_widget (labels_group, label);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
label_text = g_strdup_printf ("<b>%s</b>", description.c_str ());
gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), label_text);
g_free (label_text);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_line_wrap_mode (GTK_LABEL (label), PANGO_WRAP_WORD);
model = gtk_list_store_new (SingleChoiceSubmitter::COLUMN_NUMBER,
G_TYPE_STRING, G_TYPE_STRING);
widget = gtk_combo_box_new_with_model (GTK_TREE_MODEL (model));
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (widget), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (widget), renderer,
"text", SingleChoiceSubmitter::COLUMN_NAME,
NULL);
for (std::map<std::string, std::string>::const_iterator map_iter
= choices.begin ();
map_iter != choices.end ();
map_iter++) {
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter,
SingleChoiceSubmitter::COLUMN_VALUE, map_iter->first.c_str (),
SingleChoiceSubmitter::COLUMN_NAME, map_iter->second.c_str (),
-1);
if (map_iter->first == value)
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (widget), &iter);
}
if (advanced) {
gtk_table_attach (GTK_TABLE (advanced_fields), label,
0, 1, advanced_rows -1, advanced_rows,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
0,0);
gtk_table_attach (GTK_TABLE (advanced_fields), widget,
1, 2, advanced_rows -1, advanced_rows,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
0,0);
} else {
gtk_table_attach (GTK_TABLE (fields), label,
0, 1, rows -1, rows,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
0,0);
gtk_table_attach (GTK_TABLE (fields), widget,
1, 2, rows -1, rows,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
0,0);
}
submitter = new SingleChoiceSubmitter (name, description, choices,
advanced, widget);
submitters.push_back (submitter);
}
GtkWindow* create_notification(UrlClickedCb url_clicked)
{
GtkWidget* win;
GtkWidget* main_vbox;
GtkWidget* vbox;
GtkWidget* close_button;
GtkWidget* image;
GtkWidget* alignment;
AtkObject* atkobj;
WindowData* windata;
GdkVisual *visual;
GdkScreen* screen;
windata = g_new0(WindowData, 1);
windata->urgency = URGENCY_NORMAL;
windata->url_clicked = url_clicked;
win = gtk_window_new(GTK_WINDOW_POPUP);
gtk_window_set_resizable(GTK_WINDOW(win), FALSE);
gtk_widget_set_app_paintable(win, TRUE);
g_signal_connect(G_OBJECT(win), "style-updated", G_CALLBACK(on_style_updated), windata);
g_signal_connect(G_OBJECT(win), "map-event", G_CALLBACK(on_window_map), windata);
g_signal_connect(G_OBJECT(win), "draw", G_CALLBACK(on_draw), windata);
g_signal_connect(G_OBJECT(win), "realize", G_CALLBACK(on_window_realize), windata);
windata->win = win;
windata->composited = FALSE;
screen = gtk_window_get_screen(GTK_WINDOW(win));
visual = gdk_screen_get_rgba_visual(screen);
if (visual != NULL)
{
gtk_widget_set_visual(win, visual);
if (gdk_screen_is_composited(screen))
{
windata->composited = TRUE;
}
}
g_signal_connect(win, "composited-changed", G_CALLBACK(on_composited_changed), windata);
gtk_window_set_title(GTK_WINDOW(win), "Notification");
gtk_window_set_type_hint(GTK_WINDOW(win), GDK_WINDOW_TYPE_HINT_NOTIFICATION);
gtk_widget_add_events(win, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
g_object_set_data_full(G_OBJECT(win), "windata", windata, (GDestroyNotify) destroy_windata);
atk_object_set_role(gtk_widget_get_accessible(win), ATK_ROLE_ALERT);
g_signal_connect(G_OBJECT(win), "configure-event", G_CALLBACK(on_configure_event), windata);
main_vbox = gtk_vbox_new(FALSE, 0);
#if GTK_CHECK_VERSION (3, 0, 0)
g_signal_connect(G_OBJECT(main_vbox), "style-updated", G_CALLBACK(on_style_updated), windata);
#else
g_signal_connect(G_OBJECT(main_vbox), "style-set", G_CALLBACK(on_style_set), windata);
#endif
gtk_widget_show(main_vbox);
gtk_container_add(GTK_CONTAINER(win), main_vbox);
gtk_container_set_border_width(GTK_CONTAINER(main_vbox), 12);
windata->main_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_show(windata->main_hbox);
gtk_box_pack_start(GTK_BOX(main_vbox), windata->main_hbox, FALSE, FALSE, 0);
/* First row (icon, vbox, close) */
windata->iconbox = gtk_alignment_new(0.5, 0, 0, 0);
gtk_widget_show(windata->iconbox);
gtk_alignment_set_padding(GTK_ALIGNMENT(windata->iconbox), 5, 0, 0, 0);
gtk_box_pack_start(GTK_BOX(windata->main_hbox), windata->iconbox, FALSE, FALSE, 0);
gtk_widget_set_size_request(windata->iconbox, BODY_X_OFFSET, -1);
windata->icon = gtk_image_new();
gtk_widget_show(windata->icon);
gtk_container_add(GTK_CONTAINER(windata->iconbox), windata->icon);
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 6);
gtk_widget_show(vbox);
gtk_box_pack_start(GTK_BOX(windata->main_hbox), vbox, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 10);
/* Add the close button */
alignment = gtk_alignment_new(0.5, 0, 0, 0);
gtk_widget_show(alignment);
gtk_box_pack_start(GTK_BOX(windata->main_hbox), alignment, FALSE, FALSE, 0);
close_button = gtk_button_new();
gtk_widget_show(close_button);
windata->close_button = close_button;
gtk_container_add(GTK_CONTAINER(alignment), close_button);
gtk_button_set_relief(GTK_BUTTON(close_button), GTK_RELIEF_NONE);
gtk_container_set_border_width(GTK_CONTAINER(close_button), 0);
g_signal_connect_swapped(G_OBJECT(close_button), "clicked", G_CALLBACK(gtk_widget_destroy), win);
atkobj = gtk_widget_get_accessible(close_button);
atk_action_set_description(ATK_ACTION(atkobj), 0, "Closes the notification.");
atk_object_set_name(atkobj, "");
atk_object_set_description(atkobj, "Closes the notification.");
image = gtk_image_new_from_icon_name ("window-close", GTK_ICON_SIZE_MENU);
gtk_widget_show(image);
gtk_container_add(GTK_CONTAINER(close_button), image);
/* center vbox */
windata->summary_label = gtk_label_new(NULL);
gtk_widget_show(windata->summary_label);
gtk_box_pack_start(GTK_BOX(vbox), windata->summary_label, TRUE, TRUE, 0);
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (windata->summary_label), 0.0);
gtk_label_set_yalign (GTK_LABEL (windata->summary_label), 0.0);
#else
gtk_misc_set_alignment(GTK_MISC(windata->summary_label), 0.0, 0.0);
#endif
gtk_label_set_line_wrap(GTK_LABEL(windata->summary_label), TRUE);
gtk_label_set_line_wrap_mode (GTK_LABEL (windata->summary_label), PANGO_WRAP_WORD_CHAR);
atkobj = gtk_widget_get_accessible(windata->summary_label);
atk_object_set_description(atkobj, "Notification summary text.");
windata->content_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
gtk_widget_show(windata->content_hbox);
gtk_box_pack_start(GTK_BOX(vbox), windata->content_hbox, FALSE, FALSE, 0);
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 6);
gtk_widget_show(vbox);
gtk_box_pack_start(GTK_BOX(windata->content_hbox), vbox, TRUE, TRUE, 0);
windata->body_label = gtk_label_new(NULL);
gtk_widget_show(windata->body_label);
gtk_box_pack_start(GTK_BOX(vbox), windata->body_label, TRUE, TRUE, 0);
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (windata->body_label), 0.0);
gtk_label_set_yalign (GTK_LABEL (windata->body_label), 0.0);
#else
gtk_misc_set_alignment(GTK_MISC(windata->body_label), 0.0, 0.0);
#endif
gtk_label_set_line_wrap(GTK_LABEL(windata->body_label), TRUE);
gtk_label_set_line_wrap_mode (GTK_LABEL (windata->body_label), PANGO_WRAP_WORD_CHAR);
gtk_label_set_max_width_chars (GTK_LABEL (windata->body_label), 50);
g_signal_connect_swapped(G_OBJECT(windata->body_label), "activate-link", G_CALLBACK(windata->url_clicked), win);
atkobj = gtk_widget_get_accessible(windata->body_label);
atk_object_set_description(atkobj, "Notification body text.");
alignment = gtk_alignment_new(1, 0.5, 0, 0);
gtk_widget_show(alignment);
gtk_box_pack_start(GTK_BOX(vbox), alignment, FALSE, TRUE, 0);
windata->actions_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
gtk_widget_show(windata->actions_box);
gtk_container_add(GTK_CONTAINER(alignment), windata->actions_box);
return GTK_WINDOW(win);
}
/* desktopicon_new_do */
static DesktopIcon * _desktopicon_new_do(Desktop * desktop, GdkPixbuf * image,
char const * name)
{
DesktopIcon * desktopicon;
GtkWindow * window;
GtkWidget * vbox;
GdkGeometry geometry;
if((desktopicon = malloc(sizeof(*desktopicon))) == NULL)
return NULL;
memset(desktopicon, 0, sizeof(*desktopicon));
desktopicon->desktop = desktop;
desktopicon->confirm = TRUE;
desktopicon->updated = TRUE;
/* window */
desktopicon->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
window = GTK_WINDOW(desktopicon->window);
gtk_window_set_decorated(window, FALSE);
#if GTK_CHECK_VERSION(2, 6, 0)
gtk_window_set_focus_on_map(window, FALSE);
#endif
gtk_window_set_keep_below(window, TRUE);
gtk_window_set_resizable(window, FALSE);
gtk_window_set_skip_pager_hint(window, TRUE);
#ifdef EMBEDDED
gtk_window_set_type_hint(window, GDK_WINDOW_TYPE_HINT_UTILITY);
#else
gtk_window_set_type_hint(window, GDK_WINDOW_TYPE_HINT_DOCK);
#endif
g_signal_connect(G_OBJECT(desktopicon->window), "delete-event",
G_CALLBACK(_on_desktopicon_closex), NULL);
/* event */
desktopicon->event = gtk_event_box_new();
g_signal_connect(G_OBJECT(desktopicon->event), "button-press-event",
G_CALLBACK(_on_icon_button_press), desktopicon);
g_signal_connect(G_OBJECT(desktopicon->event), "key-press-event",
G_CALLBACK(_on_icon_key_press), desktopicon);
vbox = gtk_vbox_new(FALSE, 4);
geometry.min_width = DESKTOPICON_MIN_WIDTH;
geometry.min_height = DESKTOPICON_MIN_HEIGHT;
geometry.max_width = DESKTOPICON_MAX_WIDTH;
geometry.max_height = DESKTOPICON_MAX_HEIGHT;
geometry.base_width = DESKTOPICON_MIN_WIDTH;
geometry.base_height = DESKTOPICON_MIN_HEIGHT;
gtk_window_set_geometry_hints(window, vbox, &geometry, /* XXX check */
GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE
| GDK_HINT_BASE_SIZE);
/* image */
desktopicon->image = gtk_image_new();
gtk_widget_set_size_request(desktopicon->image, DESKTOPICON_ICON_SIZE,
DESKTOPICON_ICON_SIZE);
gtk_box_pack_start(GTK_BOX(vbox), desktopicon->image, FALSE, TRUE, 0);
/* label */
desktopicon->label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(desktopicon->label), 0.5, 0.0);
#if GTK_CHECK_VERSION(2, 10, 0)
gtk_label_set_line_wrap_mode(GTK_LABEL(desktopicon->label),
PANGO_WRAP_WORD_CHAR);
#endif
gtk_label_set_line_wrap(GTK_LABEL(desktopicon->label), TRUE);
gtk_box_pack_start(GTK_BOX(vbox), desktopicon->label, TRUE, TRUE, 4);
gtk_container_add(GTK_CONTAINER(desktopicon->event), vbox);
gtk_container_add(GTK_CONTAINER(desktopicon->window),
desktopicon->event);
if(image == NULL)
image = desktop_get_file(desktop);
_desktopicon_set_icon(desktopicon, image);
_desktopicon_set_name(desktopicon, name);
_desktopicon_update_transparency(desktopicon);
return desktopicon;
}
static void
file_list_ready_cb (GList *files,
gpointer user_data)
{
CajaFileConflictDialog *fcd = user_data;
CajaFile *src, *dest, *dest_dir;
time_t src_mtime, dest_mtime;
GtkDialog *dialog;
gboolean source_is_dir, dest_is_dir, should_show_type;
CajaFileConflictDialogDetails *details;
char *primary_text, *message, *secondary_text;
const gchar *message_extra;
char *src_name, *dest_name, *dest_dir_name, *edit_name;
char *label_text;
char *size, *date, *type = NULL;
GdkPixbuf *pixbuf;
GtkWidget *label;
GString *str;
PangoFontDescription *desc;
dialog = GTK_DIALOG (fcd);
details = fcd->details;
details->handle = NULL;
dest_dir = g_list_nth_data (files, 0);
dest = g_list_nth_data (files, 1);
src = g_list_nth_data (files, 2);
src_mtime = caja_file_get_mtime (src);
dest_mtime = caja_file_get_mtime (dest);
src_name = caja_file_get_display_name (src);
dest_name = caja_file_get_display_name (dest);
dest_dir_name = caja_file_get_display_name (dest_dir);
source_is_dir = caja_file_is_directory (src);
dest_is_dir = caja_file_is_directory (dest);
type = caja_file_get_mime_type (dest);
should_show_type = !caja_file_is_mime_type (src, type);
g_free (type);
type = NULL;
/* Set up the right labels */
if (dest_is_dir)
{
if (source_is_dir)
{
primary_text = g_strdup_printf
(_("Merge folder \"%s\"?"),
dest_name);
message_extra =
_("Merging will ask for confirmation before replacing any files in "
"the folder that conflict with the files being copied.");
if (src_mtime > dest_mtime)
{
message = g_strdup_printf (
_("An older folder with the same name already exists in \"%s\"."),
dest_dir_name);
}
else if (src_mtime < dest_mtime)
{
message = g_strdup_printf (
_("A newer folder with the same name already exists in \"%s\"."),
dest_dir_name);
}
else
{
message = g_strdup_printf (
_("Another folder with the same name already exists in \"%s\"."),
dest_dir_name);
}
}
else
{
message_extra =
_("Replacing it will remove all files in the folder.");
primary_text = g_strdup_printf
(_("Replace folder \"%s\"?"), dest_name);
message = g_strdup_printf
(_("A folder with the same name already exists in \"%s\"."),
dest_dir_name);
}
}
else
{
primary_text = g_strdup_printf
(_("Replace file \"%s\"?"), dest_name);
message_extra = _("Replacing it will overwrite its content.");
if (src_mtime > dest_mtime)
{
message = g_strdup_printf (
_("An older file with the same name already exists in \"%s\"."),
dest_dir_name);
}
else if (src_mtime < dest_mtime)
{
message = g_strdup_printf (
_("A newer file with the same name already exists in \"%s\"."),
dest_dir_name);
}
else
{
message = g_strdup_printf (
_("Another file with the same name already exists in \"%s\"."),
dest_dir_name);
}
}
secondary_text = g_strdup_printf ("%s\n%s", message, message_extra);
g_free (message);
label = gtk_label_new (primary_text);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_line_wrap_mode (GTK_LABEL (label), PANGO_WRAP_WORD_CHAR);
gtk_widget_set_size_request (label, 350, -1);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (details->titles_vbox),
label, FALSE, FALSE, 0);
gtk_widget_modify_font (label, NULL);
desc = pango_font_description_new ();
pango_font_description_set_weight (desc, PANGO_WEIGHT_BOLD);
pango_font_description_set_size (desc,
pango_font_description_get_size (gtk_widget_get_style (label)->font_desc) * PANGO_SCALE_LARGE);
gtk_widget_modify_font (label, desc);
pango_font_description_free (desc);
gtk_widget_show (label);
label = gtk_label_new (secondary_text);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_widget_set_size_request (label, 350, -1);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (details->titles_vbox),
label, FALSE, FALSE, 0);
gtk_widget_show (label);
g_free (primary_text);
g_free (secondary_text);
/* Set up file icons */
pixbuf = caja_file_get_icon_pixbuf (dest,
CAJA_ICON_SIZE_LARGE,
TRUE,
CAJA_FILE_ICON_FLAGS_USE_THUMBNAILS);
details->dest_image = gtk_image_new_from_pixbuf (pixbuf);
gtk_box_pack_start (GTK_BOX (details->first_hbox),
details->dest_image, FALSE, FALSE, 0);
gtk_widget_show (details->dest_image);
g_object_unref (pixbuf);
pixbuf = caja_file_get_icon_pixbuf (src,
CAJA_ICON_SIZE_LARGE,
TRUE,
CAJA_FILE_ICON_FLAGS_USE_THUMBNAILS);
details->src_image = gtk_image_new_from_pixbuf (pixbuf);
gtk_box_pack_start (GTK_BOX (details->second_hbox),
details->src_image, FALSE, FALSE, 0);
gtk_widget_show (details->src_image);
g_object_unref (pixbuf);
/* Set up labels */
label = gtk_label_new (NULL);
date = caja_file_get_string_attribute (dest,
"date_modified");
size = caja_file_get_string_attribute (dest, "size");
if (should_show_type)
{
type = caja_file_get_string_attribute (dest, "type");
}
str = g_string_new (NULL);
g_string_append_printf (str, "<b>%s</b>\n", _("Original file"));
g_string_append_printf (str, "<i>%s</i> %s\n", _("Size:"), size);
if (should_show_type)
{
g_string_append_printf (str, "<i>%s</i> %s\n", _("Type:"), type);
}
g_string_append_printf (str, "<i>%s</i> %s", _("Last modified:"), date);
label_text = str->str;
gtk_label_set_markup (GTK_LABEL (label),
label_text);
gtk_box_pack_start (GTK_BOX (details->first_hbox),
label, FALSE, FALSE, 0);
gtk_widget_show (label);
g_free (size);
g_free (type);
g_free (date);
g_string_erase (str, 0, -1);
/* Second label */
label = gtk_label_new (NULL);
date = caja_file_get_string_attribute (src,
"date_modified");
size = caja_file_get_string_attribute (src, "size");
if (should_show_type)
{
type = caja_file_get_string_attribute (src, "type");
}
g_string_append_printf (str, "<b>%s</b>\n", _("Replace with"));
g_string_append_printf (str, "<i>%s</i> %s\n", _("Size:"), size);
if (should_show_type)
{
g_string_append_printf (str, "<i>%s</i> %s\n", _("Type:"), type);
}
g_string_append_printf (str, "<i>%s</i> %s", _("Last modified:"), date);
label_text = g_string_free (str, FALSE);
gtk_label_set_markup (GTK_LABEL (label),
label_text);
gtk_box_pack_start (GTK_BOX (details->second_hbox),
label, FALSE, FALSE, 0);
gtk_widget_show (label);
g_free (size);
g_free (date);
g_free (type);
g_free (label_text);
/* Populate the entry */
edit_name = caja_file_get_edit_name (dest);
details->conflict_name = edit_name;
gtk_entry_set_text (GTK_ENTRY (details->entry), edit_name);
if (source_is_dir && dest_is_dir)
{
gtk_button_set_label (GTK_BUTTON (details->replace_button),
_("Merge"));
}
caja_file_monitor_add (src, fcd, CAJA_FILE_ATTRIBUTES_FOR_ICON);
caja_file_monitor_add (dest, fcd, CAJA_FILE_ATTRIBUTES_FOR_ICON);
details->src_handler_id = g_signal_connect (src, "changed",
G_CALLBACK (file_icons_changed), fcd);
details->dest_handler_id = g_signal_connect (dest, "changed",
G_CALLBACK (file_icons_changed), fcd);
}
GtkWindow* create_notification(UrlClickedCb url_clicked)
{
GtkWidget* spacer;
GtkWidget* win;
GtkWidget* main_vbox;
GtkWidget* hbox;
GtkWidget* vbox;
GtkWidget* close_button;
GtkWidget* image;
GtkWidget* alignment;
AtkObject* atkobj;
#if !GTK_CHECK_VERSION(3, 0, 0)
GtkRcStyle* rcstyle;
#endif
WindowData* windata;
#if GTK_CHECK_VERSION (3, 0, 0)
GdkVisual *visual;
#else
GdkColormap* colormap;
#endif
GdkScreen* screen;
windata = g_new0(WindowData, 1);
windata->urgency = URGENCY_NORMAL;
windata->url_clicked = url_clicked;
win = gtk_window_new(GTK_WINDOW_POPUP);
windata->win = win;
windata->composited = FALSE;
screen = gtk_window_get_screen(GTK_WINDOW(win));
#if GTK_CHECK_VERSION (3, 0, 0)
visual = gdk_screen_get_rgba_visual(screen);
if (visual != NULL)
{
gtk_widget_set_visual(win, visual);
if (gdk_screen_is_composited(screen))
{
windata->composited = TRUE;
}
}
#else
colormap = gdk_screen_get_rgba_colormap(screen);
if (colormap != NULL && gdk_screen_is_composited(screen))
{
gtk_widget_set_colormap(win, colormap);
windata->composited = TRUE;
}
#endif
gtk_window_set_title(GTK_WINDOW(win), "Notification");
gtk_window_set_type_hint(GTK_WINDOW(win), GDK_WINDOW_TYPE_HINT_NOTIFICATION);
gtk_widget_add_events(win, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
gtk_widget_realize(win);
gtk_widget_set_size_request(win, WIDTH, -1);
g_object_set_data_full(G_OBJECT(win), "windata", windata, (GDestroyNotify) destroy_windata);
atk_object_set_role(gtk_widget_get_accessible(win), ATK_ROLE_ALERT);
g_signal_connect(G_OBJECT(win), "configure_event", G_CALLBACK(configure_event_cb), windata);
main_vbox = gtk_vbox_new(FALSE, 0);
gtk_widget_show(main_vbox);
gtk_container_add (GTK_CONTAINER (win), main_vbox);
gtk_container_set_border_width(GTK_CONTAINER(main_vbox), 1);
#if GTK_CHECK_VERSION (3, 0, 0)
g_signal_connect (G_OBJECT (main_vbox), "draw", G_CALLBACK (on_draw), windata);
#else
g_signal_connect (G_OBJECT (main_vbox), "expose_event", G_CALLBACK (on_expose_event), windata);
#endif
windata->top_spacer = gtk_image_new();
gtk_box_pack_start(GTK_BOX(main_vbox), windata->top_spacer, FALSE, FALSE, 0);
gtk_widget_set_size_request(windata->top_spacer, -1, DEFAULT_ARROW_HEIGHT);
windata->main_hbox = gtk_hbox_new(FALSE, 0);
gtk_widget_show(windata->main_hbox);
gtk_box_pack_start(GTK_BOX(main_vbox), windata->main_hbox, FALSE, FALSE, 0);
windata->bottom_spacer = gtk_image_new();
gtk_box_pack_start(GTK_BOX(main_vbox), windata->bottom_spacer, FALSE, FALSE, 0);
gtk_widget_set_size_request(windata->bottom_spacer, -1, DEFAULT_ARROW_HEIGHT);
vbox = gtk_vbox_new(FALSE, 6);
gtk_widget_show(vbox);
gtk_box_pack_start(GTK_BOX(windata->main_hbox), vbox, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 10);
hbox = gtk_hbox_new(FALSE, 6);
gtk_widget_show(hbox);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
spacer = gtk_image_new();
gtk_widget_show(spacer);
gtk_box_pack_start(GTK_BOX(hbox), spacer, FALSE, FALSE, 0);
gtk_widget_set_size_request(spacer, SPACER_LEFT, -1);
windata->summary_label = gtk_label_new(NULL);
gtk_widget_show(windata->summary_label);
gtk_box_pack_start(GTK_BOX(hbox), windata->summary_label, TRUE, TRUE, 0);
#if GTK_CHECK_VERSION (3, 15, 2)
gtk_label_set_xalign (GTK_LABEL (windata->summary_label), 0.0);
gtk_label_set_yalign (GTK_LABEL (windata->summary_label), 0.0);
#else
gtk_misc_set_alignment(GTK_MISC(windata->summary_label), 0, 0);
#endif
gtk_label_set_line_wrap(GTK_LABEL(windata->summary_label), TRUE);
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_label_set_line_wrap_mode (GTK_LABEL (windata->summary_label), PANGO_WRAP_WORD_CHAR);
#endif
atkobj = gtk_widget_get_accessible(windata->summary_label);
atk_object_set_description(atkobj, "Notification summary text.");
/* Add the close button */
alignment = gtk_alignment_new(1, 0, 0, 0);
gtk_widget_show(alignment);
gtk_box_pack_start(GTK_BOX(hbox), alignment, FALSE, FALSE, 0);
close_button = gtk_button_new();
windata->close_button = close_button;
gtk_widget_show(close_button);
gtk_container_add(GTK_CONTAINER(alignment), close_button);
gtk_button_set_relief(GTK_BUTTON(close_button), GTK_RELIEF_NONE);
gtk_container_set_border_width(GTK_CONTAINER(close_button), 0);
//gtk_widget_set_size_request(close_button, 20, 20);
g_signal_connect_swapped(G_OBJECT(close_button), "clicked", G_CALLBACK(gtk_widget_destroy), win);
#if !GTK_CHECK_VERSION(3, 0, 0)
rcstyle = gtk_rc_style_new();
rcstyle->xthickness = rcstyle->ythickness = 0;
gtk_widget_modify_style(close_button, rcstyle);
g_object_unref(rcstyle);
#endif
atkobj = gtk_widget_get_accessible(close_button);
atk_action_set_description(ATK_ACTION(atkobj), 0, "Closes the notification.");
atk_object_set_name(atkobj, "");
atk_object_set_description(atkobj, "Closes the notification.");
image = gtk_image_new_from_stock(GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU);
gtk_widget_show(image);
gtk_container_add(GTK_CONTAINER(close_button), image);
windata->content_hbox = gtk_hbox_new(FALSE, 6);
gtk_box_pack_start(GTK_BOX(vbox), windata->content_hbox, FALSE, FALSE, 0);
windata->iconbox = gtk_hbox_new(FALSE, 0);
gtk_widget_show(windata->iconbox);
gtk_box_pack_start(GTK_BOX(windata->content_hbox), windata->iconbox, FALSE, FALSE, 0);
gtk_widget_set_size_request(windata->iconbox, BODY_X_OFFSET, -1);
windata->icon = gtk_image_new();
gtk_box_pack_start(GTK_BOX(windata->iconbox), windata->icon, TRUE, TRUE, 0);
gtk_misc_set_alignment(GTK_MISC(windata->icon), 0.5, 0.0);
vbox = gtk_vbox_new(FALSE, 6);
gtk_widget_show(vbox);
gtk_box_pack_start(GTK_BOX(windata->content_hbox), vbox, TRUE, TRUE, 0);
windata->body_label = gtk_label_new(NULL);
gtk_box_pack_start(GTK_BOX(vbox), windata->body_label, TRUE, TRUE, 0);
#if GTK_CHECK_VERSION (3, 15, 2)
gtk_label_set_xalign (GTK_LABEL (windata->body_label), 0.0);
gtk_label_set_yalign (GTK_LABEL (windata->body_label), 0.0);
#else
gtk_misc_set_alignment(GTK_MISC(windata->body_label), 0, 0);
#endif
gtk_label_set_line_wrap(GTK_LABEL(windata->body_label), TRUE);
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_label_set_line_wrap_mode (GTK_LABEL (windata->body_label), PANGO_WRAP_WORD_CHAR);
#endif
g_signal_connect(G_OBJECT(windata->body_label), "activate-link", G_CALLBACK(activate_link), windata);
atkobj = gtk_widget_get_accessible(windata->body_label);
atk_object_set_description(atkobj, "Notification body text.");
alignment = gtk_alignment_new(1, 0.5, 0, 0);
gtk_widget_show(alignment);
gtk_box_pack_start(GTK_BOX(vbox), alignment, FALSE, TRUE, 0);
windata->actions_box = gtk_hbox_new(FALSE, 6);
gtk_container_add(GTK_CONTAINER(alignment), windata->actions_box);
return GTK_WINDOW(win);
}
