GtkWidget *plugin_configure(GtkDialog *dialog)
{
GtkWidget *label1, *label2, *vbox;
vbox = gtk_vbox_new(FALSE, 6);
/* add a label and a text entry to the dialog */
label1 = gtk_label_new(_("Path and options for the mail client:"));
gtk_widget_show(label1);
gtk_misc_set_alignment(GTK_MISC(label1), 0, 0.5);
pref_widgets.entry = gtk_entry_new();
gtk_widget_show(pref_widgets.entry);
if (mailer != NULL)
gtk_entry_set_text(GTK_ENTRY(pref_widgets.entry), mailer);
label2 = gtk_label_new(_("Note: \n\t%f will be replaced by your file."\
"\n\t%r will be replaced by recipient's email address."\
"\n\t%b will be replaced by basename of a file"\
"\n\tExamples:"\
"\n\tsylpheed --attach \"%f\" --compose \"%r\""\
"\n\tmutt -s \"Sending \'%b\'\" -a \"%f\" \"%r\""));
gtk_label_set_selectable(GTK_LABEL(label2), TRUE);
gtk_widget_show(label2);
gtk_misc_set_alignment(GTK_MISC(label2), 0, 0.5);
pref_widgets.checkbox_icon_to_toolbar = gtk_check_button_new_with_label(_("Show toolbar icon"));
gtk_widget_set_tooltip_text(pref_widgets.checkbox_icon_to_toolbar,
_("Shows a icon in the toolbar to send file more easy."));
gtk_button_set_focus_on_click(GTK_BUTTON(pref_widgets.checkbox_icon_to_toolbar), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pref_widgets.checkbox_icon_to_toolbar), icon_in_toolbar);
gtk_widget_show(pref_widgets.checkbox_icon_to_toolbar);
pref_widgets.checkbox_use_addressdialog = gtk_check_button_new_with_label(_
("Use dialog for entering email address of recipients"));
gtk_button_set_focus_on_click(GTK_BUTTON(pref_widgets.checkbox_use_addressdialog), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pref_widgets.checkbox_use_addressdialog), use_address_dialog);
gtk_widget_show(pref_widgets.checkbox_use_addressdialog);
gtk_box_pack_start(GTK_BOX(vbox), label1, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), pref_widgets.entry, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), label2, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), pref_widgets.checkbox_icon_to_toolbar, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), pref_widgets.checkbox_use_addressdialog, FALSE, FALSE, 0);
gtk_widget_show(vbox);
g_signal_connect(dialog, "response", G_CALLBACK(on_configure_response), NULL);
return vbox;
}
/* Create a new tab. */
LXTab * lxterminal_tab_label_new(const gchar * str)
{
/* Allocate LXTab structure. */
LXTab * tab = g_slice_new0(LXTab);
/* Create a horizontal box as the toplevel. */
tab->main = gtk_hbox_new(FALSE, 4);
/* Create the Close button. */
tab->close_btn = gtk_button_new();
gtk_button_set_relief(GTK_BUTTON(tab->close_btn), GTK_RELIEF_NONE);
gtk_button_set_focus_on_click(GTK_BUTTON(tab->close_btn), FALSE);
gtk_container_add(GTK_CONTAINER(tab->close_btn), gtk_image_new_from_stock(GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU));
/* Make the button as small as possible. */
GtkRcStyle * rcstyle = gtk_rc_style_new();
rcstyle->xthickness = rcstyle->ythickness = 0;
gtk_widget_modify_style(tab->close_btn, rcstyle);
gtk_rc_style_unref(rcstyle),
/* Create the label. */
tab->label = gtk_label_new(str);
gtk_widget_set_size_request(GTK_WIDGET(tab->label), 100, -1);
gtk_label_set_ellipsize(GTK_LABEL(tab->label), PANGO_ELLIPSIZE_END);
gtk_misc_set_alignment(GTK_MISC(tab->label), 0.0, 0.5);
gtk_misc_set_padding(GTK_MISC(tab->label), 0, 0);
/* Pack everything, show the widget and return. */
gtk_box_pack_start(GTK_BOX(tab->main), tab->label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(tab->main), tab->close_btn, FALSE, FALSE, 0);
gtk_widget_show_all(tab->main);
return tab;
}
static GtkWidget *newTabLabel(OovStringRef const tabText, GtkWidget *viewTopParent)
{
GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_add(GTK_CONTAINER(box), gtk_label_new(tabText));
GtkButton *button = GTK_BUTTON(gtk_button_new());
gtk_button_set_relief(button, GTK_RELIEF_NORMAL);
gtk_button_set_focus_on_click(button, false);
gtk_button_set_image(button,
gtk_image_new_from_icon_name("window-close", GTK_ICON_SIZE_SMALL_TOOLBAR)); //GTK_ICON_SIZE_MENU));
char const * const data = "* {\n"
"-GtkButton-default-border : 0px;\n"
"-GtkButton-default-outside-border : 0px;\n"
"-GtkButton-inner-border: 0px;\n"
"-GtkWidget-focus-line-width : 0px;\n"
"-GtkWidget-focus-padding : 0px;\n"
"padding: 0px;\n"
"}";
GtkCssProvider *provider = gtk_css_provider_new();
gtk_css_provider_load_from_data(provider, data, -1, NULL);
GtkStyleContext *context = gtk_widget_get_style_context(GTK_WIDGET(button));
gtk_style_context_add_provider(context, GTK_STYLE_PROVIDER(provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
// gtk_box_pack_start(box, button, False, False, 0);
gtk_container_add(GTK_CONTAINER(box), GTK_WIDGET(button));
g_signal_connect(button, "clicked", G_CALLBACK(onTabLabelCloseClicked), viewTopParent);
gtk_widget_show_all(box);
return box;
}
static void
gtk_inspector_window_init (GtkInspectorWindow *iw)
{
GIOExtensionPoint *extension_point;
GList *l, *extensions;
gtk_widget_init_template (GTK_WIDGET (iw));
gtk_window_group_add_window (gtk_window_group_new (), GTK_WINDOW (iw));
extension_point = g_io_extension_point_lookup ("gtk-inspector-page");
extensions = g_io_extension_point_get_extensions (extension_point);
for (l = extensions; l != NULL; l = l->next)
{
GIOExtension *extension = l->data;
GType type;
GtkWidget *widget;
const char *name;
char *title;
GtkWidget *button;
gboolean use_picker;
type = g_io_extension_get_type (extension);
widget = g_object_new (type, NULL);
iw->extra_pages = g_list_prepend (iw->extra_pages, widget);
name = g_io_extension_get_name (extension);
g_object_get (widget, "title", &title, NULL);
if (g_object_class_find_property (G_OBJECT_GET_CLASS (widget), "use-picker"))
g_object_get (widget, "use-picker", &use_picker, NULL);
else
use_picker = FALSE;
if (use_picker)
{
button = gtk_button_new_from_icon_name ("find-location-symbolic",
GTK_ICON_SIZE_MENU);
gtk_button_set_focus_on_click (GTK_BUTTON (button), FALSE);
gtk_widget_set_halign (button, GTK_ALIGN_START);
gtk_widget_set_valign (button, GTK_ALIGN_CENTER);
g_signal_connect (button, "clicked",
G_CALLBACK (gtk_inspector_on_inspect), iw);
}
else
button = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_stack_add_titled (GTK_STACK (iw->top_stack), widget, name, title);
gtk_stack_add_named (GTK_STACK (iw->button_stack), button, name);
gtk_widget_show (widget);
gtk_widget_show (button);
g_free (title);
}
}
GtkWidget * FontButton::newFontButton() {
GtkWidget * w = gtk_font_button_new();
gtk_widget_show(w);
gtk_font_button_set_use_font(GTK_FONT_BUTTON(w), TRUE);
gtk_button_set_focus_on_click(GTK_BUTTON(w), FALSE);
return w;
}
void
gdm_extension_list_add_extension (GdmExtensionList *extension_list,
GdmLoginExtension *extension)
{
GtkWidget *image;
GtkWidget *button;
GIcon *icon;
char *description;
if (extension_list->priv->extensions == NULL) {
button = gtk_radio_button_new (NULL);
} else {
GdmLoginExtension *previous_extension;
GtkRadioButton *previous_button;
previous_extension = GDM_LOGIN_EXTENSION (extension_list->priv->extensions->data);
previous_button = GTK_RADIO_BUTTON (g_object_get_data (G_OBJECT (previous_extension), "gdm-extension-list-button"));
button = gtk_radio_button_new_from_widget (previous_button);
}
g_object_set_data (G_OBJECT (extension), "gdm-extension-list-button", button);
g_object_set (G_OBJECT (button), "draw-indicator", FALSE, NULL);
g_object_set_data (G_OBJECT (button), "gdm-extension", extension);
g_signal_connect_swapped (button, "toggled",
G_CALLBACK (on_extension_toggled),
extension_list);
gtk_button_set_focus_on_click (GTK_BUTTON (button), FALSE);
gtk_widget_set_sensitive (button, gdm_login_extension_is_enabled (extension));
g_signal_connect_swapped (G_OBJECT (extension), "enabled",
G_CALLBACK (on_extension_enabled),
extension_list);
g_signal_connect_swapped (G_OBJECT (extension), "disabled",
G_CALLBACK (on_extension_disabled),
extension_list);
icon = gdm_login_extension_get_icon (extension);
image = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_SMALL_TOOLBAR);
g_object_unref (icon);
gtk_widget_show (image);
gtk_container_add (GTK_CONTAINER (button), image);
description = gdm_login_extension_get_description (extension);
gtk_widget_set_tooltip_text (button, description);
g_free (description);
gtk_widget_show (button);
gtk_container_add (GTK_CONTAINER (extension_list->priv->box), button);
extension_list->priv->extensions = g_list_append (extension_list->priv->extensions,
g_object_ref (extension));
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button))) {
g_signal_emit (extension_list, signals[ACTIVATED], 0, extension);
}
}
static GtkWidget *
build_tab_label (NautilusNotebook *nb, NautilusWindowSlot *slot)
{
GtkWidget *hbox, *label, *close_button, *image, *spinner, *icon;
/* set hbox spacing and label padding (see below) so that there's an
* equal amount of space around the label */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
gtk_widget_show (hbox);
/* setup load feedback */
spinner = gtk_spinner_new ();
gtk_box_pack_start (GTK_BOX (hbox), spinner, FALSE, FALSE, 0);
/* setup site icon, empty by default */
icon = gtk_image_new ();
gtk_box_pack_start (GTK_BOX (hbox), icon, FALSE, FALSE, 0);
/* don't show the icon */
/* setup label */
label = gtk_label_new (NULL);
gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
gtk_label_set_single_line_mode (GTK_LABEL (label), TRUE);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_misc_set_padding (GTK_MISC (label), 0, 0);
gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
gtk_widget_show (label);
/* setup close button */
close_button = gtk_button_new ();
gtk_button_set_relief (GTK_BUTTON (close_button),
GTK_RELIEF_NONE);
/* don't allow focus on the close button */
gtk_button_set_focus_on_click (GTK_BUTTON (close_button), FALSE);
gtk_widget_set_name (close_button, "nautilus-tab-close-button");
image = gtk_image_new_from_icon_name ("window-close-symbolic", GTK_ICON_SIZE_MENU);
gtk_widget_set_tooltip_text (close_button, _("Close tab"));
g_signal_connect_object (close_button, "clicked",
G_CALLBACK (close_button_clicked_cb), slot, 0);
gtk_container_add (GTK_CONTAINER (close_button), image);
gtk_widget_show (image);
gtk_box_pack_start (GTK_BOX (hbox), close_button, FALSE, FALSE, 0);
gtk_widget_show (close_button);
nautilus_drag_slot_proxy_init (hbox, NULL, slot);
g_object_set_data (G_OBJECT (hbox), "label", label);
g_object_set_data (G_OBJECT (hbox), "spinner", spinner);
g_object_set_data (G_OBJECT (hbox), "icon", icon);
g_object_set_data (G_OBJECT (hbox), "close-button", close_button);
return hbox;
}
static void
empathy_presence_chooser_init (EmpathyPresenceChooser *chooser)
{
GtkWidget *arrow;
GtkWidget *alignment;
EmpathyPresenceChooserPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (chooser,
EMPATHY_TYPE_PRESENCE_CHOOSER, EmpathyPresenceChooserPriv);
chooser->priv = priv;
gtk_button_set_relief (GTK_BUTTON (chooser), GTK_RELIEF_NONE);
gtk_button_set_focus_on_click (GTK_BUTTON (chooser), FALSE);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment);
gtk_container_add (GTK_CONTAINER (chooser), alignment);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 1, 0);
priv->hbox = gtk_hbox_new (FALSE, 1);
gtk_widget_show (priv->hbox);
gtk_container_add (GTK_CONTAINER (alignment), priv->hbox);
priv->image = gtk_image_new ();
gtk_widget_show (priv->image);
gtk_box_pack_start (GTK_BOX (priv->hbox), priv->image, FALSE, TRUE, 0);
priv->label = gtk_label_new (NULL);
gtk_widget_show (priv->label);
gtk_box_pack_start (GTK_BOX (priv->hbox), priv->label, TRUE, TRUE, 0);
gtk_label_set_ellipsize (GTK_LABEL (priv->label), PANGO_ELLIPSIZE_END);
gtk_misc_set_alignment (GTK_MISC (priv->label), 0, 0.5);
gtk_misc_set_padding (GTK_MISC (priv->label), 4, 1);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment);
gtk_box_pack_start (GTK_BOX (priv->hbox), alignment, FALSE, FALSE, 0);
arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_OUT);
gtk_widget_show (arrow);
gtk_container_add (GTK_CONTAINER (alignment), arrow);
g_signal_connect (chooser, "toggled",
G_CALLBACK (presence_chooser_toggled_cb),
NULL);
g_signal_connect (chooser, "button-press-event",
G_CALLBACK (presence_chooser_button_press_event_cb),
NULL);
g_signal_connect (chooser, "scroll-event",
G_CALLBACK (presence_chooser_scroll_event_cb),
NULL);
priv->idle = empathy_idle_dup_singleton ();
presence_chooser_presence_changed_cb (chooser);
g_signal_connect_swapped (priv->idle, "notify",
G_CALLBACK (presence_chooser_presence_changed_cb),
chooser);
}
static void
he_check_button_init (HeCheckButton *self)
{
HeCheckButtonPrivate *priv = HE_CHECK_BUTTON_GET_PRIVATE (self);
/* Store private part */
self->priv = priv;
priv->title = GTK_LABEL (gtk_label_new (NULL));
priv->value = GTK_LABEL (gtk_label_new (NULL));
priv->alignment = gtk_alignment_new (0.5, 0.5, 0, 0);
priv->toggle_renderer = GTK_CELL_RENDERER_TOGGLE (gtk_cell_renderer_toggle_new ());
priv->cell_view = gtk_cell_view_new ();
priv->hbox = NULL;
priv->label_box = NULL;
priv->style = HE_CHECK_BUTTON_STYLE_NORMAL;
priv->setting_style = FALSE;
/* Setup the cell renderer */
/* We need to set the correct style from the gtkrc file. Otherwise the check box
* does not look like a check box on a HildonCheckButton. */
GtkStyle *style = gtk_rc_get_style_by_paths(gtk_widget_get_settings(GTK_WIDGET(self)),
NULL, "*.HildonCheckButton.GtkAlignment.GtkHBox.GtkCellView", G_TYPE_NONE);
gtk_widget_set_style(priv->cell_view, style);
/* Make sure that the check box is always shown, no matter the value of gtk-button-images */
g_signal_connect (priv->cell_view, "notify::visible", G_CALLBACK (gtk_widget_show), NULL);
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (priv->cell_view),
GTK_CELL_RENDERER (priv->toggle_renderer), TRUE);
/* Get checkbox-size style property of HildonCheckButton from theme */
style = gtk_rc_get_style_by_paths (gtk_widget_get_settings (GTK_WIDGET(self)),
NULL, "*.HildonCheckButton", HILDON_TYPE_CHECK_BUTTON);
glong checkbox_size = get_style_property_long (style, HILDON_TYPE_CHECK_BUTTON, "checkbox-size");
/* Set the indicator to the right size (the size of the pixmap) */
g_object_set (priv->toggle_renderer, "indicator-size", checkbox_size, NULL);
/* Setup the labels */
gtk_widget_set_name (GTK_WIDGET (priv->title), "hildon-button-title");
gtk_widget_set_name (GTK_WIDGET (priv->value), "hildon-button-value");
he_check_button_set_style (self, HE_CHECK_BUTTON_STYLE_NORMAL);
gtk_misc_set_alignment (GTK_MISC (priv->title), 0, 0.5);
gtk_misc_set_alignment (GTK_MISC (priv->value), 0, 0.5);
g_object_ref_sink (priv->alignment);
/* The labels are not shown automatically, see he_check_button_set_(title|value) */
gtk_widget_set_no_show_all (GTK_WIDGET (priv->title), TRUE);
gtk_widget_set_no_show_all (GTK_WIDGET (priv->value), TRUE);
gtk_button_set_focus_on_click (GTK_BUTTON (self), FALSE);
}
PraghaScanner *
pragha_scanner_new()
{
PraghaScanner *scanner;
PraghaStatusbar *statusbar;
GtkWidget *hbox, *progress_bar, *button, *image;
scanner = g_slice_new0(PraghaScanner);
/* Create widgets */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
progress_bar = gtk_progress_bar_new();
gtk_widget_set_size_request(progress_bar, PROGRESS_BAR_WIDTH, -1);
gtk_progress_bar_set_show_text (GTK_PROGRESS_BAR(progress_bar), TRUE);
button = gtk_button_new ();
image = gtk_image_new_from_icon_name ("process-stop", GTK_ICON_SIZE_MENU);
gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
gtk_button_set_focus_on_click (GTK_BUTTON (button), FALSE);
gtk_container_add (GTK_CONTAINER (button), image);
g_signal_connect(G_OBJECT (button),
"clicked",
G_CALLBACK(scanner_cancel_click_handler),
scanner);
gtk_box_pack_start (GTK_BOX (hbox), progress_bar, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
/* Init the rest and save references */
scanner->progress_bar = progress_bar;
scanner->hbox = hbox;
scanner->tracks_table = g_hash_table_new_full (g_str_hash,
g_str_equal,
g_free,
g_object_unref);
scanner->files_scanned = 0;
g_mutex_init (&scanner->files_scanned_mutex);
scanner->no_files = 0;
g_mutex_init (&scanner->no_files_mutex);
scanner->cancellable = g_cancellable_new ();
scanner->update_timeout = 0;
/* Append the widget */
statusbar = pragha_statusbar_get ();
pragha_statusbar_add_widget(statusbar, hbox);
g_object_unref(G_OBJECT(statusbar));
return scanner;
}
static void
photos_delete_notification_constructed (GObject *object)
{
PhotosDeleteNotification *self = PHOTOS_DELETE_NOTIFICATION (object);
gchar *msg;
GtkWidget *close;
GtkWidget *image;
GtkWidget *label;
GtkWidget *undo;
guint length;
G_OBJECT_CLASS (photos_delete_notification_parent_class)->constructed (object);
length = g_list_length (self->items);
if (length == 1)
{
const gchar *name;
name = photos_base_item_get_name_with_fallback (PHOTOS_BASE_ITEM (self->items->data));
msg = g_strdup_printf (_("“%s” deleted"), name);
}
else
msg = g_strdup_printf (ngettext ("%d item deleted", "%d items deleted", length), length);
label = gtk_label_new (msg);
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_hexpand (label, TRUE);
gtk_container_add (GTK_CONTAINER (self), label);
g_free (msg);
undo = gtk_button_new_with_label (_("Undo"));
gtk_widget_set_valign (undo, GTK_ALIGN_CENTER);
gtk_container_add (GTK_CONTAINER (self), undo);
g_signal_connect_swapped (undo, "clicked", G_CALLBACK (photos_delete_notification_undo_clicked), self);
image = gtk_image_new_from_icon_name (PHOTOS_ICON_WINDOW_CLOSE_SYMBOLIC, GTK_ICON_SIZE_INVALID);
gtk_widget_set_margin_bottom (image, 2);
gtk_widget_set_margin_top (image, 2);
gtk_image_set_pixel_size (GTK_IMAGE (image), 16);
close = gtk_button_new ();
gtk_widget_set_valign (close, GTK_ALIGN_CENTER);
gtk_button_set_focus_on_click (GTK_BUTTON (close), FALSE);
gtk_button_set_relief (GTK_BUTTON (close), GTK_RELIEF_NONE);
gtk_button_set_image (GTK_BUTTON (close), image);
gtk_container_add (GTK_CONTAINER (self), close);
g_signal_connect_swapped (close, "clicked", G_CALLBACK (photos_delete_notification_delete_items), self);
photos_notification_manager_add_notification (PHOTOS_NOTIFICATION_MANAGER (self->ntfctn_mngr),
GTK_WIDGET (self));
self->timeout_id = g_timeout_add_seconds (DELETE_TIMEOUT, photos_delete_notification_timeout, self);
}
/**
* xfce_panel_create_toggle_button:
*
* Create regular #GtkToggleButton with a few properties set to be useful in
* Xfce panel: Flat (%GTK_RELIEF_NONE), no focus on click and minimal padding.
*
* Returns: newly created #GtkToggleButton.
**/
GtkWidget *
xfce_panel_create_toggle_button (void)
{
GtkWidget *button = gtk_toggle_button_new ();
GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_DEFAULT | GTK_CAN_FOCUS);
gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
gtk_button_set_focus_on_click (GTK_BUTTON (button), FALSE);
gtk_widget_set_name (button, "xfce-panel-toggle-button");
return button;
}
static void
gtk_scale_button_init (GtkScaleButton *button)
{
GtkScaleButtonPrivate *priv;
button->priv = priv = GET_PRIVATE (button);
priv->timeout = FALSE;
priv->click_id = 0;
priv->click_timeout = CLICK_TIMEOUT;
priv->orientation = GTK_ORIENTATION_VERTICAL;
gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
gtk_button_set_focus_on_click (GTK_BUTTON (button), FALSE);
/* image */
priv->image = gtk_image_new ();
gtk_container_add (GTK_CONTAINER (button), priv->image);
gtk_widget_show_all (priv->image);
/* window */
priv->dock = gtk_window_new (GTK_WINDOW_POPUP);
gtk_widget_set_name (priv->dock, "gtk-scalebutton-popup-window");
g_signal_connect (priv->dock, "button-press-event",
G_CALLBACK (cb_dock_button_press), button);
g_signal_connect (priv->dock, "key-release-event",
G_CALLBACK (cb_dock_key_release), button);
g_signal_connect (priv->dock, "grab-notify",
G_CALLBACK (cb_dock_grab_notify), button);
g_signal_connect (priv->dock, "grab-broken-event",
G_CALLBACK (cb_dock_grab_broken_event), button);
gtk_window_set_decorated (GTK_WINDOW (priv->dock), FALSE);
/* + */
button->plus_button = gtk_button_new_with_label ("+");
gtk_button_set_relief (GTK_BUTTON (button->plus_button), GTK_RELIEF_NONE);
g_signal_connect (button->plus_button, "button-press-event",
G_CALLBACK (cb_button_press), button);
g_signal_connect (button->plus_button, "button-release-event",
G_CALLBACK (cb_button_release), button);
/* - */
button->minus_button = gtk_button_new_with_label ("-");
gtk_button_set_relief (GTK_BUTTON (button->minus_button), GTK_RELIEF_NONE);
g_signal_connect (button->minus_button, "button-press-event",
G_CALLBACK (cb_button_press), button);
g_signal_connect (button->minus_button, "button-release-event",
G_CALLBACK (cb_button_release), button);
priv->adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 100.0, 2, 20, 0));
g_object_ref_sink (priv->adjustment);
}
static GObject *
terminal_tab_label_constructor (GType type,
guint n_construct_properties,
GObjectConstructParam *construct_params)
{
GObject *object;
TerminalTabLabel *tab_label;
TerminalTabLabelPrivate *priv;
GtkWidget *hbox, *label, *close_button, *image;
object = G_OBJECT_CLASS (terminal_tab_label_parent_class)->constructor
(type, n_construct_properties, construct_params);
tab_label = TERMINAL_TAB_LABEL (object);
hbox = GTK_WIDGET (tab_label);
priv = tab_label->priv;
g_assert (priv->screen != NULL);
gtk_box_set_spacing (GTK_BOX (hbox), SPACING);
priv->label = label = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_misc_set_padding (GTK_MISC (label), 0, 0);
gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
gtk_label_set_single_line_mode (GTK_LABEL (label), TRUE);
gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
priv->close_button = close_button = gtk_button_new ();
gtk_button_set_relief (GTK_BUTTON (close_button), GTK_RELIEF_NONE);
gtk_button_set_focus_on_click (GTK_BUTTON (close_button), FALSE);
gtk_button_set_relief (GTK_BUTTON (close_button), GTK_RELIEF_NONE);
gtk_widget_set_name (close_button, "gnome-terminal-tab-close-button");
gtk_widget_set_tooltip_text (close_button, _("Close tab"));
image = gtk_image_new_from_stock (GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU);
gtk_container_add (GTK_CONTAINER (close_button), image);
gtk_box_pack_end (GTK_BOX (hbox), close_button, FALSE, FALSE, 0);
sync_tab_label (priv->screen, NULL, label);
g_signal_connect (priv->screen, "notify::title",
G_CALLBACK (sync_tab_label), label);
g_signal_connect (close_button, "clicked",
G_CALLBACK (close_button_clicked_cb), tab_label);
gtk_widget_show_all (hbox);
return object;
}
/*
Creates button
*/
extern
GtkWidget* launcher_create_button (char *id_image)
{
GtkWidget *widget;
GtkWidget *image;
widget = gtk_button_new();
image = gtk_image_new_from_pixbuf(create_pixbuf(id_image));
gtk_button_set_image(GTK_BUTTON(widget), image);
gtk_button_set_relief(GTK_BUTTON(widget), GTK_RELIEF_NONE);
gtk_button_set_focus_on_click(GTK_BUTTON(widget), FALSE);
gtk_button_set_image_position(GTK_BUTTON(widget), GTK_POS_LEFT);
return widget;
}
int
clip_GTK_BUTTONSETFOCUSONCLICK(ClipMachine * ClipMachineMemory)
{
C_widget *cbtn = _fetch_cw_arg(ClipMachineMemory);
gboolean focus_on_click = _clip_parl(ClipMachineMemory, 2);
CHECKCWID(cbtn, GTK_IS_BUTTON);
CHECKARG(2, LOGICAL_type_of_ClipVarType);
gtk_button_set_focus_on_click(GTK_BUTTON(cbtn->widget), focus_on_click);
return 0;
err:
return 1;
}
static bool
on_simple_chat_added (ChatWindow* self,
Ekiga::SimpleChatPtr chat)
{
GtkWidget* page = NULL;
GtkWidget* hbox = NULL;
GtkWidget* label = NULL;
GtkWidget* close_button = NULL;
GtkWidget* close_image = NULL;
page = simple_chat_page_new (chat);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
label = gtk_label_new (chat->get_title ().c_str ());
g_object_set_data_full (G_OBJECT (label), "base-title",
g_strdup (chat->get_title ().c_str ()),
g_free);
close_button = gtk_button_new ();
gtk_button_set_relief (GTK_BUTTON (close_button), GTK_RELIEF_NONE);
gtk_button_set_focus_on_click (GTK_BUTTON (close_button), FALSE);
close_image = gtk_image_new_from_stock (GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU);
gtk_widget_set_size_request (GTK_WIDGET (close_image), 12, 12);
gtk_widget_set_size_request (GTK_WIDGET (close_button), 16, 16);
gtk_container_add (GTK_CONTAINER (close_button), close_image);
gtk_container_set_border_width (GTK_CONTAINER (close_button), 0);
g_object_set_data (G_OBJECT (close_button), "page-widget", page);
g_signal_connect (close_button, "clicked",
G_CALLBACK (on_close_button_clicked), self);
gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 2);
g_object_set_data (G_OBJECT (hbox), "label-widget", label);
gtk_box_pack_end (GTK_BOX (hbox), close_button, FALSE, FALSE, 2);
g_object_set_data (G_OBJECT (hbox), "close-button-widget", close_button);
gtk_widget_show_all (hbox);
gtk_notebook_append_page (GTK_NOTEBOOK (self->priv->notebook),
page, hbox);
gtk_widget_show (page);
g_signal_connect (page, "message-notice-event",
G_CALLBACK (on_message_notice_event), self);
self->priv->connections.add (chat->user_requested.connect (boost::bind (&on_some_chat_user_requested, self, page)));
return true;
}
static void
glide_slide_button_init (GlideSlideButton *button)
{
button->priv = GLIDE_SLIDE_BUTTON_GET_PRIVATE (button);
button->priv->drawing_area = gtk_drawing_area_new ();
gtk_container_add (GTK_CONTAINER (button), button->priv->drawing_area);
gtk_widget_show (GTK_WIDGET (button->priv->drawing_area));
g_signal_connect (button, "clicked", G_CALLBACK (glide_slide_button_clicked), NULL);
g_signal_connect (button->priv->drawing_area, "expose-event",
G_CALLBACK (glide_slide_button_drawing_area_expose),
button);
gtk_widget_set_size_request (button->priv->drawing_area, 80, 60);
gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
gtk_button_set_focus_on_click (GTK_BUTTON (button), FALSE);
}
static void
places_button_construct(PlacesButton *self, XfcePanelPlugin *plugin)
{
GtkOrientation orientation;
g_assert(XFCE_IS_PANEL_PLUGIN(plugin));
g_object_ref(plugin);
self->plugin = plugin;
/* from libxfce4panel */
GTK_WIDGET_UNSET_FLAGS(self, GTK_CAN_DEFAULT|GTK_CAN_FOCUS);
gtk_button_set_relief(GTK_BUTTON(self), GTK_RELIEF_NONE);
gtk_button_set_focus_on_click(GTK_BUTTON(self), FALSE);
self->alignment = gtk_alignment_new (0.0, 0.5, 1.0, 1.0);
gtk_container_add(GTK_CONTAINER(self), self->alignment);
gtk_widget_show(self->alignment);
orientation = xfce_panel_plugin_get_orientation(self->plugin);
self->box = xfce_hvbox_new(orientation, FALSE, BOX_SPACING);
gtk_container_set_border_width(GTK_CONTAINER(self->box), 0);
gtk_container_add(GTK_CONTAINER(self->alignment), self->box);
gtk_widget_show(self->box);
places_button_resize(self);
#ifdef HAS_PANEL_49
g_signal_connect(G_OBJECT(plugin), "mode-changed",
G_CALLBACK(places_button_mode_changed), self);
#else
g_signal_connect(G_OBJECT(plugin), "orientation-changed",
G_CALLBACK(places_button_orientation_changed), self);
#endif
g_signal_connect(G_OBJECT(plugin), "size-changed",
G_CALLBACK(places_button_size_changed), self);
self->style_set_id = g_signal_connect(G_OBJECT(self), "style-set",
G_CALLBACK(places_button_theme_changed), NULL);
self->screen_changed_id = g_signal_connect(G_OBJECT(self), "screen-changed",
G_CALLBACK(places_button_theme_changed), NULL);
}
static void
gtk_tool_button_init (GtkToolButton *button,
GtkToolButtonClass *klass)
{
GtkToolItem *toolitem = GTK_TOOL_ITEM (button);
button->priv = GTK_TOOL_BUTTON_GET_PRIVATE (button);
button->priv->contents_invalid = TRUE;
gtk_tool_item_set_homogeneous (toolitem, TRUE);
/* create button */
button->priv->button = g_object_new (klass->button_type, NULL);
gtk_button_set_focus_on_click (GTK_BUTTON (button->priv->button), FALSE);
g_signal_connect_object (button->priv->button, "clicked",
G_CALLBACK (button_clicked), button, 0);
gtk_container_add (GTK_CONTAINER (button), button->priv->button);
gtk_widget_show (button->priv->button);
}
GtkWidget *
bluefish_small_close_button_new(void)
{
/* TODO: Add a tooltip to the button */
GtkWidget *button, *image;
#if GTK_CHECK_VERSION(3,0,0)
GtkCssProvider *provider;
GtkStyleContext *context;
static const gchar button_style[] =
"GtkButton#bluefish-small-close-button {\n"
"-GtkButton-default-border: 0;\n"
"-GtkButton-default-outside-border: 0;\n"
"-GtkButton-inner-border: 0;\n"
"-GtkWidget-focus-line-width: 0;\n"
"-GtkWidget-focus-padding: 0;\n"
"padding: 0;\n"
"}";
#endif
button = gtk_button_new();
gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
gtk_button_set_focus_on_click(GTK_BUTTON(button), FALSE);
gtk_widget_set_name(button, "bluefish-small-close-button");
image = gtk_image_new_from_stock(GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU);
gtk_button_set_image(GTK_BUTTON(button), image);
#if GTK_CHECK_VERSION(3,0,0)
provider = gtk_css_provider_new();
gtk_css_provider_load_from_data(provider, button_style, -1, NULL);
context = gtk_widget_get_style_context(GTK_WIDGET(button));
gtk_style_context_add_provider(context, GTK_STYLE_PROVIDER(provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
g_object_unref(provider);
#else
g_signal_connect(button, "style-set", G_CALLBACK(button_set_style), NULL);
#endif
return button;
}
/*
* Sets the properties of the widget. This is used for both applying the
* properties changed in the property editor, and also for loading.
*/
static void
gb_gnome_color_picker_set_properties (GtkWidget * widget, GbWidgetSetArgData * data)
{
gboolean dither, use_alpha, focus_on_click;
gchar *title;
dither = gb_widget_input_bool (data, Dither);
if (data->apply)
gnome_color_picker_set_dither (GNOME_COLOR_PICKER (widget), dither);
use_alpha = gb_widget_input_bool (data, UseAlpha);
if (data->apply)
gnome_color_picker_set_use_alpha (GNOME_COLOR_PICKER (widget), use_alpha);
title = gb_widget_input_string (data, Title);
if (data->apply)
gnome_color_picker_set_title (GNOME_COLOR_PICKER (widget), title);
focus_on_click = gb_widget_input_bool (data, FocusOnClick);
if (data->apply)
gtk_button_set_focus_on_click (GTK_BUTTON (widget), focus_on_click);
}
static ClipmanPlugin *
clipman_new (XfcePanelPlugin *plugin)
{
ClipmanPlugin *clipman;
clipman = g_new0 (ClipmanPlugin, 1);
clipman->clips = g_ptr_array_new ();
clipman->plugin = plugin;
clipman->tooltip = gtk_tooltips_new ();
g_object_ref (clipman->tooltip);
clipman_read (clipman);
clipman->button = gtk_toggle_button_new ();
gtk_widget_show (clipman->button);
gtk_button_set_relief (GTK_BUTTON (clipman->button), GTK_RELIEF_NONE);
gtk_button_set_focus_on_click (GTK_BUTTON (clipman->button), FALSE);
gtk_tooltips_set_tip (GTK_TOOLTIPS(clipman->tooltip),
clipman->button, _("Clipboard Manager"),
NULL);
g_signal_connect(clipman->button, "button_press_event",
G_CALLBACK(clipman_clicked), clipman);
/* Start the clipman_check function */
clipman->TimeoutId = g_timeout_add_full(G_PRIORITY_LOW,
TIMER_INTERVAL,
(GSourceFunc) clipman_check,
clipman,
(GDestroyNotify) clipman_reset_timeout);
/* Connect to the clipboards */
defaultClip = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
primaryClip = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
return clipman;
}
// Close button
GtkWidget* close_button_new()
{
auto* self = GTK_WIDGET(g_object_new(close_button_get_type(), nullptr));
gtk_button_set_relief(GTK_BUTTON(self), GTK_RELIEF_NONE);
gtk_button_set_focus_on_click(GTK_BUTTON(self), FALSE);
gtk_widget_set_can_focus(self, FALSE);
gtk_widget_set_halign(self, GTK_ALIGN_START);
auto const& file = decoration::Style::Get()->ThemedFilePath(CLOSE_BUTTON_INACTIVE_FILE, {PKGDATADIR"/"});
auto* img = gtk_image_new_from_file(file.c_str());
gtk_container_add(GTK_CONTAINER(self), img);
CLOSE_BUTTON(self)->priv->img = GTK_IMAGE(img);
glib::Object<GtkCssProvider> style(gtk_css_provider_new());
gtk_css_provider_load_from_data(style, R"(
* {padding: 0px 0px 0px 0px; border: 0px; }
)", -1, nullptr);
auto* style_ctx = gtk_widget_get_style_context(self);
gtk_style_context_add_provider(style_ctx, glib::object_cast<GtkStyleProvider>(style), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
return self;
}
/*
* Sets the properties of the widget. This is used for both applying the
* properties changed in the property editor, and also for loading.
*/
static void
gb_gnome_href_set_properties (GtkWidget * widget, GbWidgetSetArgData * data)
{
gchar *url, *label_text;
gboolean focus_on_click;
url = gb_widget_input_string (data, HRefURL);
if (data->apply)
gnome_href_set_url (GNOME_HREF (widget), url && url[0] ? url : "");
label_text = gb_widget_input_text (data, HRefLabel);
/* Support the old name we used for the property. */
if (!data->apply && data->action == GB_LOADING)
label_text = gb_widget_input_text (data, "label");
if (data->apply)
gnome_href_set_text (GNOME_HREF (widget), label_text);
if (data->action == GB_APPLYING)
g_free (label_text);
focus_on_click = gb_widget_input_bool (data, FocusOnClick);
if (data->apply)
gtk_button_set_focus_on_click (GTK_BUTTON (widget), focus_on_click);
}
static GtkWidget * make_close_button (gint list)
{
GtkWidget * button = gtk_button_new ();
gtk_button_set_relief ((GtkButton *) button, GTK_RELIEF_NONE);
gtk_button_set_focus_on_click ((GtkButton *) button, FALSE);
gtk_widget_set_name (button, "gtkui-tab-close-button");
gtk_widget_set_tooltip_text (button, _("Close"));
g_signal_connect (button, "clicked", (GCallback) close_button_cb,
GINT_TO_POINTER (aud_playlist_get_unique_id (list)));
GtkCssProvider * provider = gtk_css_provider_new ();
gtk_css_provider_load_from_data (provider,
"#gtkui-tab-close-button {"
" -GtkButton-default-border: 0;"
" -GtkButton-default-outside-border: 0;"
" -GtkButton-inner-border: 0;"
" -GtkWidget-focus-padding: 0;"
" -GtkWidget-focus-line-width: 0;"
" margin: 0;"
" padding: 0; }",
-1, NULL);
gtk_style_context_add_provider (gtk_widget_get_style_context (button),
GTK_STYLE_PROVIDER (provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
g_object_unref (provider);
GtkWidget * icon = gtk_image_new_from_stock (GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU);
gtk_container_add ((GtkContainer *) button, icon);
GtkWidget * align = gtk_alignment_new (1.0, 0.5, 0.0, 0.0);
gtk_container_add ((GtkContainer *) align, button);
gtk_widget_show_all (align);
return align;
}
static GtkWidget *
finfo_creeaza_buton(GtkWindow *fereastraParinte,
const gchar *textAfisat, fl_media_type tpImg,
const gchar *textIndicatie, void (*fctClicked)(GtkWidget *, GtkWindow *)) {
GtkWidget *btRezultat = NULL;
/* inițializări generale */
btRezultat = gtk_button_new_with_label(textAfisat);
gtk_button_set_relief(GTK_BUTTON(btRezultat), GTK_RELIEF_HALF);
gtk_button_set_focus_on_click(GTK_BUTTON(btRezultat), FALSE);
gtk_widget_set_tooltip_markup(btRezultat, textIndicatie);
if(NULL != fctClicked) {
g_signal_connect(btRezultat, "clicked", G_CALLBACK(fctClicked), fereastraParinte);
}
/* atașăm pictograma */
GdkPixbuf *imgbtPixBuf = fl_obtine_imagine_media_scalata(tpImg, 16, 16);
GtkWidget *imgbt = gtk_image_new_from_pixbuf(imgbtPixBuf);
g_object_unref(imgbtPixBuf);
gtk_button_set_image_position(GTK_BUTTON(btRezultat), GTK_POS_RIGHT);
gtk_button_set_image(GTK_BUTTON(btRezultat), imgbt);
return btRezultat;
}
static GObject * main_window_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties) {
GObject * obj;
GObjectClass * parent_class;
MainWindow * self;
GdkEventMask _tmp0_;
GdkEventMask _tmp1_;
GtkAccelGroup* _tmp2_;
GtkAccelGroup* accel_group;
GtkAccelGroup* _tmp3_;
GdkRGBA bg_color = {0};
gchar* _tmp4_ = NULL;
gchar* _tmp5_;
GdkRGBA _tmp6_;
AtkObject* _tmp7_ = NULL;
const gchar* _tmp8_ = NULL;
GdkWindow* _tmp9_ = NULL;
cairo_t* _tmp10_ = NULL;
cairo_t* _tmp11_;
cairo_surface_t* _tmp12_ = NULL;
Background* _tmp13_;
Background* _tmp14_;
gboolean _tmp15_ = FALSE;
Background* _tmp16_;
gchar* _tmp17_ = NULL;
gchar* _tmp18_;
Background* _tmp19_;
gchar* _tmp20_ = NULL;
gchar* _tmp21_;
gchar* _tmp22_ = NULL;
gchar* _tmp23_;
Background* _tmp24_;
Background* _tmp25_;
Background* _tmp26_;
GtkBox* _tmp27_;
GtkBox* _tmp28_;
Background* _tmp29_;
GtkBox* _tmp30_;
GtkEventBox* _tmp31_;
GtkEventBox* menubox;
GtkAlignment* _tmp32_;
GtkAlignment* menualign;
gchar* _tmp33_ = NULL;
gchar* shadow_path;
gchar* _tmp34_;
gchar* shadow_style;
const gchar* _tmp35_;
gboolean _tmp36_ = FALSE;
GtkEventBox* _tmp51_;
GtkEventBox* _tmp52_;
GtkAlignment* _tmp53_;
GtkEventBox* _tmp54_;
GtkAlignment* _tmp55_;
GtkBox* _tmp56_;
GtkEventBox* _tmp57_;
GtkAlignment* _tmp58_;
GtkEventBox* _tmp59_;
Background* _tmp60_;
GtkAccelGroup* _tmp61_;
MenuBar* _tmp62_;
MenuBar* _tmp63_;
GtkAlignment* _tmp64_;
MenuBar* _tmp65_;
MenuBar* _tmp66_;
GtkBox* _tmp67_;
GtkBox* _tmp68_;
GtkBox* _tmp69_;
GtkBox* _tmp70_;
GtkBox* _tmp71_;
GtkAlignment* _tmp72_;
GtkAlignment* align;
GtkAlignment* _tmp73_;
GtkAlignment* _tmp74_;
GtkAlignment* _tmp75_;
GtkBox* _tmp76_;
GtkAlignment* _tmp77_;
FlatButton* _tmp78_;
GtkButton* _tmp79_;
gchar* _tmp80_ = NULL;
gchar* _tmp81_;
GtkImage* _tmp82_;
GtkImage* _tmp83_;
GtkImage* image;
GtkImage* _tmp84_;
GtkButton* _tmp85_;
GtkButton* _tmp86_;
GtkImage* _tmp87_;
GtkButton* _tmp88_;
GtkAlignment* _tmp89_;
GtkButton* _tmp90_;
GtkAlignment* _tmp91_;
GtkAlignment* _tmp92_;
GtkBox* _tmp93_;
GtkAlignment* _tmp94_;
ListStack* _tmp95_;
ListStack* _tmp96_;
GtkAlignment* _tmp97_;
ListStack* _tmp98_;
UnityGreeter* _tmp99_;
gboolean _tmp100_;
GError * _inner_error_ = NULL;
parent_class = G_OBJECT_CLASS (main_window_parent_class);
obj = parent_class->constructor (type, n_construct_properties, construct_properties);
self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_MAIN_WINDOW, MainWindow);
_tmp0_ = gtk_widget_get_events ((GtkWidget*) self);
_tmp1_ = _tmp0_;
gtk_widget_set_events ((GtkWidget*) self, _tmp1_ | GDK_POINTER_MOTION_MASK);
_tmp2_ = gtk_accel_group_new ();
accel_group = _tmp2_;
_tmp3_ = accel_group;
gtk_window_add_accel_group ((GtkWindow*) self, _tmp3_);
memset (&bg_color, 0, sizeof (GdkRGBA));
_tmp4_ = ug_settings_get_string (UG_SETTINGS_KEY_BACKGROUND_COLOR);
_tmp5_ = _tmp4_;
gdk_rgba_parse (&bg_color, _tmp5_);
_g_free0 (_tmp5_);
_tmp6_ = bg_color;
gtk_widget_override_background_color ((GtkWidget*) self, GTK_STATE_FLAG_NORMAL, &_tmp6_);
_tmp7_ = gtk_widget_get_accessible ((GtkWidget*) self);
_tmp8_ = _ ("Login Screen");
atk_object_set_name (_tmp7_, _tmp8_);
gtk_window_set_has_resize_grip ((GtkWindow*) self, FALSE);
unity_greeter_add_style_class ((GtkWidget*) self);
gtk_widget_realize ((GtkWidget*) self);
_tmp9_ = gtk_widget_get_window ((GtkWidget*) self);
_tmp10_ = gdk_cairo_create (_tmp9_);
_tmp11_ = _tmp10_;
_tmp12_ = cairo_get_target (_tmp11_);
_tmp13_ = background_new (_tmp12_);
g_object_ref_sink (_tmp13_);
_g_object_unref0 (self->priv->background);
self->priv->background = _tmp13_;
_cairo_destroy0 (_tmp11_);
_tmp14_ = self->priv->background;
_tmp15_ = ug_settings_get_boolean (UG_SETTINGS_KEY_DRAW_GRID);
background_set_draw_grid (_tmp14_, _tmp15_);
_tmp16_ = self->priv->background;
_tmp17_ = ug_settings_get_string (UG_SETTINGS_KEY_BACKGROUND);
_tmp18_ = _tmp17_;
background_set_default_background (_tmp16_, _tmp18_);
_g_free0 (_tmp18_);
_tmp19_ = self->priv->background;
_tmp20_ = ug_settings_get_string (UG_SETTINGS_KEY_LOGO);
_tmp21_ = _tmp20_;
_tmp22_ = ug_settings_get_string (UG_SETTINGS_KEY_BACKGROUND_LOGO);
_tmp23_ = _tmp22_;
background_set_logo (_tmp19_, _tmp21_, _tmp23_);
_g_free0 (_tmp23_);
_g_free0 (_tmp21_);
_tmp24_ = self->priv->background;
gtk_widget_show ((GtkWidget*) _tmp24_);
_tmp25_ = self->priv->background;
gtk_container_add ((GtkContainer*) self, (GtkWidget*) _tmp25_);
_tmp26_ = self->priv->background;
unity_greeter_add_style_class ((GtkWidget*) _tmp26_);
_tmp27_ = (GtkBox*) gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
g_object_ref_sink (_tmp27_);
_g_object_unref0 (self->priv->login_box);
self->priv->login_box = _tmp27_;
_tmp28_ = self->priv->login_box;
gtk_widget_show ((GtkWidget*) _tmp28_);
_tmp29_ = self->priv->background;
_tmp30_ = self->priv->login_box;
gtk_container_add ((GtkContainer*) _tmp29_, (GtkWidget*) _tmp30_);
_tmp31_ = (GtkEventBox*) gtk_event_box_new ();
g_object_ref_sink (_tmp31_);
menubox = _tmp31_;
_tmp32_ = (GtkAlignment*) gtk_alignment_new (0.0f, 0.0f, 1.0f, 0.0f);
g_object_ref_sink (_tmp32_);
menualign = _tmp32_;
_tmp33_ = g_build_filename (PKGDATADIR, "shadow.png", NULL, NULL);
shadow_path = _tmp33_;
_tmp34_ = g_strdup ("");
shadow_style = _tmp34_;
_tmp35_ = shadow_path;
_tmp36_ = g_file_test (_tmp35_, G_FILE_TEST_EXISTS);
if (_tmp36_) {
const gchar* _tmp37_;
gchar* _tmp38_ = NULL;
_tmp37_ = shadow_path;
_tmp38_ = g_strdup_printf ("background-image: url('%s');\n" \
" background-repeat: repeat;", _tmp37_);
_g_free0 (shadow_style);
shadow_style = _tmp38_;
}
{
GtkCssProvider* _tmp39_;
GtkCssProvider* style;
GtkCssProvider* _tmp40_;
const gchar* _tmp41_;
gchar* _tmp42_ = NULL;
gchar* _tmp43_;
GtkEventBox* _tmp44_;
GtkStyleContext* _tmp45_ = NULL;
GtkStyleContext* _tmp46_;
GtkStyleContext* context;
GtkStyleContext* _tmp47_;
GtkCssProvider* _tmp48_;
_tmp39_ = gtk_css_provider_new ();
style = _tmp39_;
_tmp40_ = style;
_tmp41_ = shadow_style;
_tmp42_ = g_strdup_printf ("* {background-color: transparent;\n" \
" %s\n" \
" }", _tmp41_);
_tmp43_ = _tmp42_;
gtk_css_provider_load_from_data (_tmp40_, _tmp43_, (gssize) (-1), &_inner_error_);
_g_free0 (_tmp43_);
if (_inner_error_ != NULL) {
_g_object_unref0 (style);
goto __catch11_g_error;
}
_tmp44_ = menubox;
_tmp45_ = gtk_widget_get_style_context ((GtkWidget*) _tmp44_);
_tmp46_ = _g_object_ref0 (_tmp45_);
context = _tmp46_;
_tmp47_ = context;
_tmp48_ = style;
gtk_style_context_add_provider (_tmp47_, (GtkStyleProvider*) _tmp48_, (guint) GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
_g_object_unref0 (context);
_g_object_unref0 (style);
}
goto __finally11;
__catch11_g_error:
{
GError* e = NULL;
GError* _tmp49_;
const gchar* _tmp50_;
e = _inner_error_;
_inner_error_ = NULL;
_tmp49_ = e;
_tmp50_ = _tmp49_->message;
g_debug ("main-window.vala:87: Internal error loading menubox style: %s", _tmp50_);
_g_error_free0 (e);
}
__finally11:
if (_inner_error_ != NULL) {
_g_free0 (shadow_style);
_g_free0 (shadow_path);
_g_object_unref0 (menualign);
_g_object_unref0 (menubox);
_g_object_unref0 (accel_group);
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
}
_tmp51_ = menubox;
gtk_widget_set_size_request ((GtkWidget*) _tmp51_, -1, MAIN_WINDOW_MENUBAR_HEIGHT);
_tmp52_ = menubox;
gtk_widget_show ((GtkWidget*) _tmp52_);
_tmp53_ = menualign;
gtk_widget_show ((GtkWidget*) _tmp53_);
_tmp54_ = menubox;
_tmp55_ = menualign;
gtk_container_add ((GtkContainer*) _tmp54_, (GtkWidget*) _tmp55_);
_tmp56_ = self->priv->login_box;
_tmp57_ = menubox;
gtk_container_add ((GtkContainer*) _tmp56_, (GtkWidget*) _tmp57_);
_tmp58_ = menualign;
unity_greeter_add_style_class ((GtkWidget*) _tmp58_);
_tmp59_ = menubox;
unity_greeter_add_style_class ((GtkWidget*) _tmp59_);
_tmp60_ = self->priv->background;
_tmp61_ = accel_group;
_tmp62_ = menu_bar_new (_tmp60_, _tmp61_);
g_object_ref_sink (_tmp62_);
_g_object_unref0 (self->menubar);
self->menubar = _tmp62_;
_tmp63_ = self->menubar;
gtk_widget_show ((GtkWidget*) _tmp63_);
_tmp64_ = menualign;
_tmp65_ = self->menubar;
gtk_container_add ((GtkContainer*) _tmp64_, (GtkWidget*) _tmp65_);
_tmp66_ = self->menubar;
unity_greeter_add_style_class ((GtkWidget*) _tmp66_);
_tmp67_ = (GtkBox*) gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
g_object_ref_sink (_tmp67_);
_g_object_unref0 (self->priv->hbox);
self->priv->hbox = _tmp67_;
_tmp68_ = self->priv->hbox;
g_object_set ((GtkWidget*) _tmp68_, "expand", TRUE, NULL);
_tmp69_ = self->priv->hbox;
gtk_widget_show ((GtkWidget*) _tmp69_);
_tmp70_ = self->priv->login_box;
_tmp71_ = self->priv->hbox;
gtk_container_add ((GtkContainer*) _tmp70_, (GtkWidget*) _tmp71_);
_tmp72_ = (GtkAlignment*) gtk_alignment_new (0.5f, 0.5f, 0.0f, 0.0f);
g_object_ref_sink (_tmp72_);
align = _tmp72_;
_tmp73_ = align;
gtk_widget_set_size_request ((GtkWidget*) _tmp73_, grid_size, -1);
_tmp74_ = align;
gtk_widget_set_margin_bottom ((GtkWidget*) _tmp74_, MAIN_WINDOW_MENUBAR_HEIGHT);
_tmp75_ = align;
gtk_widget_show ((GtkWidget*) _tmp75_);
_tmp76_ = self->priv->hbox;
_tmp77_ = align;
gtk_container_add ((GtkContainer*) _tmp76_, (GtkWidget*) _tmp77_);
_tmp78_ = flat_button_new ();
g_object_ref_sink (_tmp78_);
_g_object_unref0 (self->priv->back_button);
self->priv->back_button = (GtkButton*) _tmp78_;
_tmp79_ = self->priv->back_button;
gtk_button_set_focus_on_click (_tmp79_, FALSE);
_tmp80_ = g_build_filename (PKGDATADIR, "arrow_left.png", NULL, NULL);
_tmp81_ = _tmp80_;
_tmp82_ = (GtkImage*) gtk_image_new_from_file (_tmp81_);
g_object_ref_sink (_tmp82_);
_tmp83_ = _tmp82_;
_g_free0 (_tmp81_);
image = _tmp83_;
_tmp84_ = image;
gtk_widget_show ((GtkWidget*) _tmp84_);
_tmp85_ = self->priv->back_button;
gtk_widget_set_size_request ((GtkWidget*) _tmp85_, grid_size - (GREETER_LIST_BORDER * 2), grid_size - (GREETER_LIST_BORDER * 2));
_tmp86_ = self->priv->back_button;
_tmp87_ = image;
gtk_container_add ((GtkContainer*) _tmp86_, (GtkWidget*) _tmp87_);
_tmp88_ = self->priv->back_button;
g_signal_connect_object (_tmp88_, "clicked", (GCallback) _main_window_pop_list_gtk_button_clicked, self, 0);
_tmp89_ = align;
_tmp90_ = self->priv->back_button;
gtk_container_add ((GtkContainer*) _tmp89_, (GtkWidget*) _tmp90_);
_tmp91_ = (GtkAlignment*) gtk_alignment_new (0.0f, 0.5f, 0.0f, 1.0f);
g_object_ref_sink (_tmp91_);
_g_object_unref0 (align);
align = _tmp91_;
_tmp92_ = align;
gtk_widget_show ((GtkWidget*) _tmp92_);
_tmp93_ = self->priv->hbox;
_tmp94_ = align;
gtk_container_add ((GtkContainer*) _tmp93_, (GtkWidget*) _tmp94_);
_tmp95_ = list_stack_new ();
g_object_ref_sink (_tmp95_);
_g_object_unref0 (self->stack);
self->stack = _tmp95_;
_tmp96_ = self->stack;
gtk_widget_show ((GtkWidget*) _tmp96_);
_tmp97_ = align;
_tmp98_ = self->stack;
gtk_container_add ((GtkContainer*) _tmp97_, (GtkWidget*) _tmp98_);
main_window_add_user_list (self);
_tmp99_ = unity_greeter_singleton;
_tmp100_ = _tmp99_->test_mode;
if (_tmp100_) {
Monitor* _tmp101_;
Monitor* _tmp102_;
Background* _tmp103_;
GList* _tmp104_;
GList* _tmp105_;
gconstpointer _tmp106_ = NULL;
__g_list_free__monitor_unref0_0 (self->priv->monitors);
self->priv->monitors = NULL;
_tmp101_ = monitor_new (0, 0, 800, 600);
self->priv->monitors = g_list_append (self->priv->monitors, _tmp101_);
_tmp102_ = monitor_new (800, 120, 640, 480);
self->priv->monitors = g_list_append (self->priv->monitors, _tmp102_);
_tmp103_ = self->priv->background;
_tmp104_ = self->priv->monitors;
background_set_monitors (_tmp103_, _tmp104_);
_tmp105_ = self->priv->monitors;
_tmp106_ = g_list_nth_data (_tmp105_, (guint) 0);
main_window_move_to_monitor (self, (Monitor*) _tmp106_);
gtk_window_resize ((GtkWindow*) self, 800 + 640, 600);
} else {
GdkScreen* _tmp107_ = NULL;
GdkScreen* _tmp108_;
GdkScreen* screen;
GdkScreen* _tmp109_;
GdkScreen* _tmp110_;
_tmp107_ = gtk_window_get_screen ((GtkWindow*) self);
_tmp108_ = _g_object_ref0 (_tmp107_);
screen = _tmp108_;
_tmp109_ = screen;
g_signal_connect_object (_tmp109_, "monitors-changed", (GCallback) _main_window_monitors_changed_cb_gdk_screen_monitors_changed, self, 0);
_tmp110_ = screen;
main_window_monitors_changed_cb (self, _tmp110_);
_g_object_unref0 (screen);
}
_g_object_unref0 (image);
_g_object_unref0 (align);
_g_free0 (shadow_style);
_g_free0 (shadow_path);
_g_object_unref0 (menualign);
_g_object_unref0 (menubox);
_g_object_unref0 (accel_group);
return obj;
}
GtkWidget *
create_editor_window(const char *tag)
{
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *combo;
GtkWidget *separator;
GtkWidget *frame;
GtkWidget *table;
GtkWidget *scale;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
set_window_title(window, tag, "Patch Edit");
g_signal_connect (G_OBJECT(window), "destroy",
G_CALLBACK (gtk_main_quit), NULL);
g_signal_connect (G_OBJECT (window), "delete-event",
G_CALLBACK (on_delete_event_wrapper),
(gpointer)gtk_widget_hide);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 6);
editor_status_label = gtk_label_new (" ");
gtk_container_add (GTK_CONTAINER (vbox), editor_status_label);
gtk_misc_set_alignment (GTK_MISC (editor_status_label), 0, 0.5);
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 0);
label = gtk_label_new ("Patch Name");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
editor_name_entry = gtk_entry_new_with_max_length(10);
gtk_box_pack_start (GTK_BOX (hbox), editor_name_entry, FALSE, FALSE, 2);
g_signal_connect(G_OBJECT(editor_name_entry), "changed",
G_CALLBACK(patch_edit_on_name_entry_changed), NULL);
/* -FIX- comment (reuse Performance Name?)
* GtkWidget *comment_label = gtk_label_new ("Comment");
* gtk_box_pack_start (GTK_BOX (hbox), comment_label, FALSE, FALSE, 2);
* gtk_misc_set_alignment (GTK_MISC (comment_label), 0, 0.5);
* GtkWidget *comment_entry = gtk_entry_new_with_max_length(60);
* gtk_box_pack_start (GTK_BOX (hbox), comment_entry, TRUE, TRUE, 2);
*/
/* separator */
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, FALSE, 2);
gtk_widget_show_all(vbox);
/* editor widgets */
create_widgy_editor(tag);
gtk_box_pack_start (GTK_BOX (vbox), widgy_widget, TRUE, FALSE, 2);
gtk_widget_show(widgy_widget);
create_retro_editor(tag);
gtk_box_pack_start (GTK_BOX (vbox), retro_widget, TRUE, FALSE, 2);
/* separator */
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, FALSE, 2);
gtk_widget_show(separator);
/* edit action widgets */
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 0);
label = gtk_label_new ("Editor Mode");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
combo = gtk_combo_box_new_text();
gtk_combo_box_append_text(GTK_COMBO_BOX(combo), "Widgy");
gtk_combo_box_append_text(GTK_COMBO_BOX(combo), "Retro");
gtk_combo_box_set_active(GTK_COMBO_BOX(combo), 0);
gtk_box_pack_start (GTK_BOX (hbox), combo, FALSE, FALSE, 2);
g_signal_connect(G_OBJECT(combo), "changed",
G_CALLBACK(patch_edit_on_mode_change), NULL);
/* -FIX- add: [compare to original?] [swap A/B?] [close?] */
label = gtk_label_new (NULL);
gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, FALSE, 0);
editor_discard_button = gtk_button_new_with_label ("Discard Changes");
gtk_box_pack_start (GTK_BOX (hbox), editor_discard_button, FALSE, FALSE, 2);
gtk_signal_connect (GTK_OBJECT (editor_discard_button), "clicked",
GTK_SIGNAL_FUNC (on_editor_discard_button_press),
NULL);
editor_save_button = gtk_button_new_with_label ("Save Changes into Patch Bank");
gtk_box_pack_start (GTK_BOX (hbox), editor_save_button, FALSE, FALSE, 2);
gtk_signal_connect (GTK_OBJECT (editor_save_button), "clicked",
GTK_SIGNAL_FUNC (on_editor_save_button_press),
NULL);
gtk_widget_show_all(hbox);
/* test note widgets */
frame = gtk_frame_new ("Test Note");
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
table = gtk_table_new (3, 3, FALSE);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_container_set_border_width (GTK_CONTAINER (table), 2);
gtk_table_set_row_spacings (GTK_TABLE (table), 1);
gtk_table_set_col_spacings (GTK_TABLE (table), 5);
label = gtk_label_new ("key");
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
scale = gtk_hscale_new (GTK_ADJUSTMENT (test_note_key_adj));
gtk_table_attach (GTK_TABLE (table), scale, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_scale_set_value_pos (GTK_SCALE (scale), GTK_POS_RIGHT);
gtk_scale_set_digits (GTK_SCALE (scale), 0);
gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
label = gtk_label_new ("velocity");
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
scale = gtk_hscale_new (GTK_ADJUSTMENT (test_note_velocity_adj));
gtk_table_attach (GTK_TABLE (table), scale, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_scale_set_value_pos (GTK_SCALE (scale), GTK_POS_RIGHT);
gtk_scale_set_digits (GTK_SCALE (scale), 0);
gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
editor_test_note_button = gtk_button_new_with_label (" Send Test Note");
gtk_table_attach (GTK_TABLE (table), editor_test_note_button, 2, 3, 0, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 4, 0);
gtk_button_set_focus_on_click(GTK_BUTTON(editor_test_note_button), FALSE);
g_signal_connect (G_OBJECT (editor_test_note_button), "pressed",
G_CALLBACK (on_test_note_button_press), (gpointer)1);
g_signal_connect (G_OBJECT (editor_test_note_button), "released",
G_CALLBACK (on_test_note_button_press), (gpointer)0);
gtk_widget_show_all (frame);
editor_window = window;
return editor_window;
}
GtkWidget * create_layer_view_widget (void)
{
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *hide_button;
GtkRcStyle *rcstyle; /* For hide_button */
GtkWidget *image; /* For hide_button */
GtkWidget *list;
GtkWidget *separator;
GtkWidget *scrolled_win;
GtkWidget *button_box;
/* if layer_dialog were renamed to layer_view_data this would make
* more sense.
*/
layer_dialog = g_new (struct LayerDialog, 1);
layer_dialog->diagram = NULL;
layer_dialog->dialog = vbox = gtk_vbox_new (FALSE, 1);
hbox = gtk_hbox_new (FALSE, 1);
label = gtk_label_new (_ ("Layers:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
gtk_widget_show (label);
layer_dialog->diagram_omenu = NULL;
/* Hide Button */
hide_button = gtk_button_new ();
gtk_button_set_relief (GTK_BUTTON (hide_button), GTK_RELIEF_NONE);
gtk_button_set_focus_on_click (GTK_BUTTON (hide_button), FALSE);
/* make it as small as possible */
rcstyle = gtk_rc_style_new ();
rcstyle->xthickness = rcstyle->ythickness = 0;
gtk_widget_modify_style (hide_button, rcstyle);
g_object_unref (rcstyle);
image = gtk_image_new_from_stock (GTK_STOCK_CLOSE,
GTK_ICON_SIZE_MENU);
gtk_container_add (GTK_CONTAINER(hide_button), image);
g_signal_connect (G_OBJECT (hide_button), "clicked",
G_CALLBACK (layer_view_hide_button_clicked), NULL);
gtk_box_pack_start (GTK_BOX (hbox), hide_button, FALSE, FALSE, 2);
gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 2);
gtk_widget_show_all (hbox);
button_box = create_button_box(vbox, FALSE);
gtk_box_pack_start (GTK_BOX (vbox), button_box, FALSE, FALSE, 2);
gtk_widget_show (button_box);
separator = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(vbox), separator, FALSE, FALSE, 2);
gtk_widget_show (separator);
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 2);
layer_dialog->layer_list = list = gtk_list_new();
gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_BROWSE);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), list);
gtk_container_set_focus_vadjustment (GTK_CONTAINER (list),
gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_win)));
gtk_widget_show (scrolled_win);
gtk_widget_show (list);
g_signal_connect (G_OBJECT (list), "event",
G_CALLBACK (layer_list_events), NULL);
return vbox;
}
