void
nautilus_navigation_window_activate_spinner (NautilusNavigationWindow *window)
{
GtkToolItem *item;
GtkWidget *spinner;
if (window->details->spinner != NULL) {
return;
}
item = gtk_tool_item_new ();
gtk_widget_show (GTK_WIDGET (item));
gtk_tool_item_set_expand (item, TRUE);
gtk_toolbar_insert (GTK_TOOLBAR (window->details->toolbar),
item, -1);
spinner = gtk_spinner_new ();
gtk_widget_show (GTK_WIDGET (spinner));
item = gtk_tool_item_new ();
gtk_container_add (GTK_CONTAINER (item), spinner);
gtk_widget_show (GTK_WIDGET (item));
gtk_toolbar_insert (GTK_TOOLBAR (window->details->toolbar),
item, -1);
window->details->spinner = spinner;
}
static void
cw_picture_window_init (CWPictureWindow *cw_picture_window)
{
CWPictureWindowPrivate *priv =
CW_PICTURE_WINDOW_GET_PRIVATE(cw_picture_window);
priv->store_item = NULL;
priv->spinner = NULL;
priv->connect_id = 0;
priv->spinner = gtk_spinner_new();
GtkWidget* alignment = gtk_alignment_new(0.5, 0.5, 1, 1);
//gtk_alignment_set_padding(
//GTK_ALIGNMENT(alignment),
//IMAGE_SHADOW_RADIUS,
//IMAGE_SHADOW_RADIUS + IMAGE_SHADOW_OFFSET_X * 2,
//IMAGE_SHADOW_RADIUS,
//IMAGE_SHADOW_RADIUS + IMAGE_SHADOW_OFFSET_Y * 2);
gtk_container_add (GTK_CONTAINER (alignment), priv->spinner);
//gtk_container_add (GTK_CONTAINER (cw_picture_window), alignment);
gtk_widget_add_events(GTK_WIDGET(cw_picture_window),
GDK_POINTER_MOTION_MASK
| GDK_BUTTON_PRESS_MASK);
//| GDK_BUTTON_RELEASE_MASK);
GdkRGBA rgba = { 1, 1, 1, 0.0};
gtk_widget_override_background_color(GTK_WIDGET(cw_picture_window),
GTK_STATE_FLAG_NORMAL, &rgba);
/* TODO: Add initialization code here */
}
static GtkWidget *autoenc_processing_dialog_create(void)
{
GtkWidget *dialog;
GtkWidget *hbox;
GtkWidget *spinner;
GtkWidget *label;
dialog = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width(GTK_CONTAINER(dialog), 16);
gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER);
gtk_window_set_title(GTK_WINDOW(dialog), _("Encrypting attachments"));
gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
gtk_window_set_policy(GTK_WINDOW(dialog), FALSE, FALSE, FALSE);
syl_plugin_manage_window_set_transient(GTK_WINDOW(dialog));
//g_signal_connect(G_OBJECT(dialog), "delete_event", G_CALLBACK(gtk_true), NULL);
hbox = gtk_hbox_new(FALSE, 12);
gtk_container_add(GTK_CONTAINER(dialog), hbox);
gtk_widget_show(hbox);
spinner = gtk_spinner_new();
gtk_widget_set_size_request(spinner, 16, 16);
gtk_box_pack_start(GTK_BOX(hbox), spinner, FALSE, FALSE, 0);
gtk_widget_show(spinner);
label = gtk_label_new(_("Encrypting attachments..."));
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
gtk_widget_show(label);
gtk_widget_show(dialog);
gtk_spinner_start(GTK_SPINNER(spinner));
return dialog;
}
static void
photos_print_notification_init (PhotosPrintNotification *self)
{
PhotosPrintNotificationPrivate *priv;
GtkWidget *image;
self->priv = photos_print_notification_get_instance_private (self);
priv = self->priv;
priv->ntfctn_mngr = g_object_ref_sink (photos_notification_manager_dup_singleton ());
priv->spinner = gtk_spinner_new ();
gtk_widget_set_size_request (priv->spinner, 16, 16);
gtk_container_add (GTK_CONTAINER (self), priv->spinner);
priv->status_label = gtk_label_new (NULL);
gtk_widget_set_halign (priv->status_label, GTK_ALIGN_START);
gtk_container_add (GTK_CONTAINER (self), priv->status_label);
image = gtk_image_new_from_icon_name (PHOTOS_ICON_PROCESS_STOP_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);
priv->stop_button = gtk_button_new ();
gtk_widget_set_valign (priv->stop_button, GTK_ALIGN_CENTER);
gtk_button_set_image (GTK_BUTTON (priv->stop_button), image);
gtk_container_add (GTK_CONTAINER (self), priv->stop_button);
g_signal_connect_swapped (priv->stop_button,
"clicked",
G_CALLBACK (photos_print_notification_stop_clicked),
self);
}
static void
nautilus_floating_bar_constructed (GObject *obj)
{
NautilusFloatingBar *self = NAUTILUS_FLOATING_BAR (obj);
GtkWidget *w, *box;
G_OBJECT_CLASS (nautilus_floating_bar_parent_class)->constructed (obj);
box = GTK_WIDGET (obj);
w = gtk_spinner_new ();
gtk_box_pack_start (GTK_BOX (box), w, FALSE, FALSE, 0);
gtk_widget_set_visible (w, self->priv->show_spinner);
self->priv->spinner = w;
gtk_widget_set_size_request (w, 16, 16);
gtk_widget_set_margin_start (w, 8);
w = gtk_label_new (NULL);
gtk_label_set_ellipsize (GTK_LABEL (w), PANGO_ELLIPSIZE_MIDDLE);
gtk_box_pack_start (GTK_BOX (box), w, FALSE, FALSE, 0);
g_object_set (w,
"margin-top", 2,
"margin-bottom", 2,
"margin-left", 12,
"margin-right", 12,
"max-width-chars", 60,
NULL);
self->priv->label_widget = w;
gtk_widget_show (w);
}
gint cui_load_left_menu(GtkBuilder *builder, GtkStatusIcon *trayicon)
{
GError *error = NULL;
gtk_builder_add_from_file(builder, CUI_LEFT_MENU_UI_PATH, &error);
if (error != NULL) {
printf("Error: %s\n", error->message);
g_error_free(error);
return -EINVAL;
}
cui_left_menu = (GtkMenu *) gtk_builder_get_object(builder,
"cui_left_menu");
cui_more_menu = (GtkMenu *) gtk_builder_get_object(builder,
"cui_more_menu");
cui_list_more_item = (GtkMenuItem *) gtk_builder_get_object(builder,
"cui_list_more_item");
cui_scan_spinner = (GtkMenuItem *) gtk_builder_get_object(builder,
"cui_scan_spinner");
gtk_container_add(GTK_CONTAINER(cui_scan_spinner), gtk_spinner_new());
g_signal_connect(cui_left_menu, "deactivate",
G_CALLBACK(cui_popdown_left_menu), NULL);
service_items = g_hash_table_new_full(g_str_hash, g_str_equal,
NULL, delete_service_item);
cui_tray_hook_left_menu(cui_popup_left_menu);
return 0;
}
static void
device_busy_cb (NmaBtDevice *device, GParamSpec *pspec, WidgetInfo *info)
{
gboolean busy = nma_bt_device_get_busy (device);
if (info->pan_button)
gtk_widget_set_sensitive (info->pan_button, !busy);
if (info->dun_button)
set_dun_button_sensitive (info, !busy);
if (busy) {
if (!info->spinner) {
info->spinner = gtk_spinner_new ();
gtk_box_pack_start (GTK_BOX (info->hbox), info->spinner, FALSE, FALSE, 6);
}
gtk_spinner_start (GTK_SPINNER (info->spinner));
gtk_widget_show (info->spinner);
} else {
if (info->spinner) {
gtk_spinner_stop (GTK_SPINNER (info->spinner));
gtk_widget_destroy (info->spinner);
info->spinner = NULL;
}
}
}
static void
on_import_button_clicked (GtkButton *import_button, gpointer user_data)
{
SeahorseKeyserverResultsRow *row = user_data;
g_autoptr(GtkWidget) spinner = NULL;
g_autoptr(GList) keys = NULL;
g_autoptr(GCancellable) cancellable = NULL;
SeahorsePgpBackend *backend;
SeahorseGpgmeKeyring *keyring;
/* Let the button show a spinner while importing */
gtk_widget_set_sensitive (GTK_WIDGET (import_button), FALSE);
spinner = gtk_spinner_new ();
gtk_spinner_start (GTK_SPINNER (spinner));
gtk_button_set_image (import_button, g_steal_pointer (&spinner));
/* Now import the key */
keys = g_list_append (keys, row->key);
cancellable = g_cancellable_new ();
backend = seahorse_pgp_backend_get ();
keyring = seahorse_pgp_backend_get_default_keyring (backend);
seahorse_pgp_backend_transfer_async (backend, keys,
SEAHORSE_PLACE (keyring),
cancellable, on_import_complete,
g_object_ref (row));
}
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
cheese_widget_init (CheeseWidget *widget)
{
CheeseWidgetPrivate *priv = CHEESE_WIDGET_GET_PRIVATE (widget);
GtkWidget *box;
ClutterActor *stage, *frame;
ClutterConstraint *constraint;
ClutterColor black = { 0x00, 0x00, 0x00, 0xff };
priv->state = CHEESE_WIDGET_STATE_NONE;
priv->error = NULL;
/* XXX
* remove this line if you want to debug */
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (widget), FALSE);
gtk_notebook_set_show_border (GTK_NOTEBOOK (widget), FALSE);
/* Spinner page */
priv->spinner = gtk_spinner_new ();
box = gtk_event_box_new ();
gtk_container_add (GTK_CONTAINER (box), priv->spinner);
cheese_widget_spinner_invert (priv->spinner, box);
gtk_widget_show_all (box);
gtk_notebook_append_page (GTK_NOTEBOOK (widget),
box, gtk_label_new ("spinner"));
/* Webcam page */
priv->screen = gtk_clutter_embed_new ();
stage = gtk_clutter_embed_get_stage (GTK_CLUTTER_EMBED (priv->screen));
clutter_stage_set_color (CLUTTER_STAGE (stage), &black);
frame = cheese_aspect_frame_new ();
priv->texture = clutter_texture_new ();
clutter_actor_set_size (priv->texture, 400, 300);
mx_bin_set_child (MX_BIN (frame), priv->texture);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), frame);
constraint = clutter_bind_constraint_new (stage, CLUTTER_BIND_SIZE, 0.0);
clutter_actor_add_constraint_with_name (frame, "size", constraint);
gtk_widget_show (priv->screen);
clutter_actor_show (priv->texture);
gtk_notebook_append_page (GTK_NOTEBOOK (widget),
priv->screen, gtk_label_new ("webcam"));
/* Problem page */
priv->problem = gtk_drawing_area_new ();
gtk_widget_show (priv->problem);
gtk_notebook_append_page (GTK_NOTEBOOK (widget),
priv->problem,
gtk_label_new ("got problems"));
priv->settings = g_settings_new ("org.gnome.Cheese");
}
static void linphone_gtk_in_call_set_animation_spinner(GtkWidget *callview) {
#if GTK_CHECK_VERSION(2,20,0)
GtkWidget *container=linphone_gtk_get_widget(callview,"in_call_animation");
GList *elem=gtk_container_get_children(GTK_CONTAINER(container));
GtkWidget *spinner=gtk_spinner_new();
if (elem)
gtk_widget_destroy((GtkWidget*)elem->data);
gtk_widget_show(spinner);
gtk_container_add(GTK_CONTAINER(container),spinner);
gtk_widget_set_size_request(spinner, 20,20);
gtk_spinner_start(GTK_SPINNER(spinner));
#endif
}
static GtkWidget *
make_delayed_switch (gboolean is_on,
gboolean is_sensitive)
{
GtkWidget *hbox;
GtkWidget *sw, *label, *spinner, *check;
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
sw = gtk_switch_new ();
gtk_switch_set_active (GTK_SWITCH (sw), is_on);
gtk_box_pack_start (GTK_BOX (hbox), sw, FALSE, FALSE, 0);
gtk_widget_set_sensitive (sw, is_sensitive);
gtk_widget_show (sw);
g_signal_connect (sw, "state-set", G_CALLBACK (set_state), NULL);
spinner = gtk_spinner_new ();
gtk_box_pack_start (GTK_BOX (hbox), spinner, FALSE, TRUE, 0);
gtk_widget_set_opacity (spinner, 0.0);
gtk_widget_show (spinner);
check = gtk_check_button_new ();
gtk_box_pack_end (GTK_BOX (hbox), check, FALSE, TRUE, 0);
gtk_widget_show (check);
g_object_bind_property (sw, "state",
check, "active",
G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
label = gtk_label_new (is_on ? "Enabled" : "Disabled");
gtk_box_pack_end (GTK_BOX (hbox), label, TRUE, TRUE, 0);
gtk_widget_show (label);
g_object_bind_property_full (sw, "active",
label, "label",
G_BINDING_DEFAULT,
boolean_to_text,
NULL,
NULL, NULL);
g_signal_connect (sw, "notify", G_CALLBACK (sw_delay_notify), spinner);
return hbox;
}
static void
nautilus_floating_bar_constructed (GObject *obj)
{
NautilusFloatingBar *self = NAUTILUS_FLOATING_BAR (obj);
GtkWidget *w, *box, *labels_box;
G_OBJECT_CLASS (nautilus_floating_bar_parent_class)->constructed (obj);
box = GTK_WIDGET (obj);
w = gtk_spinner_new ();
gtk_box_pack_start (GTK_BOX (box), w, FALSE, FALSE, 0);
gtk_widget_set_visible (w, self->show_spinner);
gtk_spinner_start (GTK_SPINNER (w));
self->spinner = w;
gtk_widget_set_size_request (w, 16, 16);
gtk_widget_set_margin_start (w, 8);
labels_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (box), labels_box, TRUE, TRUE, 0);
g_object_set (labels_box,
"margin-top", 2,
"margin-bottom", 2,
"margin-start", 12,
"margin-end", 12,
NULL);
gtk_widget_show (labels_box);
w = gtk_label_new (NULL);
gtk_label_set_ellipsize (GTK_LABEL (w), PANGO_ELLIPSIZE_MIDDLE);
gtk_label_set_single_line_mode (GTK_LABEL (w), TRUE);
gtk_container_add (GTK_CONTAINER (labels_box), w);
self->primary_label_widget = w;
gtk_widget_show (w);
w = gtk_label_new (NULL);
gtk_label_set_single_line_mode (GTK_LABEL (w), TRUE);
gtk_container_add (GTK_CONTAINER (labels_box), w);
self->details_label_widget = w;
gtk_widget_show (w);
}
int main (int argc, char *argv[])
{
/* GUI widgets */
GtkWidget *window;
GtkWidget *align;
GtkWidget *expander;
GtkWidget *label;
GtkWidget *radio1, *radio2;
GtkWidget *check;
GtkWidget *button;
GtkWidget *entry;
GtkTooltips *tooltip;
/* Packing boxes */
GtkWidget *vbMain; /* main vertical box */
GtkWidget *hbox1, *vbox1, *vbox2; /* username/password */
GtkWidget *hbox2, *vbox3, *hbMac; /* login options */
GtkWidget *hbox3; /* cancel/login buttons */
GtkWidget *hbox9; /* show pwd & gtl */
/* Initialize multihreading and gtk functions */
g_thread_init (NULL);
gdk_threads_init ();
gdk_threads_enter ();
gtk_init (&argc, &argv);
/* Create main window */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW(window), "Glawn");
gtk_window_set_resizable (GTK_WINDOW(window), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
g_signal_connect (window, "destroy", G_CALLBACK(quit_glawn), NULL);
GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file ("./icons/glawn-icon.png", NULL);
gtk_window_set_icon (GTK_WINDOW(window), pixbuf);
/* Create pack boxes */
vbMain= gtk_vbox_new (FALSE, 3);
vbox1 = gtk_vbox_new (FALSE, 0);
vbox2 = gtk_vbox_new (FALSE, 3);
vbox3 = gtk_vbox_new (FALSE, 0);
hbox1 = gtk_hbox_new (FALSE, 0);
hbox2 = gtk_hbox_new (FALSE, 0);
hbox3 = gtk_hbox_new (FALSE, 0);
hbMac = gtk_hbox_new (FALSE, 0);
hbox9 = gtk_hbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), vbMain);
/* Username entry label */
label = gtk_label_new ("GT Account : ");
gtk_misc_set_alignment ((GtkMisc *)label, 0, 0);
gtk_box_pack_start (GTK_BOX(vbox1), label, TRUE, FALSE, 0);
/* Password entry label */
label = gtk_label_new ("Password : "******"");
gtk_box_pack_start (GTK_BOX(vbox1),label,FALSE, FALSE, 2);
/* Username entry field */
data.nameEntry = entry = gtk_entry_new_with_max_length (50);
gtk_entry_set_width_chars (GTK_ENTRY(entry), 25);
g_signal_connect (entry, "activate", G_CALLBACK(login), NULL);
gtk_box_pack_start (GTK_BOX(vbox2), entry, FALSE, FALSE, 0);
/* Password entry field */
data.pwdEntry = entry = gtk_entry_new_with_max_length(50);
gtk_entry_set_visibility (GTK_ENTRY(entry), FALSE);
g_signal_connect (entry, "activate", G_CALLBACK(login), NULL);
gtk_box_pack_start (GTK_BOX(vbox2), entry, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(hbox1), vbox2, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX(vbMain), hbox1, FALSE, FALSE, 0);
/* Show password checkbox */
data.pwdCBox = check = gtk_check_button_new_with_mnemonic ("_Show password");
g_signal_connect (check, "toggled", G_CALLBACK(show_pass), GTK_ENTRY(entry));
gtk_box_pack_start (GTK_BOX(hbox9), check, FALSE, FALSE, 0);
/* Location checkbox */
data.locCBox = check = gtk_check_button_new_with_mnemonic ("_GTL");
tooltip = gtk_tooltips_new ();
gtk_tooltips_set_tip (tooltip, check, "Enable Georgia Tech-Lorraine support", NULL);
gtk_box_pack_start (GTK_BOX(hbox9), check, FALSE, FALSE, 9);
gtk_box_pack_start (GTK_BOX(vbox2), hbox9, FALSE, FALSE, 0);
/* Options expander */
expander = gtk_expander_new_with_mnemonic ("_Options");
gtk_box_pack_start (GTK_BOX(vbMain), expander, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER(expander), hbox2);
/* Left indent alignment for expander */
align = gtk_alignment_new (0, 0, 1 , 1);
gtk_widget_set_size_request (align, 17, 0);
gtk_box_pack_start (GTK_BOX(hbox2), align, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(hbox2), vbox3, FALSE, FALSE, 0);
/* ISS checkbox */
data.issCBox = check = gtk_check_button_new_with_mnemonic
("_Enable Inbound Service Security");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(check), TRUE);
gtk_box_pack_start (GTK_BOX(vbox3), check, FALSE, FALSE, 0);
tooltip = gtk_tooltips_new ();
gtk_tooltips_set_tip (tooltip, check, "When turned on,"
" devices outside of the LAWN network are blocked from "
"connecting to services running on your device.", NULL);
/* Login this device radio */
data.radio_this = radio1 = gtk_radio_button_new_with_mnemonic_from_widget
(NULL, "Lo_gin this device");
g_signal_connect (radio1, "toggled", G_CALLBACK(mac_switch), (gpointer) FALSE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(radio1), TRUE);
gtk_box_pack_start (GTK_BOX(vbox3), radio1, FALSE, FALSE, 0);
/* Login other device radio */
data.radio_other = radio2 = gtk_radio_button_new_with_mnemonic_from_widget
(GTK_RADIO_BUTTON(radio1), "Login a _different device");
g_signal_connect (radio2, "toggled", G_CALLBACK(mac_switch), (gpointer) TRUE);
gtk_box_pack_start (GTK_BOX(vbox3), radio2, FALSE, FALSE, 0);
gtk_tooltips_set_tip (tooltip, radio2, "You can authenticate other"
" devices currently on LAWN. The login will last as long as the"
" device maintains a valid DHCP lease. You accept responsibility"
" for all usage associated with this device.", NULL);
/* MAC address label and entry */
label = gtk_label_new (" MAC Address : "); // more elegance
data.macEntry = entry = gtk_entry_new_with_max_length (12);
gtk_entry_set_width_chars (GTK_ENTRY(entry), 18);
gtk_widget_set_sensitive (entry, FALSE);
gtk_box_pack_start (GTK_BOX(hbMac), label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(hbMac), entry, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(vbox3), hbMac, FALSE, FALSE, 0);
/* Login button */
data.login = button = gtk_button_new_with_mnemonic (" _Login ");
gtk_widget_set_sensitive (button, FALSE);
g_signal_connect (button, "clicked", G_CALLBACK(login), NULL);
gtk_box_pack_end (GTK_BOX(hbox3), button, FALSE, FALSE, 5);
/* Logout button */
data.logout = button = gtk_button_new_with_mnemonic ("Logou_t");
gtk_widget_set_sensitive (button, FALSE);
g_signal_connect (button, "clicked", G_CALLBACK(logout), NULL);
gtk_box_pack_end (GTK_BOX(hbox3), button, FALSE, FALSE, 0);
/* Spinner */
data.spinner = gtk_spinner_new ();
gtk_box_pack_start (GTK_BOX(hbox3), data.spinner, FALSE, FALSE, 2);
/* Statusbar */
data.status = label = gtk_label_new ("");
gtk_box_pack_start (GTK_BOX(hbox3), label, FALSE, FALSE, 2);
gtk_box_pack_start (GTK_BOX(vbMain), hbox3, FALSE, FALSE, 0);
/* Display window */
gtk_widget_show_all (window);
/* Ascii art */
g_printf ("\n===========================\n"
" Welcome to Glawn!\n"
"===========================\n\n");
/*Load_settings */
init_mutex();
load_settings();
update_gui (LOAD_INI_START);
// send curl request for status
update_gui (CHECK_STAT_START);
g_thread_create((GThreadFunc)check_status, NULL, FALSE, NULL);
g_timeout_add_seconds_full(G_PRIORITY_LOW, 1, init_check_status, NULL, NULL);
/* Start main loop */
gtk_main ();
gdk_threads_leave ();
return 0;
}
static VALUE
rg_initialize(VALUE self)
{
RBGTK_INITIALIZE(self, gtk_spinner_new());
return Qnil;
}
static void
backgrounds_changed_cb (GtkIconView *icon_view,
CcBackgroundPanel *panel)
{
GtkTreeIter iter;
GtkTreeModel *model;
CcBackgroundItem *item;
CcBackgroundPanelPrivate *priv = panel->priv;
char *pcolor, *scolor;
gboolean draw_preview = TRUE;
const char *uri;
CcBackgroundItemFlags flags;
char *filename;
item = get_selected_item (panel);
if (item == NULL)
return;
/* Update current source */
model = gtk_combo_box_get_model (GTK_COMBO_BOX (WID ("sources-combobox")));
gtk_combo_box_get_active_iter (GTK_COMBO_BOX (WID ("sources-combobox")),
&iter);
gtk_tree_model_get (model, &iter,
COL_SOURCE_TYPE, &priv->current_source, -1);
uri = cc_background_item_get_uri (item);
flags = cc_background_item_get_flags (item);
if ((flags & CC_BACKGROUND_ITEM_HAS_URI) && uri == NULL)
{
g_settings_set_enum (priv->settings, WP_OPTIONS_KEY, G_DESKTOP_BACKGROUND_STYLE_NONE);
g_settings_set_string (priv->settings, WP_URI_KEY, "");
}
else if (cc_background_item_get_source_url (item) != NULL &&
cc_background_item_get_needs_download (item))
{
GFile *source, *dest;
gchar *cache_path, *basename, *dest_path, *display_name, *dest_uri;
GdkPixbuf *pixbuf;
cache_path = bg_pictures_source_get_cache_path ();
if (g_mkdir_with_parents (cache_path, 0755) < 0)
{
g_warning ("Failed to create directory '%s'", cache_path);
g_free (cache_path);
return;
}
g_free (cache_path);
dest_path = bg_pictures_source_get_unique_path (cc_background_item_get_source_url (item));
dest = g_file_new_for_path (dest_path);
g_free (dest_path);
source = g_file_new_for_uri (cc_background_item_get_source_url (item));
basename = g_file_get_basename (source);
display_name = g_filename_display_name (basename);
dest_path = g_file_get_path (dest);
g_free (basename);
/* create a blank image to use until the source image is ready */
pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, 1, 1);
gdk_pixbuf_fill (pixbuf, 0x00000000);
gdk_pixbuf_save (pixbuf, dest_path, "png", NULL, NULL);
g_object_unref (pixbuf);
g_free (dest_path);
if (priv->copy_cancellable)
{
g_cancellable_cancel (priv->copy_cancellable);
g_cancellable_reset (priv->copy_cancellable);
}
if (priv->spinner)
{
gtk_widget_destroy (GTK_WIDGET (priv->spinner));
priv->spinner = NULL;
}
/* create a spinner while the file downloads */
priv->spinner = gtk_spinner_new ();
gtk_spinner_start (GTK_SPINNER (priv->spinner));
gtk_box_pack_start (GTK_BOX (WID ("bottom-hbox")), priv->spinner, FALSE,
FALSE, 6);
gtk_widget_show (priv->spinner);
/* reference the panel in case it is removed before the copy is
* finished */
g_object_ref (panel);
g_object_set_data_full (G_OBJECT (source), "item", g_object_ref (item), g_object_unref);
g_file_copy_async (source, dest, G_FILE_COPY_OVERWRITE,
G_PRIORITY_DEFAULT, priv->copy_cancellable,
NULL, NULL,
copy_finished_cb, panel);
g_object_unref (source);
dest_uri = g_file_get_uri (dest);
g_object_unref (dest);
g_settings_set_string (priv->settings, WP_URI_KEY, dest_uri);
g_object_set (G_OBJECT (item),
"uri", dest_uri,
"needs-download", FALSE,
"name", display_name,
NULL);
g_free (display_name);
g_free (dest_uri);
/* delay the updated drawing of the preview until the copy finishes */
draw_preview = FALSE;
}
else
{
g_settings_set_string (priv->settings, WP_URI_KEY, uri);
}
/* Also set the placement if we have a URI and the previous value was none */
if (flags & CC_BACKGROUND_ITEM_HAS_PLACEMENT)
{
g_settings_set_enum (priv->settings, WP_OPTIONS_KEY, cc_background_item_get_placement (item));
}
else if (uri != NULL)
{
GDesktopBackgroundStyle style;
style = g_settings_get_enum (priv->settings, WP_OPTIONS_KEY);
if (style == G_DESKTOP_BACKGROUND_STYLE_NONE)
g_settings_set_enum (priv->settings, WP_OPTIONS_KEY, cc_background_item_get_placement (item));
}
if (flags & CC_BACKGROUND_ITEM_HAS_SHADING)
g_settings_set_enum (priv->settings, WP_SHADING_KEY, cc_background_item_get_shading (item));
/* When changing to a background with colours set,
* don't overwrite what's in GSettings, but read
* from it instead.
* We have a hack for the colors source though */
if (flags & CC_BACKGROUND_ITEM_HAS_PCOLOR &&
priv->current_source != SOURCE_COLORS)
{
g_settings_set_string (priv->settings, WP_PCOLOR_KEY, cc_background_item_get_pcolor (item));
}
else
{
pcolor = g_settings_get_string (priv->settings, WP_PCOLOR_KEY);
g_object_set (G_OBJECT (item), "primary-color", pcolor, NULL);
}
if (flags & CC_BACKGROUND_ITEM_HAS_SCOLOR &&
priv->current_source != SOURCE_COLORS)
{
g_settings_set_string (priv->settings, WP_SCOLOR_KEY, cc_background_item_get_scolor (item));
}
else
{
scolor = g_settings_get_string (priv->settings, WP_SCOLOR_KEY);
g_object_set (G_OBJECT (item), "secondary-color", scolor, NULL);
}
/* Apply all changes */
g_settings_apply (priv->settings);
update_remove_button (panel, item);
/* update the preview information */
if (draw_preview != FALSE)
{
update_preview (priv, item);
/* Save the source XML if there is one */
filename = get_save_path ();
if (create_save_dir ())
cc_background_xml_save (priv->current_background, filename);
}
}
static GtkWidget *
build_tab_label (CajaNotebook *nb, CajaWindowSlot *slot)
{
CajaDragSlotProxyInfo *drag_info;
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_hbox_new (FALSE, 4);
gtk_widget_show (hbox);
/* setup load feedback */
spinner = 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);
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_label_set_yalign (GTK_LABEL (label), 0.5);
#else
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
#endif
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_widget_set_margin_start (label, 0);
gtk_widget_set_margin_end (label, 0);
gtk_widget_set_margin_top (label, 0);
gtk_widget_set_margin_bottom (label, 0);
#else
gtk_misc_set_padding (GTK_MISC (label), 0, 0);
#endif
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 */
#if GTK_CHECK_VERSION(3,20,0)
gtk_widget_set_focus_on_click (close_button, FALSE);
#else
gtk_button_set_focus_on_click (GTK_BUTTON (close_button), FALSE);
#endif
gtk_widget_set_name (close_button, "caja-tab-close-button");
image = gtk_image_new_from_icon_name ("window-close", 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);
/* Set minimal size */
g_signal_connect (hbox, "style-set",
G_CALLBACK (tab_label_style_set_cb), NULL);
drag_info = g_new0 (CajaDragSlotProxyInfo, 1);
drag_info->target_slot = slot;
g_object_set_data_full (G_OBJECT (hbox), "proxy-drag-info",
drag_info, (GDestroyNotify) g_free);
caja_drag_slot_proxy_init (hbox, drag_info);
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
add_access_point (GisNetworkPage *page, NMAccessPoint *ap, NMAccessPoint *active)
{
GisNetworkPagePrivate *priv = gis_network_page_get_instance_private (page);
const GByteArray *ssid;
gchar *ssid_text;
const gchar *object_path;
gboolean activated, activating;
guint security;
guint strength;
const gchar *icon_name;
GtkWidget *row;
GtkWidget *widget;
GtkWidget *box;
ssid = nm_access_point_get_ssid (ap);
object_path = nm_object_get_path (NM_OBJECT (ap));
if (ssid == NULL)
return;
ssid_text = nm_utils_ssid_to_utf8 (ssid);
if (active &&
nm_utils_same_ssid (ssid, nm_access_point_get_ssid (active), TRUE)) {
switch (nm_device_get_state (priv->nm_device))
{
case NM_DEVICE_STATE_PREPARE:
case NM_DEVICE_STATE_CONFIG:
case NM_DEVICE_STATE_NEED_AUTH:
case NM_DEVICE_STATE_IP_CONFIG:
case NM_DEVICE_STATE_SECONDARIES:
activated = FALSE;
activating = TRUE;
break;
case NM_DEVICE_STATE_ACTIVATED:
activated = TRUE;
activating = FALSE;
break;
default:
activated = FALSE;
activating = FALSE;
break;
}
} else {
activated = FALSE;
activating = FALSE;
}
security = get_access_point_security (ap);
strength = nm_access_point_get_strength (ap);
row = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_widget_set_margin_start (row, 12);
gtk_widget_set_margin_end (row, 12);
widget = gtk_label_new (ssid_text);
gtk_widget_set_margin_top (widget, 12);
gtk_widget_set_margin_bottom (widget, 12);
gtk_box_pack_start (GTK_BOX (row), widget, FALSE, FALSE, 0);
if (activated) {
widget = gtk_image_new_from_icon_name ("object-select-symbolic", GTK_ICON_SIZE_MENU);
gtk_widget_set_halign (widget, GTK_ALIGN_CENTER);
gtk_widget_set_valign (widget, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (row), widget, FALSE, FALSE, 0);
}
widget = gtk_spinner_new ();
gtk_widget_set_no_show_all (widget, TRUE);
if (activating) {
gtk_widget_show (widget);
gtk_spinner_start (GTK_SPINNER (widget));
}
gtk_widget_set_halign (widget, GTK_ALIGN_CENTER);
gtk_widget_set_valign (widget, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (row), widget, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (row), gtk_label_new (""), TRUE, FALSE, 0);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_set_homogeneous (GTK_BOX (box), TRUE);
gtk_size_group_add_widget (priv->icons, box);
gtk_box_pack_start (GTK_BOX (row), box, FALSE, FALSE, 0);
if (security != NM_AP_SEC_UNKNOWN &&
security != NM_AP_SEC_NONE) {
widget = gtk_image_new_from_icon_name ("network-wireless-encrypted-symbolic", GTK_ICON_SIZE_MENU);
} else {
widget = gtk_label_new ("");
}
gtk_box_pack_start (GTK_BOX (box), widget, FALSE, FALSE, 0);
if (strength < 20)
icon_name = "network-wireless-signal-none-symbolic";
else if (strength < 40)
icon_name = "network-wireless-signal-weak-symbolic";
else if (strength < 50)
icon_name = "network-wireless-signal-ok-symbolic";
else if (strength < 80)
icon_name = "network-wireless-signal-good-symbolic";
else
icon_name = "network-wireless-signal-excellent-symbolic";
widget = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_MENU);
gtk_box_pack_start (GTK_BOX (box), widget, FALSE, FALSE, 0);
gtk_widget_show_all (row);
g_object_set_data (G_OBJECT (row), "object-path", (gpointer) object_path);
g_object_set_data (G_OBJECT (row), "ssid", (gpointer) ssid);
g_object_set_data (G_OBJECT (row), "strength", GUINT_TO_POINTER (strength));
gtk_container_add (GTK_CONTAINER (priv->network_list), row);
}
static void
build_ui (EmerillonWindow *self)
{
GtkAction *action;
GtkWidget *vbox;
GtkWidget *menubar;
GtkToolItem *throbber;
GtkWidget *viewport;
GtkWidget *hpaned;
GtkWidget *embed_view;
ClutterActor *scale;
GError *error = NULL;
/* Action entries. */
self->priv->main_actions = gtk_action_group_new ("MenuActionsWindow");
gtk_action_group_set_translation_domain (self->priv->main_actions,
GETTEXT_PACKAGE);
gtk_action_group_add_actions (self->priv->main_actions, action_entries,
G_N_ELEMENTS (action_entries), self);
/* Toggle entries. */
gtk_action_group_add_toggle_actions (self->priv->main_actions,
toggle_entries, G_N_ELEMENTS (toggle_entries), self);
/* Radio entries. */
gtk_action_group_add_radio_actions (self->priv->main_actions,
radio_entries, G_N_ELEMENTS (radio_entries), 0,
G_CALLBACK (cmd_map_change_map), self);
/* Short labels. */
action = gtk_action_group_get_action (self->priv->main_actions,
"ViewZoomIn");
g_object_set (action, "short_label", _("In"), NULL);
action = gtk_action_group_get_action (self->priv->main_actions,
"ViewZoomOut");
g_object_set (action, "short_label", _("Out"), NULL);
/* UI manager. */
self->priv->ui_manager = gtk_ui_manager_new ();
gtk_ui_manager_insert_action_group (self->priv->ui_manager,
self->priv->main_actions, 0);
if (!gtk_ui_manager_add_ui_from_file (self->priv->ui_manager,
EMERILLON_DATADIR "/emerillon-ui.xml", &error))
{
g_warning ("building menus failed: %s", error->message);
g_error_free (error);
return;
}
g_signal_connect (self->priv->ui_manager, "connect_proxy",
G_CALLBACK (connect_proxy_cb), self);
g_signal_connect (self->priv->ui_manager, "disconnect_proxy",
G_CALLBACK (disconnect_proxy_cb), self);
gtk_window_add_accel_group (GTK_WINDOW (self),
gtk_ui_manager_get_accel_group (self->priv->ui_manager));
/* Main box. */
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (self), vbox);
gtk_widget_show (vbox);
/* Menu. */
menubar = gtk_ui_manager_get_widget (self->priv->ui_manager, "/MainMenu");
g_assert (GTK_IS_WIDGET (menubar));
gtk_box_pack_start (GTK_BOX (vbox), menubar, FALSE, FALSE, 0);
gtk_widget_show (menubar);
/* Toolbar. */
self->priv->toolbar = gtk_ui_manager_get_widget (self->priv->ui_manager,
"/Toolbar");
gtk_style_context_add_class (gtk_widget_get_style_context (self->priv->toolbar),
"primary-toolbar");
self->priv->throbber = gtk_spinner_new ();
throbber = gtk_tool_item_new ();
gtk_container_add (GTK_CONTAINER (throbber), self->priv->throbber);
gtk_widget_show (GTK_WIDGET (self->priv->throbber));
gtk_widget_show (GTK_WIDGET (throbber));
gtk_toolbar_insert (GTK_TOOLBAR (self->priv->toolbar), throbber,
-1);
gtk_box_pack_start (GTK_BOX (vbox), self->priv->toolbar,
FALSE, FALSE, 0);
gtk_widget_show (self->priv->toolbar);
/* Statusbar. */
self->priv->statusbar = gtk_statusbar_new ();
gtk_box_pack_end (GTK_BOX (vbox),
GTK_WIDGET (self->priv->statusbar), FALSE, FALSE, 0);
gtk_widget_show (self->priv->statusbar);
self->priv->tooltip_message_context_id = gtk_statusbar_get_context_id (
GTK_STATUSBAR (self->priv->statusbar), "tooltip-message");
/* Viewport. */
viewport = gtk_frame_new (NULL);
/* Map. */
embed_view = gtk_champlain_embed_new ();
gtk_container_add (GTK_CONTAINER (viewport), embed_view);
/* FIXME: workaround for a champlain-gtk bug, replace with _show(). */
gtk_widget_show_all (embed_view);
self->priv->view = gtk_champlain_embed_get_view (GTK_CHAMPLAIN_EMBED (embed_view));
g_signal_connect (self->priv->view, "notify::zoom-level",
G_CALLBACK (zoom_changed_cb), self);
g_signal_connect (self->priv->view, "notify::map-source",
G_CALLBACK (zoom_changed_cb), self);
g_signal_connect (self->priv->view, "notify::state",
G_CALLBACK (state_changed_cb), self);
g_object_set (self->priv->view, "zoom-level", 1,
"kinetic-mode", TRUE,
NULL);
champlain_view_center_on (self->priv->view, 40, 0);
scale = champlain_scale_new ();
champlain_scale_connect_view (CHAMPLAIN_SCALE (scale), self->priv->view);
/* align to the bottom left */
champlain_view_bin_layout_add (self->priv->view, scale,
CLUTTER_BIN_ALIGNMENT_START, CLUTTER_BIN_ALIGNMENT_END);
/* Sidebar. */
self->priv->sidebar = emerillon_sidebar_new ();
gtk_widget_set_size_request (self->priv->sidebar, 200, -1);
/* Horizontal pane. */
hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_paned_pack1 (GTK_PANED (hpaned), self->priv->sidebar, FALSE, FALSE);
gtk_paned_pack2 (GTK_PANED (hpaned), viewport, TRUE, FALSE);
gtk_widget_show (self->priv->sidebar);
gtk_widget_show (viewport);
g_signal_connect_after (self->priv->sidebar, "show",
G_CALLBACK (sidebar_visibility_changed_cb), self);
g_signal_connect_after (self->priv->sidebar, "hide",
G_CALLBACK (sidebar_visibility_changed_cb), self);
gtk_box_pack_start (GTK_BOX (vbox), hpaned, TRUE, TRUE, 0);
gtk_widget_show (hpaned);
update_ui_visibility (self);
}
void
empathy_new_chatroom_dialog_show (GtkWindow *parent)
{
EmpathyNewChatroomDialog *dialog;
GtkBuilder *gui;
GtkSizeGroup *size_group;
gchar *filename;
if (dialog_p) {
gtk_window_present (GTK_WINDOW (dialog_p->window));
return;
}
dialog_p = dialog = g_new0 (EmpathyNewChatroomDialog, 1);
filename = empathy_file_lookup ("empathy-new-chatroom-dialog.ui", "src");
gui = empathy_builder_get_file (filename,
"new_chatroom_dialog", &dialog->window,
"table_grid", &dialog->table_grid,
"label_account", &dialog->label_account,
"label_server", &dialog->label_server,
"label_room", &dialog->label_room,
"entry_server", &dialog->entry_server,
"entry_room", &dialog->entry_room,
"treeview", &dialog->treeview,
"button_join", &dialog->button_join,
"expander_browse", &dialog->expander_browse,
"hbox_expander", &dialog->hbox_expander,
"label_error_message", &dialog->label_error_message,
"viewport_error", &dialog->viewport_error,
NULL);
g_free (filename);
empathy_builder_connect (gui, dialog,
"new_chatroom_dialog", "response", new_chatroom_dialog_response_cb,
"new_chatroom_dialog", "destroy", new_chatroom_dialog_destroy_cb,
"entry_server", "changed", new_chatroom_dialog_entry_changed_cb,
"entry_server", "activate", new_chatroom_dialog_entry_server_activate_cb,
"entry_server", "focus-out-event", new_chatroom_dialog_entry_server_focus_out_cb,
"entry_room", "changed", new_chatroom_dialog_entry_changed_cb,
"expander_browse", "activate", new_chatroom_dialog_expander_browse_activate_cb,
"button_close_error", "clicked", new_chatroom_dialog_button_close_error_clicked_cb,
NULL);
g_object_unref (gui);
g_object_add_weak_pointer (G_OBJECT (dialog->window), (gpointer) &dialog_p);
/* Label alignment */
size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
gtk_size_group_add_widget (size_group, dialog->label_account);
gtk_size_group_add_widget (size_group, dialog->label_server);
gtk_size_group_add_widget (size_group, dialog->label_room);
g_object_unref (size_group);
/* Set up chatrooms treeview */
new_chatroom_dialog_model_setup (dialog);
/* Add throbber */
dialog->throbber = gtk_spinner_new ();
gtk_box_pack_start (GTK_BOX (dialog->hbox_expander), dialog->throbber,
TRUE, TRUE, 0);
dialog->gsettings = g_settings_new (EMPATHY_PREFS_CHAT_SCHEMA);
/* Account chooser for custom */
dialog->account_chooser = empathy_account_chooser_new ();
empathy_account_chooser_set_filter (EMPATHY_ACCOUNT_CHOOSER (dialog->account_chooser),
empathy_account_chooser_filter_supports_chatrooms,
NULL);
gtk_grid_attach (GTK_GRID (dialog->table_grid),
dialog->account_chooser,
1, 0, 1, 1);
gtk_widget_show (dialog->account_chooser);
g_signal_connect (EMPATHY_ACCOUNT_CHOOSER (dialog->account_chooser), "ready",
G_CALLBACK (new_chatroom_dialog_account_ready_cb),
dialog);
g_signal_connect (GTK_COMBO_BOX (dialog->account_chooser), "changed",
G_CALLBACK (new_chatroom_dialog_account_changed_cb),
dialog);
new_chatroom_dialog_account_changed_cb (GTK_COMBO_BOX (dialog->account_chooser),
dialog);
if (parent) {
gtk_window_set_transient_for (GTK_WINDOW (dialog->window),
GTK_WINDOW (parent));
}
gtk_widget_show (dialog->window);
}
gint
main (gint argc, gchar **argv)
{
GtkWidget *window, *toolbar, *grid, *treeview, *scrolled_window;
GtkWidget *hbox, *hbox1, *hbox2, *checkbox, *option_menu, *menu;
gint i;
static const gchar *toolbar_styles[] = { "icons", "text", "both (vertical)",
"both (horizontal)" };
GtkToolItem *item;
GtkListStore *store;
GtkWidget *image;
GtkWidget *menuitem;
GtkWidget *button;
GtkWidget *label;
GIcon *gicon;
GSList *group;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
grid = gtk_grid_new ();
gtk_container_add (GTK_CONTAINER (window), grid);
toolbar = gtk_toolbar_new ();
gtk_widget_set_vexpand (toolbar, TRUE);
gtk_grid_attach (GTK_GRID (grid), toolbar, 0, 0, 2, 1);
hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3);
gtk_container_set_border_width (GTK_CONTAINER (hbox1), 5);
gtk_widget_set_vexpand (hbox1, TRUE);
gtk_grid_attach (GTK_GRID (grid), hbox1, 1, 1, 1, 1);
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_container_set_border_width (GTK_CONTAINER (hbox2), 5);
gtk_widget_set_vexpand (hbox2, TRUE);
gtk_grid_attach (GTK_GRID (grid), hbox2, 1, 2, 1, 1);
checkbox = gtk_check_button_new_with_mnemonic("_Vertical");
gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0);
g_signal_connect (checkbox, "toggled",
G_CALLBACK (change_orientation), toolbar);
checkbox = gtk_check_button_new_with_mnemonic("_Show Arrow");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), TRUE);
gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0);
g_signal_connect (checkbox, "toggled",
G_CALLBACK (change_show_arrow), toolbar);
checkbox = gtk_check_button_new_with_mnemonic("_Set Toolbar Style:");
g_signal_connect (checkbox, "toggled", G_CALLBACK (set_toolbar_style_toggled), toolbar);
gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0);
option_menu = gtk_combo_box_text_new ();
gtk_widget_set_sensitive (option_menu, FALSE);
g_object_set_data (G_OBJECT (checkbox), "option-menu", option_menu);
for (i = 0; i < G_N_ELEMENTS (toolbar_styles); i++)
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (option_menu), toolbar_styles[i]);
gtk_combo_box_set_active (GTK_COMBO_BOX (option_menu),
gtk_toolbar_get_style (GTK_TOOLBAR (toolbar)));
gtk_box_pack_start (GTK_BOX (hbox2), option_menu, FALSE, FALSE, 0);
g_signal_connect (option_menu, "changed",
G_CALLBACK (change_toolbar_style), toolbar);
checkbox = gtk_check_button_new_with_mnemonic("_Set Icon Size:");
g_signal_connect (checkbox, "toggled", G_CALLBACK (set_icon_size_toggled), toolbar);
gtk_box_pack_start (GTK_BOX (hbox2), checkbox, FALSE, FALSE, 0);
option_menu = gtk_combo_box_text_new ();
g_object_set_data (G_OBJECT (checkbox), "option-menu", option_menu);
gtk_widget_set_sensitive (option_menu, FALSE);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (option_menu), "small toolbar");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (option_menu), "large toolbar");
gtk_box_pack_start (GTK_BOX (hbox2), option_menu, FALSE, FALSE, 0);
g_signal_connect (option_menu, "changed",
G_CALLBACK (icon_size_history_changed), toolbar);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_set_hexpand (scrolled_window, TRUE);
gtk_widget_set_vexpand (scrolled_window, TRUE);
gtk_grid_attach (GTK_GRID (grid), scrolled_window, 1, 3, 1, 1);
store = create_items_list (&treeview);
gtk_container_add (GTK_CONTAINER (scrolled_window), treeview);
item = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "document-new");
gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Custom label");
add_item_to_list (store, item, "New");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gdk_threads_add_timeout (3000, (GSourceFunc) timeout_cb, item);
gtk_tool_item_set_expand (item, TRUE);
menu = gtk_menu_new ();
for (i = 0; i < 20; i++)
{
char *text;
text = g_strdup_printf ("Menuitem %d", i);
menuitem = gtk_menu_item_new_with_label (text);
g_free (text);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
}
item = gtk_menu_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "document-open");
gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Open");
gtk_menu_tool_button_set_menu (GTK_MENU_TOOL_BUTTON (item), menu);
add_item_to_list (store, item, "Open");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gdk_threads_add_timeout (3000, (GSourceFunc) timeout_cb1, item);
menu = gtk_menu_new ();
for (i = 0; i < 20; i++)
{
char *text;
text = g_strdup_printf ("A%d", i);
menuitem = gtk_menu_item_new_with_label (text);
g_free (text);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
}
item = gtk_menu_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "go-previous");
gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Back");
gtk_menu_tool_button_set_menu (GTK_MENU_TOOL_BUTTON (item), menu);
add_item_to_list (store, item, "BackWithHistory");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_separator_tool_item_new ();
add_item_to_list (store, item, "-----");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
image = gtk_image_new_from_icon_name ("dialog-warning", GTK_ICON_SIZE_DIALOG);
item = gtk_tool_item_new ();
gtk_widget_show (image);
gtk_container_add (GTK_CONTAINER (item), image);
add_item_to_list (store, item, "(Custom Item)");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "go-previous");
gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Back");
add_item_to_list (store, item, "Back");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_separator_tool_item_new ();
add_item_to_list (store, item, "-----");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "go-next");
gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Forward");
add_item_to_list (store, item, "Forward");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_toggle_tool_button_new ();
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-text-bold");
g_signal_connect (item, "toggled", G_CALLBACK (bold_toggled), NULL);
add_item_to_list (store, item, "Bold");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gtk_widget_set_sensitive (GTK_WIDGET (item), FALSE);
item = gtk_separator_tool_item_new ();
add_item_to_list (store, item, "-----");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gtk_tool_item_set_expand (item, TRUE);
gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM (item), FALSE);
g_assert (gtk_toolbar_get_nth_item (GTK_TOOLBAR (toolbar), 0) != 0);
item = gtk_radio_tool_button_new (NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-justify-left");
group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (item));
add_item_to_list (store, item, "Left");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_radio_tool_button_new (group);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-justify-center");
make_prop_editor (G_OBJECT (item));
group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (item));
add_item_to_list (store, item, "Center");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_radio_tool_button_new (group);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-justify-right");
add_item_to_list (store, item, "Right");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_tool_button_new (gtk_image_new_from_file ("apple-red.png"), "_Apple");
add_item_to_list (store, item, "Apple");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gtk_tool_button_set_use_underline (GTK_TOOL_BUTTON (item), TRUE);
gicon = g_content_type_get_icon ("video/ogg");
image = gtk_image_new_from_gicon (gicon, GTK_ICON_SIZE_LARGE_TOOLBAR);
g_object_unref (gicon);
item = gtk_tool_button_new (image, "Video");
add_item_to_list (store, item, "Video");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
image = gtk_image_new_from_icon_name ("utilities-terminal", GTK_ICON_SIZE_LARGE_TOOLBAR);
item = gtk_tool_button_new (image, "Terminal");
add_item_to_list (store, item, "Terminal");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
image = gtk_spinner_new ();
gtk_spinner_start (GTK_SPINNER (image));
item = gtk_tool_button_new (image, "Spinner");
add_item_to_list (store, item, "Spinner");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
gtk_widget_set_hexpand (hbox, TRUE);
gtk_grid_attach (GTK_GRID (grid), hbox, 1, 4, 1, 1);
button = gtk_button_new_with_label ("Drag me to the toolbar");
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
label = gtk_label_new ("Drop index:");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
label = gtk_label_new ("");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
checkbox = gtk_check_button_new_with_mnemonic("_Right to left");
if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), TRUE);
else
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), FALSE);
g_signal_connect (checkbox, "toggled", G_CALLBACK (rtl_toggled), NULL);
gtk_box_pack_end (GTK_BOX (hbox), checkbox, FALSE, FALSE, 0);
gtk_drag_source_set (button, GDK_BUTTON1_MASK,
target_table, G_N_ELEMENTS (target_table),
GDK_ACTION_MOVE);
gtk_drag_dest_set (toolbar, GTK_DEST_DEFAULT_DROP,
target_table, G_N_ELEMENTS (target_table),
GDK_ACTION_MOVE);
g_signal_connect (toolbar, "drag_motion",
G_CALLBACK (toolbar_drag_motion), NULL);
g_signal_connect (toolbar, "drag_leave",
G_CALLBACK (toolbar_drag_leave), NULL);
g_signal_connect (toolbar, "drag_drop",
G_CALLBACK (toolbar_drag_drop), label);
gtk_widget_show_all (window);
make_prop_editor (G_OBJECT (toolbar));
g_signal_connect (window, "delete_event", G_CALLBACK (gtk_main_quit), NULL);
g_signal_connect (toolbar, "popup_context_menu", G_CALLBACK (popup_context_menu), NULL);
gtk_main ();
return 0;
}
int music_build_element_widgets () {
int i = 0;
for (i = 0; i < 9; i++) {
label_music_info[i] = gtk_label_new(NULL);
gtk_label_set_width_chars(GTK_LABEL(label_music_info[i]), 15);
gtk_label_set_max_width_chars(GTK_LABEL(label_music_info[i]), 150);
gtk_label_set_line_wrap(GTK_LABEL(label_music_info[i]), TRUE);
}
separator_music_info = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
for (i = 0; i < 9; i++) {
label_music_lyric[i] = gtk_label_new(NULL);
gtk_label_set_max_width_chars(GTK_LABEL(label_music_lyric[i]), 305);
// gtk_label_set_line_wrap(GTK_LABEL(label_music_lyric[i]), TRUE);
}
gtk_label_set_selectable(GTK_LABEL(label_music_lyric[4]), TRUE);
gtk_label_set_use_underline (GTK_LABEL(label_music_lyric[4]), TRUE);
gtk_label_set_use_markup (GTK_LABEL(label_music_lyric[4]), TRUE);
gtk_label_set_pattern (GTK_LABEL(label_music_lyric[4]), "________");
separator_music_lyric1 = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
separator_music_lyric2 = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
button_music_start_server = gtk_button_new_with_label("启动服务器");
// set_button_music_start_server(button_music_start_server);
button_music_exit_server = gtk_button_new_with_label("关闭服务器");
// set_button_music_exit_server(button_music_exit_server);
button_music_play = gtk_button_new();
// box_music_play = button_with_image("/usr/share/raspi_remote_control/ui_images/ui_images_music/play.png");
// box_music_pause = button_with_image("/usr/share/raspi_remote_control/ui_images/ui_images_music/pause.png");
image_music_play = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/play.png");
image_music_play_light = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/play_light.png");
image_music_pause = gtk_image_new_from_file ("/usr/share/raspi_remote_control/ui_images/ui_images_music/pause.png");
image_music_pause_light = gtk_image_new_from_file ("/usr/share/raspi_remote_control/ui_images/ui_images_music/pause_light.png");
gtk_button_set_relief(GTK_BUTTON(button_music_play), GTK_RELIEF_NONE);
set_button_music_play(button_music_play);
button_music_pause = gtk_button_new_with_label("暂停");
// set_button_music_pause(button_music_pause);
button_music_unpause = gtk_button_new_with_label("取消暂停");
// set_button_music_unpause(button_music_unpause);
// button_music_stop = gtk_button_new_with_label("停止");
button_music_stop = gtk_button_new();
image_music_stop = gtk_image_new_from_file ("/usr/share/raspi_remote_control/ui_images/ui_images_music/stop.png");
image_music_stop_light = gtk_image_new_from_file ("/usr/share/raspi_remote_control/ui_images/ui_images_music/stop_light.png");
gtk_button_set_image(GTK_BUTTON(button_music_stop), image_music_stop);
gtk_button_set_relief(GTK_BUTTON(button_music_stop), GTK_RELIEF_NONE);
set_button_music_stop(button_music_stop);
// button_music_next = gtk_button_new_with_label("下一首");
button_music_next = gtk_button_new();
image_music_next = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/next.png");
image_music_next_light = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/next_light.png");
gtk_button_set_image(GTK_BUTTON(button_music_next), image_music_next);
gtk_button_set_relief(GTK_BUTTON(button_music_next), GTK_RELIEF_NONE);
set_button_music_next(button_music_next);
// button_music_pre = gtk_button_new_with_label("上一首");
button_music_pre = gtk_button_new();
image_music_pre = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/pre.png");
image_music_pre_light = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/pre_light.png");
gtk_button_set_image (GTK_BUTTON(button_music_pre), image_music_pre);
gtk_button_set_relief(GTK_BUTTON(button_music_pre), GTK_RELIEF_NONE);
set_button_music_pre(button_music_pre);
// button_music_volume_up = gtk_button_new_with_label("音量+");
// set_button_music_volume_up(button_music_volume_up);
// button_music_volume_silence = gtk_button_new_with_label("静音");
button_music_silence = gtk_button_new();
image_music_silence = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/silence.png");
image_music_silence_light = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/silence_light.png");
image_music_unsilence = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/unsilence.png");
image_music_unsilence_light = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/unsilence_light.png");
gtk_button_set_image (GTK_BUTTON(button_music_silence), image_music_silence);
gtk_button_set_relief(GTK_BUTTON(button_music_silence), GTK_RELIEF_NONE);
set_button_music_silence(button_music_silence);
button_music_volume = gtk_volume_button_new();
set_button_music_volume( button_music_volume);
button_music_reset_list = gtk_button_new_with_label("重设列表");
set_button_music_reset_list(button_music_reset_list);
// button_music_choose_path = gtk_button_new_with_label("添加路径");
// set_button_music_choose_path(button_music_choose_path);
// music_path_dialog = gtk_file_chooser_widget_new(GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
music_path_dialog = gtk_file_chooser_dialog_new ("test_title", NULL, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, "test_button_text", NULL);
button_music_choose_path = gtk_file_chooser_button_new_with_dialog (music_path_dialog);
gtk_file_chooser_button_set_title (GTK_FILE_CHOOSER_BUTTON(button_music_choose_path), "添加路径");
// gtk_file_chooser_set_select_multiple (music_path_dialog, TRUE);
button_music_delete_path = gtk_button_new_with_label("删除当前路径");
set_button_music_delete_path(button_music_delete_path);
scale_music_process = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 100, 1);
set_scale_music_process(scale_music_process);
label_music_cur_time = gtk_label_new ("--:--:--");
label_music_total_time = gtk_label_new ("--:--:--");
switch_music_autonext = gtk_switch_new ();
set_switch_music_autonext ();
label_music_autonext = gtk_label_new ("AutoNext: ");
switch_music_repeat = gtk_switch_new ();
set_switch_music_repeat ();
label_music_repeat = gtk_label_new ("Repeat: ");
switch_music_shuffle = gtk_switch_new ();
set_switch_music_shuffle ();
label_music_shuffle = gtk_label_new ("Shuffle: ");
radio_button_music_mode_shuffle = gtk_radio_button_new (NULL);
label_music_mode_shuffle = gtk_label_new ("随机:");
radio_button_music_mode_loop_list = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON (radio_button_music_mode_shuffle));
label_music_mode_loop_list = gtk_label_new ("列表循环:");
radio_button_music_mode_play_list = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON (radio_button_music_mode_shuffle));
label_music_mode_play_list = gtk_label_new ("播放列表:");
radio_button_music_mode_loop_one = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON (radio_button_music_mode_shuffle));
label_music_mode_loop_one = gtk_label_new ("单曲:");
spinner_music_mode_changing = gtk_spinner_new ();
set_radio_button_music_mode ();
store_music_dir_list = gtk_tree_store_new(dir_n_columns, G_TYPE_STRING);
tree_view_music_dir_list = gtk_tree_view_new_with_model (GTK_TREE_MODEL(store_music_dir_list));
text_renderer_music_dir_list = gtk_cell_renderer_text_new ();
column_music_dir_list = gtk_tree_view_column_new_with_attributes (NULL, text_renderer_music_dir_list, "text", dir_name, NULL);
gtk_tree_view_column_set_fixed_width(column_music_dir_list, 100);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view_music_dir_list), column_music_dir_list);
music_dir_list_sw_adj_h = gtk_adjustment_new(100, 0, 100, 1, 1, 50);
music_dir_list_sw = gtk_scrolled_window_new(NULL, music_dir_list_sw_adj_h);
gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(music_dir_list_sw), 330);
gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(music_dir_list_sw), 100);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(music_dir_list_sw), GTK_SHADOW_NONE);
// gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(music_dir_list_sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(music_dir_list_sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(music_dir_list_sw), tree_view_music_dir_list);
selection_music_dir_list = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view_music_dir_list));
set_tree_view_music_dir_list ();
store_music_list = gtk_tree_store_new(list_n_columns, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
// char file_index[BUFSIZ];
// printf("music_list_num is: %s\n", music_list_num);
// while (i < music_list_num) {
// // printf("%d: %s\n", i, music_list[i]);
// sprintf(file_index, "%d", i + 1);
// gtk_tree_store_append(store_music_list, &iter_music_list, NULL);
// gtk_tree_store_set (store_music_list, &iter_music_list, list_index, file_index, list_title, music_list[i], list_total_sec, "03:00", -1);
// i++;
// }
//
tree_view_music_list = gtk_tree_view_new_with_model (GTK_TREE_MODEL(store_music_list));
text_renderer_music_list = gtk_cell_renderer_text_new ();
column_music_list = gtk_tree_view_column_new_with_attributes (NULL, text_renderer_music_list, "text", list_index, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view_music_list), column_music_list);
gtk_tree_view_column_set_title(column_music_list, "序号");
text_renderer_music_list = gtk_cell_renderer_text_new ();
column_music_list = gtk_tree_view_column_new_with_attributes (NULL, text_renderer_music_list, "text", list_title, NULL);
gtk_tree_view_column_set_fixed_width(column_music_list, 100);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view_music_list), column_music_list);
// text_renderer_music_list = gtk_cell_renderer_text_new ();
// column_music_list = gtk_tree_view_column_new_with_attributes (NULL, text_renderer_music_list, "text", list_total_sec, NULL);
// gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view_music_list), column_music_list);
music_list_sw_adj_h = gtk_adjustment_new(100, 0, 100, 1, 1, 50);
music_list_sw = gtk_scrolled_window_new(NULL, music_list_sw_adj_h);
gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(music_list_sw), 370);
gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(music_list_sw), 200);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(music_list_sw), GTK_SHADOW_NONE);
// gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(music_list_sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(music_list_sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(music_list_sw), tree_view_music_list);
selection_music_list = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view_music_list));
set_tree_view_music_list ();
return 1;
}
// Основная функция построения класса, в которой происходит заполнение окна виджетами.
void cMainWin::Create()
{
// Создаём объект, если ранее он был не создан или был уничтожен.
if(mbIsCreated)
return;
// Общие виджеты. Будут использованы несколько раз.
GtkWidget *awHBox; // Горизонтальный бокс.
GtkWidget *awVBox; // Вертикальный бокс.
GtkWidget *awLabel; // Заголовок.
GtkWidget *awFrame; // Фрейм для виджетов.
GtkWidget *awMenuBar; // Виджет для основного меню.
GtkWidget *awSubmenu; // Подменю.
GtkWidget *awMenuitem; // Пункт основного меню.
GtkWidget *awSubMenuitem; // Пункт подменю.
GtkWidget *awOpenFileButton; // Кнопка открытия файла.
GtkWidget *awAdditionButton; // Кнопка доп. настроек.
GtkWidget *awConvertButton; // Кнопка конвертации.
// Настраиваем виджет главного окна.
mwWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size ((GtkWindow *)mwWindow, 800, 400); // Задаём размер.
gtk_window_move((GtkWindow *)mwWindow, 50, 50); // Перемещаем окно.
gtk_window_set_title((GtkWindow *)mwWindow, msTitle.c_str()); // Задаём имя.
// Устанавливаем обработчик события уничтожения окна.
g_signal_connect(
G_OBJECT(mwWindow), "delete_event",
G_CALLBACK(gtk_main_quit), this);
// Создаём новый вертикальный бокс и забиваем его в основное окно.
mwMainBox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add((GtkContainer *)mwWindow, mwMainBox);
// Создаём новый виджет основного меню.
awMenuBar = gtk_menu_bar_new ();
gtk_box_pack_start (GTK_BOX (mwMainBox), awMenuBar, FALSE, TRUE, 0); // Забиваем меню в главный бокс.
// Создаём новый пункт меню Справка и заполняем его подменю.
awMenuitem = gtk_menu_item_new_with_label ("Справка");
awSubmenu = gtk_menu_new();
// Добавляем в подменю новый пункт.
awSubMenuitem = gtk_menu_item_new_with_label ("О программе");
gtk_menu_shell_append (GTK_MENU_SHELL (awSubmenu), awSubMenuitem); // Не забываем связать этот пункт с подменю.
// Устанавливаем обработчик нажатия на пункт подменю.
g_signal_connect(awSubMenuitem, "activate",
G_CALLBACK(OnAbout), this);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (awMenuitem), awSubmenu); // Связываем подменю с главным.
gtk_menu_shell_append (GTK_MENU_SHELL (awMenuBar), awMenuitem); // И добавляем пунтк меню в главное меню.
// Добавляем в главный бокс разделитель виджетов(простая длинная линия).
gtk_box_pack_start (GTK_BOX (mwMainBox), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, TRUE, 5);
// Задаём вертикальный бокс для первого пункта процесса конвертации и забиваем его в главный бокс.
awVBox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start(GTK_BOX(mwMainBox), awVBox, FALSE, FALSE, 1);
// Задаём горизонтальный бокс для первого пункта процесса конвертации и забиваем его в предыдущий вертикальный бокс.
awHBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start(GTK_BOX(awVBox), awHBox, FALSE, FALSE, 1);
// Задаём виджет для отображения текста и добавляем в горизонтальный бокс.
awLabel = gtk_label_new ("1.");
//gtk_widget_set_halign (awLabel, GTK_ALIGN_START); // Выравнивание. Не нужно, если использовать горизонтальный бокс.
gtk_box_pack_start(GTK_BOX(awHBox), awLabel, FALSE, FALSE, 5);
// Создаём кнопку Открыть файл и добавляем в горизонтальный бокс.
awOpenFileButton = gtk_button_new_with_label ("Открыть файл");
gtk_box_pack_start(GTK_BOX(awHBox), awOpenFileButton, FALSE, FALSE, 10);
// Устанавливаем обработчик нажатия на кнопку Открыть файл.
g_signal_connect(awOpenFileButton, "clicked",
G_CALLBACK(OnOpenFile), this);
// Создаём бокс для списка всех записей и добавляем в горизонтальный бокс.
mwTrackNameBox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start(GTK_BOX(awHBox), mwTrackNameBox, FALSE, FALSE, 5);
// Переходим ко второму пункту меню
// Задаём вертикальный бокс для второго пункта процесса конвертации и забиваем его в главный бокс.
awVBox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start(GTK_BOX(mwMainBox), awVBox, FALSE, FALSE, 10);
// Задаём горизонтальный бокс для второго пункта процесса конвертации и забиваем его в предыдущий вертикальный бокс.
awHBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start(GTK_BOX(awVBox), awHBox, FALSE, FALSE, 1);
// Задаём виджет для отображения текста и добавляем в горизонтальный бокс.
awLabel = gtk_label_new ("2. ");
gtk_box_pack_start(GTK_BOX(awHBox), awLabel, FALSE, FALSE, 5);
// Создаём комбо бокс для выбора формата конвертации.
mwFormat = gtk_combo_box_text_new ();
for(int i = eFormat_MP3; i < eFormat_Unknown; i++)
{
// Для каждого пункта из enum добавляем пункт в комбо боксе со своим текстом из asFormat.
gtk_combo_box_text_insert_text ((GtkComboBoxText *)mwFormat, -1, asFormat[i].c_str());
}
gtk_combo_box_set_active((GtkComboBox *)mwFormat, 0); // Устанавливаем активный элемент на первый в списке.
// Задаём обработчик события смены формата.
g_signal_connect (mwFormat, "changed",
G_CALLBACK (OnChangeFormat), this);
gtk_box_pack_start(GTK_BOX(awHBox), mwFormat, FALSE, FALSE, 5); // Добавляем комбо бокс в горизонтальный бокс.
// Теперь настроим виджеты, которые будут соответствовать формату конвертации из комбо бокса.
// Виджеты, соответствующие формату, будут показываться, только при выборе этого формата в комбо боксе.
// Задаём горизонтальный бокс для настроек под определённый формат и добавляем его в вертикальный бокс.
awHBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start(GTK_BOX(awVBox), awHBox, FALSE, FALSE, 10);
// Настроим MP3 виджеты.
// Задаём слайдер качества с определённым количеством меток.
mMP3Widgets.mwQuality = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, eMP3Quality_count-1, 1);
gtk_scale_set_draw_value ((GtkScale *)mMP3Widgets.mwQuality, FALSE); // Не будем рисовать текущее значение.
// Добавим метки на шкалу слайдера для визуализации.
for(int i = 0; i < eMP3Quality_count; i++)
{
std::string asQ = asMP3Quality[i] +"kbps"; // Значения мток берём из asMP3Quality массива.
gtk_scale_add_mark ((GtkScale *)mMP3Widgets.mwQuality, i, GTK_POS_TOP, asQ.c_str());
}
gtk_box_pack_start(GTK_BOX(awHBox), mMP3Widgets.mwQuality, TRUE, TRUE, 30); // Добавляем слайдер в горизонтальный бокс.
gtk_range_set_show_fill_level ((GtkRange *)mMP3Widgets.mwQuality, TRUE); // Заполняем слайдер другим цветом.
gtk_range_set_restrict_to_fill_level ((GtkRange *)mMP3Widgets.mwQuality, TRUE); // Устанавливаем указатель слайдера до уровня заполнения слайдера.
gtk_range_set_fill_level ((GtkRange *)mMP3Widgets.mwQuality, eMP3Quality_count-1); // Полностью заполняем слайдер цветом.
gtk_range_set_value ((GtkRange *)mMP3Widgets.mwQuality, eMP3Quality_count-1); // Ставим значение слайдера на последнее из массива значений.
// Указатель теперь связан с уровнем заполнения, но указатель всё ещё можно двигать, не меняя уровень заполнения.
// Для этого необходимо ввести 2 обработчика событий - изменение значение слайдера и изменение границ указателя, для перемещения уровня заполнения.
g_signal_connect (mMP3Widgets.mwQuality, "value-changed", G_CALLBACK (OnQualityChanged), this);
g_signal_connect (mMP3Widgets.mwQuality, "adjust-bounds", G_CALLBACK (OnAdjustBoundsQuality), this);
gtk_widget_show(mMP3Widgets.mwQuality); // Показываем виджеты страницы MP3 конвертера.
// Настраиваем OGG виджеты.
// Задаём слайдер качества с определённым количеством меток.
mOGGWidgets.mwQuality = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, eOGGQuality_count-1, 1);
gtk_scale_set_draw_value ((GtkScale *)mOGGWidgets.mwQuality, FALSE);
// Добавим метки на шкалу слайдера для визуализации.
for(int i = 0; i < eOGGQuality_count; i++)
{
std::string asQ = asOGGQuality[i] +"kbps"; // Значения мток берём из asOGGQuality массива.
gtk_scale_add_mark ((GtkScale *)mOGGWidgets.mwQuality, i, GTK_POS_TOP, asQ.c_str());
}
gtk_box_pack_start(GTK_BOX(awHBox), mOGGWidgets.mwQuality, TRUE, TRUE, 30); // Добавляем слайдер в горизонтальный бокс.
gtk_range_set_show_fill_level ((GtkRange *)mOGGWidgets.mwQuality, TRUE); // Заполняем слайдер другим цветом.
gtk_range_set_restrict_to_fill_level ((GtkRange *)mOGGWidgets.mwQuality, TRUE); // Устанавливаем указатель слайдера до уровня заполнения слайдера.
gtk_range_set_fill_level ((GtkRange *)mOGGWidgets.mwQuality, eOGGQuality_count-1); // Полностью заполняем слайдер цветом.
gtk_range_set_value ((GtkRange *)mOGGWidgets.mwQuality, eOGGQuality_count-1); // Ставим значение слайдера на последнее из массива значений.
// Снова вводим 2 обработчика событий, один на изменение значения слайдера и друго для изменения границ указателя, для перемещения уровня заполнения.
g_signal_connect (mOGGWidgets.mwQuality, "value-changed", G_CALLBACK (OnQualityChanged), this);
g_signal_connect (mOGGWidgets.mwQuality, "adjust-bounds", G_CALLBACK (OnAdjustBoundsQuality), this);
// Добавим новую кнопку Дополнительно для отображения дополнительных параметров и добавим его в горизонтальный бокс.
awAdditionButton = gtk_button_new_with_label ("Дополнительно");
gtk_box_pack_end(GTK_BOX(awHBox), awAdditionButton, FALSE, FALSE, 30);
// Введём обработчик нажатия на кнопку Дополнительно.
g_signal_connect(awAdditionButton, "clicked",
G_CALLBACK(OnShowAdditionalSettings), this);
// Переходим к третьему пункту меню.
// Задаём вертикальный бокс для третьего пункта процесса конвертации и забиваем его в главный бокс.
awVBox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start(GTK_BOX(mwMainBox), awVBox, FALSE, FALSE, 1);
// Задаём горизонтальный бокс для третьего пункта процесса конвертации и забиваем его в предыдущий вертикальный бокс.
awHBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start(GTK_BOX(awVBox), awHBox, FALSE, FALSE, 10);
// Задаём виджет для отображения текста и добавляем в горизонтальный бокс.
awLabel = gtk_label_new ("3.");
gtk_box_pack_start(GTK_BOX(awHBox), awLabel, FALSE, FALSE, 5);
// Добавим кнопку Конвертировать - для начала процесса конвертации ваших аудио файлов. Добавим кнопку в горизонтальный бокс.
awConvertButton = gtk_button_new_with_label ("Конвертировать");
gtk_box_pack_start(GTK_BOX(awHBox), awConvertButton, FALSE, FALSE, 10);
// Создадим спиннер для визуального отображения процесса конвертации.
// Это просто необходимо, т.к. программа как бы подвисает, из-за того что мы конвертируем в одном потоке с программой.
// Серъёзно нагружает процессор =(
mwSpinner = gtk_spinner_new ();
gtk_box_pack_start(GTK_BOX(awHBox), mwSpinner, FALSE, FALSE, 5);
// Обработчик события нажатие на кнопку Конвертация.
g_signal_connect(awConvertButton, "clicked",
G_CALLBACK(OnConvert), this);
gtk_widget_show_all (mwWindow); // Покажем все виджеты в окне.
gtk_widget_hide(mOGGWidgets.mwQuality); // Скроем виджеты со страницы OGG. По умолчанию отображаем конвертацию в MP3.
gtk_widget_hide(mwSpinner); // Скроем спиннер, т.к. мы хотим его показать только в момент конвертации файлов.
mbIsCreated = true; // Объект создан.
}
/* Gobj */
static void
bjb_window_base_constructed (GObject *obj)
{
BjbWindowBase *self = BJB_WINDOW_BASE (obj);
BjbWindowBasePriv *priv;
gboolean maximized;
const gint32 *position;
const gint32 *size;
gsize n_elements;
GVariant *variant;
G_OBJECT_CLASS (bjb_window_base_parent_class)->constructed (obj);
priv = self->priv;
priv->settings = bjb_app_get_settings ((gpointer) g_application_get_default ());
gtk_window_set_position (GTK_WINDOW (self),GTK_WIN_POS_CENTER);
gtk_window_set_title (GTK_WINDOW (self), _(BIJIBEN_MAIN_WIN_TITLE));
variant = g_settings_get_value (G_SETTINGS (priv->settings), "window-size");
size = g_variant_get_fixed_array (variant, &n_elements, sizeof (gint32));
if (n_elements == 2)
gtk_window_set_default_size (GTK_WINDOW (self), size[0], size[1]);
g_variant_unref (variant);
variant = g_settings_get_value (G_SETTINGS (priv->settings), "window-position");
position = g_variant_get_fixed_array (variant, &n_elements, sizeof (gint32));
if (n_elements == 2)
gtk_window_move (GTK_WINDOW (self), position[0], position[1]);
g_variant_unref (variant);
maximized = g_settings_get_boolean (G_SETTINGS (priv->settings), "window-maximized");
if (maximized)
gtk_window_maximize (GTK_WINDOW (self));
/* We probably want to offer a no entry window at first (startup) */
priv->entry = NULL ;
priv->controller = bjb_controller_new
(bijiben_get_manager (BIJIBEN_APPLICATION(g_application_get_default())),
GTK_WINDOW (obj),
priv->entry );
/* Shared toolbar */
priv->view = bjb_main_view_new (GTK_WIDGET (obj), priv->controller);
priv->main_toolbar = bjb_main_toolbar_new (priv->view, priv->controller);
gtk_window_set_titlebar (GTK_WINDOW (self), GTK_WIDGET (priv->main_toolbar));
/* Search entry toolbar */
priv->search_bar = bjb_search_toolbar_new (GTK_WIDGET (obj), priv->controller);
gtk_box_pack_start (GTK_BOX (priv->vbox), GTK_WIDGET (priv->search_bar), FALSE, FALSE, 0);
/* UI : stack for different views */
priv->stack = GTK_STACK (gtk_stack_new ());
gtk_box_pack_start (GTK_BOX (priv->vbox), GTK_WIDGET (priv->stack), TRUE, TRUE, 0);
priv->spinner = gtk_spinner_new ();
gtk_stack_add_named (priv->stack, priv->spinner, "spinner");
gtk_stack_set_visible_child_name (priv->stack, "spinner");
gtk_widget_show (priv->spinner);
gtk_spinner_start (GTK_SPINNER (priv->spinner));
priv->no_note = bjb_empty_results_box_new ();
gtk_stack_add_named (priv->stack, priv->no_note, "empty");
gtk_stack_add_named (priv->stack, GTK_WIDGET (priv->view), "main-view");
gtk_widget_show (GTK_WIDGET (priv->stack));
/* Connection to window signals */
g_signal_connect (GTK_WIDGET (self),
"destroy",
G_CALLBACK (bjb_window_base_destroy),
self);
g_signal_connect (self,
"window-state-event",
G_CALLBACK (bjb_application_window_state_changed),
priv->settings);
g_signal_connect (self,
"configure-event",
G_CALLBACK (bjb_application_window_configured),
self);
/* Keys */
g_signal_connect (GTK_WIDGET (self),
"key-press-event",
G_CALLBACK(on_key_pressed_cb),
self);
/* If a note is requested at creation, show it
* This is a specific type of window not associated with any view */
if (priv->note == NULL)
{
bjb_window_base_switch_to (self, BJB_WINDOW_BASE_MAIN_VIEW);
}
else
{
priv->detached = TRUE;
bjb_window_base_switch_to_item (self, BIJI_ITEM (priv->note));
}
/* For some reason, do not gtk_widget_show _self_
* or gtk_application_get_menu_bar will run,
* fire a warning, while app menu will not show up
* you have been warned!
*
* This is probably due to the fact that,
* at startup, we still are
* inside... drums... gapplication startup () */
gtk_widget_show (priv->vbox);
}
static void
um_account_dialog_init (UmAccountDialog *self)
{
GtkBuilder *builder;
GtkWidget *widget;
const gchar *filename;
GError *error = NULL;
GtkDialog *dialog;
GtkWidget *content;
GtkWidget *actions;
GtkWidget *box;
builder = gtk_builder_new ();
filename = UIDIR "/account-dialog.ui";
if (!g_file_test (filename, G_FILE_TEST_EXISTS))
filename = "data/account-dialog.ui";
if (!gtk_builder_add_from_file (builder, filename, &error)) {
g_error ("%s", error->message);
g_error_free (error);
return;
}
dialog = GTK_DIALOG (self);
actions = gtk_dialog_get_action_area (dialog);
content = gtk_dialog_get_content_area (dialog);
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gtk_window_set_title (GTK_WINDOW (dialog), " ");
gtk_window_set_icon_name (GTK_WINDOW (dialog), "system-users");
/* Rearrange the bottom of dialog, so we can have spinner on left */
g_object_ref (actions);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_container_remove (GTK_CONTAINER (content), actions);
gtk_box_pack_end (GTK_BOX (box), actions, FALSE, TRUE, 0);
gtk_box_pack_end (GTK_BOX (content), box, TRUE, TRUE, 0);
gtk_widget_show (box);
g_object_unref (actions);
/* Create the spinner, but don't show it yet */
self->spinner = GTK_SPINNER (gtk_spinner_new ());
widget = gtk_alignment_new (0.5, 0.5, 1.0, 1.0);
gtk_alignment_set_padding (GTK_ALIGNMENT (widget), 0, 0, 12, 6);
gtk_box_pack_start (GTK_BOX (box), widget, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (widget), GTK_WIDGET (self->spinner));
gtk_widget_show (widget);
gtk_dialog_add_button (dialog, _("Cancel"), GTK_RESPONSE_CANCEL);
widget = gtk_dialog_add_button (dialog, _("_Add"), GTK_RESPONSE_OK);
gtk_widget_grab_default (widget);
widget = (GtkWidget *) gtk_builder_get_object (builder, "account-dialog");
gtk_container_add (GTK_CONTAINER (content), widget);
self->container_widget = widget;
local_init (self, builder);
enterprise_init (self, builder);
join_init (self, builder);
mode_init (self, builder);
g_object_unref (builder);
}
int
main (int argc, char *argv[])
{
GtkWidget *window, *box, *hbox, *button, *spinner, *check,
*fps_label, *gears, *extra_hbox, *bbox, *overlay,
*revealer, *frame, *label, *scrolled;
int i;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "GdkGears");
gtk_window_set_default_size (GTK_WINDOW (window), 640, 640);
gtk_container_set_border_width (GTK_CONTAINER (window), 12);
g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
overlay = gtk_overlay_new ();
gtk_container_add (GTK_CONTAINER (window), overlay);
gtk_widget_show (overlay);
revealer = gtk_revealer_new ();
gtk_widget_set_halign (revealer, GTK_ALIGN_END);
gtk_widget_set_valign (revealer, GTK_ALIGN_START);
gtk_overlay_add_overlay (GTK_OVERLAY (overlay),
revealer);
gtk_widget_show (revealer);
frame = gtk_frame_new (NULL);
gtk_style_context_add_class (gtk_widget_get_style_context (frame),
"app-notification");
gtk_container_add (GTK_CONTAINER (revealer), frame);
gtk_widget_show (frame);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, FALSE);
gtk_box_set_spacing (GTK_BOX (hbox), 6);
gtk_container_add (GTK_CONTAINER (frame), hbox);
gtk_widget_show (hbox);
label = gtk_label_new ("This is a transparent overlay widget!!!!\nAmazing, eh?");
gtk_container_add (GTK_CONTAINER (hbox), label);
gtk_widget_show (label);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, FALSE);
gtk_box_set_spacing (GTK_BOX (box), 6);
gtk_container_add (GTK_CONTAINER (overlay), box);
gtk_widget_show (box);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, FALSE);
gtk_box_set_spacing (GTK_BOX (box), 6);
gtk_container_add (GTK_CONTAINER (box), hbox);
gtk_widget_show (hbox);
gears = gtk_gears_new ();
gtk_widget_set_hexpand (gears, TRUE);
gtk_widget_set_vexpand (gears, TRUE);
gtk_container_add (GTK_CONTAINER (hbox), gears);
gtk_widget_show (gears);
for (i = 0; i < GTK_GEARS_N_AXIS; i++)
gtk_container_add (GTK_CONTAINER (hbox), create_axis_slider (GTK_GEARS (gears), i));
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, FALSE);
gtk_box_set_spacing (GTK_BOX (hbox), 6);
gtk_container_add (GTK_CONTAINER (box), hbox);
gtk_widget_show (hbox);
fps_label = gtk_label_new ("");
gtk_container_add (GTK_CONTAINER (hbox), fps_label);
gtk_widget_show (fps_label);
gtk_gears_set_fps_label (GTK_GEARS (gears), GTK_LABEL (fps_label));
spinner = gtk_spinner_new ();
gtk_box_pack_end (GTK_BOX (hbox), spinner, FALSE, FALSE, 0);
gtk_widget_show (spinner);
gtk_spinner_start (GTK_SPINNER (spinner));
check = gtk_check_button_new_with_label ("Animate spinner");
gtk_box_pack_end (GTK_BOX (hbox), check, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
gtk_widget_show (check);
g_signal_connect (check, "toggled",
G_CALLBACK (toggle_spin), spinner);
check = gtk_check_button_new_with_label ("Alpha");
gtk_box_pack_end (GTK_BOX (hbox), check, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), FALSE);
gtk_widget_show (check);
g_signal_connect (check, "toggled",
G_CALLBACK (toggle_alpha), gears);
check = gtk_check_button_new_with_label ("Overlay");
gtk_box_pack_end (GTK_BOX (hbox), check, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), FALSE);
gtk_widget_show (check);
g_signal_connect (check, "toggled",
G_CALLBACK (toggle_overlay), revealer);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_NEVER);
gtk_container_add (GTK_CONTAINER (box), scrolled);
gtk_widget_show (scrolled);
extra_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, FALSE);
gtk_box_set_spacing (GTK_BOX (extra_hbox), 6);
gtk_container_add (GTK_CONTAINER (scrolled), extra_hbox);
gtk_widget_show (extra_hbox);
bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_set_spacing (GTK_BOX (bbox), 6);
gtk_container_add (GTK_CONTAINER (box), bbox);
gtk_widget_show (bbox);
button = gtk_button_new_with_label ("Moar gears!");
gtk_widget_set_hexpand (button, TRUE);
gtk_container_add (GTK_CONTAINER (bbox), button);
g_signal_connect (button, "clicked", G_CALLBACK (moar_gears), extra_hbox);
gtk_widget_show (button);
button = gtk_button_new_with_label ("Quit");
gtk_widget_set_hexpand (button, TRUE);
gtk_container_add (GTK_CONTAINER (bbox), button);
g_signal_connect_swapped (button, "clicked", G_CALLBACK (gtk_widget_destroy), window);
gtk_widget_show (button);
gtk_widget_show (window);
gtk_main ();
return EXIT_SUCCESS;
}
static void
bluetooth_chooser_init(BluetoothChooser *self)
{
BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(self);
GtkWidget *vbox;
GtkWidget *hbox;
gtk_widget_push_composite_child ();
g_object_set (G_OBJECT (self), "orientation", GTK_ORIENTATION_VERTICAL, NULL);
priv->client = bluetooth_client_new ();
/* Setup the widget itself */
gtk_box_set_spacing (GTK_BOX(self), 18);
gtk_container_set_border_width (GTK_CONTAINER(self), 0);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_widget_show (vbox);
gtk_box_pack_start (GTK_BOX (self), vbox, TRUE, TRUE, 0);
/* The treeview label */
priv->search_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 24);
gtk_widget_set_name (priv->search_hbox, "search_hbox");
if (priv->show_searching)
gtk_widget_show (priv->search_hbox);
gtk_box_pack_end (GTK_BOX (vbox), priv->search_hbox, FALSE, TRUE, 0);
gtk_widget_set_no_show_all (priv->search_hbox, TRUE);
/* Setup the adapter disco mode callback for the search button */
priv->adapter_model = bluetooth_client_get_adapter_model (priv->client);
g_signal_connect (priv->adapter_model, "row-changed",
G_CALLBACK (adapter_model_row_changed), self);
/* The searching label */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_widget_set_name (hbox, "searching label hbox");
priv->spinner = gtk_spinner_new ();
gtk_container_add (GTK_CONTAINER (hbox), priv->spinner);
gtk_widget_show (priv->spinner);
priv->search_label = gtk_label_new (_("Searching for devices…"));
gtk_container_add (GTK_CONTAINER (hbox), priv->search_label);
gtk_widget_show (priv->search_label);
gtk_widget_show (hbox);
if (priv->show_searching) {
gboolean discovering;
g_object_get (G_OBJECT (priv->client), "default-adapter-discovering", &discovering, NULL);
set_search_label (self, discovering);
}
gtk_box_pack_start (GTK_BOX (priv->search_hbox), hbox, FALSE, TRUE, 0);
/* The treeview */
priv->scrolled_window = create_treeview (self);
gtk_widget_show_all (priv->scrolled_window);
gtk_box_pack_start (GTK_BOX (vbox), priv->scrolled_window, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (priv->scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (priv->scrolled_window), GTK_SHADOW_IN);
/* The filters */
priv->device_type_filter_model = GTK_TREE_MODEL (gtk_list_store_new (DEVICE_TYPE_FILTER_NUM_COLS,
G_TYPE_STRING, G_TYPE_INT));
priv->filters_vbox = bluetooth_filter_widget_new ();
gtk_widget_show (priv->filters_vbox);
gtk_box_pack_start (GTK_BOX (self), priv->filters_vbox, FALSE, TRUE, 0);
gtk_widget_set_no_show_all (priv->filters_vbox, TRUE);
/* if filters are not visible hide the vbox */
if (!priv->show_device_type && !priv->show_device_category)
gtk_widget_hide (priv->filters_vbox);
priv->default_adapter_changed_id = g_signal_connect (priv->client, "notify::default-adapter",
G_CALLBACK (default_adapter_changed), self);
g_signal_connect(self, "notify::device-type-filter",
G_CALLBACK(filter_type_changed_cb), NULL);
g_signal_connect(self, "notify::device-category-filter",
G_CALLBACK(filter_category_changed_cb), NULL);
gtk_widget_pop_composite_child ();
}
static void
set_background (CcBackgroundPanel *panel,
GSettings *settings,
CcBackgroundItem *item)
{
CcBackgroundPanelPrivate *priv = panel->priv;
GDesktopBackgroundStyle style;
gboolean save_settings = TRUE;
const char *uri;
CcBackgroundItemFlags flags;
char *filename;
if (item == NULL)
return;
uri = cc_background_item_get_uri (item);
flags = cc_background_item_get_flags (item);
if ((flags & CC_BACKGROUND_ITEM_HAS_URI) && uri == NULL)
{
g_settings_set_enum (settings, WP_OPTIONS_KEY, G_DESKTOP_BACKGROUND_STYLE_NONE);
g_settings_set_string (settings, WP_URI_KEY, "");
}
else if (cc_background_item_get_source_url (item) != NULL &&
cc_background_item_get_needs_download (item))
{
GFile *source, *dest;
char *cache_path, *basename, *dest_path, *display_name, *dest_uri;
GdkPixbuf *pixbuf;
cache_path = bg_pictures_source_get_cache_path ();
if (g_mkdir_with_parents (cache_path, USER_DIR_MODE) < 0)
{
g_warning ("Failed to create directory '%s'", cache_path);
g_free (cache_path);
return;
}
g_free (cache_path);
dest_path = bg_pictures_source_get_unique_path (cc_background_item_get_source_url (item));
dest = g_file_new_for_path (dest_path);
g_free (dest_path);
source = g_file_new_for_uri (cc_background_item_get_source_url (item));
basename = g_file_get_basename (source);
display_name = g_filename_display_name (basename);
dest_path = g_file_get_path (dest);
g_free (basename);
/* create a blank image to use until the source image is ready */
pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, 1, 1);
gdk_pixbuf_fill (pixbuf, 0x00000000);
gdk_pixbuf_save (pixbuf, dest_path, "png", NULL, NULL);
g_object_unref (pixbuf);
g_free (dest_path);
if (priv->copy_cancellable)
{
g_cancellable_cancel (priv->copy_cancellable);
g_cancellable_reset (priv->copy_cancellable);
}
if (priv->spinner)
{
gtk_widget_destroy (GTK_WIDGET (priv->spinner));
priv->spinner = NULL;
}
/* create a spinner while the file downloads */
priv->spinner = gtk_spinner_new ();
gtk_spinner_start (GTK_SPINNER (priv->spinner));
gtk_box_pack_start (GTK_BOX (WID ("bottom-hbox")), priv->spinner, FALSE,
FALSE, 6);
gtk_widget_show (priv->spinner);
/* reference the panel in case it is removed before the copy is
* finished */
g_object_ref (panel);
g_object_set_data_full (G_OBJECT (source), "item", g_object_ref (item), g_object_unref);
g_object_set_data (G_OBJECT (source), "settings", settings);
g_file_copy_async (source, dest, G_FILE_COPY_OVERWRITE,
G_PRIORITY_DEFAULT, priv->copy_cancellable,
NULL, NULL,
copy_finished_cb, panel);
g_object_unref (source);
dest_uri = g_file_get_uri (dest);
g_object_unref (dest);
g_settings_set_string (settings, WP_URI_KEY, dest_uri);
g_object_set (G_OBJECT (item),
"uri", dest_uri,
"needs-download", FALSE,
"name", display_name,
NULL);
g_free (display_name);
g_free (dest_uri);
/* delay the updated drawing of the preview until the copy finishes */
save_settings = FALSE;
}
else
{
g_settings_set_string (settings, WP_URI_KEY, uri);
}
/* Also set the placement if we have a URI and the previous value was none */
if (flags & CC_BACKGROUND_ITEM_HAS_PLACEMENT)
{
g_settings_set_enum (settings, WP_OPTIONS_KEY, cc_background_item_get_placement (item));
}
else if (uri != NULL)
{
style = g_settings_get_enum (settings, WP_OPTIONS_KEY);
if (style == G_DESKTOP_BACKGROUND_STYLE_NONE)
g_settings_set_enum (settings, WP_OPTIONS_KEY, cc_background_item_get_placement (item));
}
if (flags & CC_BACKGROUND_ITEM_HAS_SHADING)
g_settings_set_enum (settings, WP_SHADING_KEY, cc_background_item_get_shading (item));
g_settings_set_string (settings, WP_PCOLOR_KEY, cc_background_item_get_pcolor (item));
g_settings_set_string (settings, WP_SCOLOR_KEY, cc_background_item_get_scolor (item));
/* update the preview information */
if (save_settings != FALSE)
{
/* Apply all changes */
g_settings_apply (settings);
/* Save the source XML if there is one */
filename = get_save_path (SAVE_PATH);
if (create_save_dir ())
cc_background_xml_save (CURRENT_BG, filename);
}
}
static void
create_gui(MathDisplay *display)
{
GtkWidget *info_view, *info_box, *main_box;
PangoFontDescription *font_desc;
int i;
GtkStyle *style;
main_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add(GTK_CONTAINER(display), main_box);
g_signal_connect(display, "key-press-event", G_CALLBACK(key_press_cb), display);
display->priv->text_view = gtk_text_view_new_with_buffer(GTK_TEXT_BUFFER(display->priv->equation));
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(display->priv->text_view), GTK_WRAP_WORD);
gtk_text_view_set_accepts_tab(GTK_TEXT_VIEW(display->priv->text_view), FALSE);
gtk_text_view_set_pixels_above_lines(GTK_TEXT_VIEW(display->priv->text_view), 8);
gtk_text_view_set_pixels_below_lines(GTK_TEXT_VIEW(display->priv->text_view), 2);
/* TEMP: Disabled for now as GTK+ doesn't properly render a right aligned right margin, see bug #482688 */
/*gtk_text_view_set_right_margin(GTK_TEXT_VIEW(display->priv->text_view), 6);*/
gtk_text_view_set_justification(GTK_TEXT_VIEW(display->priv->text_view), GTK_JUSTIFY_RIGHT);
gtk_widget_ensure_style(display->priv->text_view);
font_desc = pango_font_description_copy(gtk_widget_get_style(display->priv->text_view)->font_desc);
pango_font_description_set_size(font_desc, 16 * PANGO_SCALE);
gtk_widget_modify_font(display->priv->text_view, font_desc);
pango_font_description_free(font_desc);
gtk_widget_set_name(display->priv->text_view, "displayitem");
atk_object_set_role(gtk_widget_get_accessible(display->priv->text_view), ATK_ROLE_EDITBAR);
//FIXME:<property name="AtkObject::accessible-description" translatable="yes" comments="Accessible description for the area in which results are displayed">Result Region</property>
g_signal_connect(display->priv->text_view, "key-press-event", G_CALLBACK(display_key_press_cb), display);
gtk_box_pack_start(GTK_BOX(main_box), display->priv->text_view, TRUE, TRUE, 0);
info_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start(GTK_BOX(main_box), info_box, FALSE, TRUE, 0);
info_view = gtk_text_view_new();
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(info_view), GTK_WRAP_WORD);
gtk_widget_set_can_focus(info_view, TRUE); // FIXME: This should be FALSE but it locks the cursor inside the main view for some reason
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(info_view), FALSE); // FIXME: Just here so when incorrectly gets focus doesn't look editable
gtk_text_view_set_editable(GTK_TEXT_VIEW(info_view), FALSE);
gtk_text_view_set_justification(GTK_TEXT_VIEW(info_view), GTK_JUSTIFY_RIGHT);
/* TEMP: Disabled for now as GTK+ doesn't properly render a right aligned right margin, see bug #482688 */
/*gtk_text_view_set_right_margin(GTK_TEXT_VIEW(info_view), 6);*/
gtk_box_pack_start(GTK_BOX(info_box), info_view, TRUE, TRUE, 0);
display->priv->info_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(info_view));
display->priv->spinner = gtk_spinner_new();
gtk_box_pack_end(GTK_BOX(info_box), display->priv->spinner, FALSE, FALSE, 0);
style = gtk_widget_get_style(info_view);
for (i = 0; i < 5; i++) {
gtk_widget_modify_bg(GTK_WIDGET(display), i, &style->base[i]);
}
gtk_widget_show(info_box);
gtk_widget_show(info_view);
gtk_widget_show(display->priv->text_view);
gtk_widget_show(main_box);
g_signal_connect(display->priv->equation, "notify::status", G_CALLBACK(status_changed_cb), display);
status_changed_cb(display->priv->equation, NULL, display);
}
static void source_spinner_item_instance_init (SourceSpinnerItem * self) {
self->priv = SOURCE_SPINNER_ITEM_GET_PRIVATE (self);
self->priv->spinner = g_object_ref_sink ((GtkSpinner*) gtk_spinner_new ());
}
