static void
fcitx_wizard_candidate_widget_setup_ui(FcitxWizardCandidateWidget *self)
{
int row = 0;
GtkWidget *cvbox = GTK_WIDGET(self);
GtkWidget *hbox;
GtkWidget *grid = gtk_grid_new();
gtk_widget_set_margin_left(grid, 0);
gtk_widget_set_margin_top(grid, 6);
gtk_grid_set_row_spacing(GTK_GRID(grid), 12);
gtk_grid_set_column_spacing(GTK_GRID(grid), 6);
GtkWidget* label = gtk_label_new(("Candidate Word Number"));
g_object_set(label, "xalign", 0.0f, NULL);
self->candidate_word_number_spin_button = gtk_spin_button_new_with_range(
1, 10, 1.0);
g_object_set(self->candidate_word_number_spin_button, "hexpand", TRUE, NULL);
gtk_grid_attach(GTK_GRID(grid), label, 0, row, 1, 1);
gtk_grid_attach(GTK_GRID(grid), self->candidate_word_number_spin_button, 1,
row, 1, 1);
row ++;
label = gtk_label_new(("Font Size"));
g_object_set(label, "xalign", 0.0f, NULL);
self->font_size_spin_button = gtk_spin_button_new_with_range(
0, 72, 1.0);
g_object_set(self->font_size_spin_button, "hexpand", TRUE, NULL);
gtk_grid_attach(GTK_GRID(grid), label, 0, row, 1, 1);
gtk_grid_attach(GTK_GRID(grid), self->font_size_spin_button, 1,
row, 1, 1);
row ++;
label = gtk_label_new(("Font"));
g_object_set(label, "xalign", 0.0f, NULL);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
self->font_button = gtk_font_button_new();
GtkWidget *button = gtk_button_new_with_label(_("Clear font setting"));
gtk_box_pack_start(GTK_BOX(hbox), self->font_button, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_font_button_set_use_size(GTK_FONT_BUTTON(self->font_button), FALSE);
gtk_font_button_set_show_size(GTK_FONT_BUTTON(self->font_button), FALSE);
g_signal_connect(G_OBJECT(button), "clicked", (GCallback) set_none_font_clicked,
self->font_button);
gtk_grid_attach(GTK_GRID(grid), label, 0, row, 1, 1);
gtk_grid_attach(GTK_GRID(grid), hbox, 1, row, 1, 1);
row ++;
label = gtk_label_new(("Vertical Candidate Word List"));
g_object_set(label, "xalign", 0.0f, NULL);
self->vertical_candidate_button = gtk_check_button_new();
g_object_set(self->vertical_candidate_button, "hexpand", TRUE, NULL);
gtk_grid_attach(GTK_GRID(grid), label, 0, row, 1, 1);
gtk_grid_attach(GTK_GRID(grid), self->vertical_candidate_button, 1, row, 1, 1);
gtk_box_pack_start(GTK_BOX(cvbox), grid, TRUE, TRUE, 0);
fcitx_wizard_candidate_widget_load_conf(self);
g_signal_connect(G_OBJECT(self->candidate_word_number_spin_button), "value-changed",
G_CALLBACK(candidate_word_number_value_changed), self);
g_signal_connect(G_OBJECT(self->font_size_spin_button), "value-changed",
G_CALLBACK(font_size_value_changed), self);
g_signal_connect(G_OBJECT(self->font_button), "font-set",
G_CALLBACK(font_button_font_set), self);
g_signal_connect(G_OBJECT(self->vertical_candidate_button), "toggled",
G_CALLBACK(vertical_candidate_button_toggled), self);
}
int
main (int argc, char **argv)
{
GtkWidget *window, *grid;
GtkWidget *label, *image, *box;
GtkIconTheme *theme;
GdkPixbuf *pixbuf;
GtkIconSet *iconset;
GtkIconSource *iconsource;
gchar *icon_name = "gnome-terminal";
gchar *anim_filename = NULL;
GIcon *icon;
GFile *file;
GdkGeometry geo;
gtk_init (&argc, &argv);
if (argc > 1)
icon_name = argv[1];
if (argc > 2)
anim_filename = argv[2];
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
geo.min_width = 400;
geo.min_height = 300;
geo.max_width = 800;
geo.max_height = 600;
gtk_window_set_geometry_hints (GTK_WINDOW (window), NULL, &geo, GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE);
grid = gtk_grid_new ();
gtk_container_add (GTK_CONTAINER (window), grid);
label = gtk_label_new ("symbolic size");
gtk_grid_attach (GTK_GRID (grid), label, 1, 0, 1, 1);
label = gtk_label_new ("fixed size");
gtk_grid_attach (GTK_GRID (grid), label, 2, 0, 1, 1);
label = gtk_label_new ("GTK_IMAGE_PIXBUF");
gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1);
theme = gtk_icon_theme_get_default ();
pixbuf = gtk_icon_theme_load_icon (theme, icon_name, 48, 0, NULL);
image = gtk_image_new_from_pixbuf (pixbuf);
box = gtk_event_box_new ();
gtk_container_add (GTK_CONTAINER (box), image);
gtk_grid_attach (GTK_GRID (grid), box, 2, 1, 1, 1);
gtk_drag_source_set (box, GDK_BUTTON1_MASK,
NULL, 0,
GDK_ACTION_COPY);
gtk_drag_source_add_image_targets (box);
g_signal_connect (box, "drag_begin", G_CALLBACK (drag_begin), image);
g_signal_connect (box, "drag_data_get", G_CALLBACK (drag_data_get), image);
gtk_drag_dest_set (box,
GTK_DEST_DEFAULT_MOTION |
GTK_DEST_DEFAULT_HIGHLIGHT |
GTK_DEST_DEFAULT_DROP,
NULL, 0, GDK_ACTION_COPY);
gtk_drag_dest_add_image_targets (box);
g_signal_connect (box, "drag_data_received",
G_CALLBACK (drag_data_received), image);
label = gtk_label_new ("GTK_IMAGE_STOCK");
gtk_grid_attach (GTK_GRID (grid), label, 0, 2, 1, 1);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
image = gtk_image_new_from_stock (GTK_STOCK_REDO, GTK_ICON_SIZE_DIALOG);
gtk_grid_attach (GTK_GRID (grid), image, 1, 2, 1, 1);
label = gtk_label_new ("GTK_IMAGE_ICON_SET");
gtk_grid_attach (GTK_GRID (grid), label, 0, 3, 1, 1);
iconsource = gtk_icon_source_new ();
gtk_icon_source_set_icon_name (iconsource, icon_name);
iconset = gtk_icon_set_new ();
gtk_icon_set_add_source (iconset, iconsource);
image = gtk_image_new_from_icon_set (iconset, GTK_ICON_SIZE_DIALOG);
gtk_grid_attach (GTK_GRID (grid), image, 1, 3, 1, 1);
G_GNUC_END_IGNORE_DEPRECATIONS;
label = gtk_label_new ("GTK_IMAGE_ICON_NAME");
gtk_grid_attach (GTK_GRID (grid), label, 0, 4, 1, 1);
image = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_DIALOG);
gtk_grid_attach (GTK_GRID (grid), image, 1, 4, 1, 1);
image = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_DIALOG);
gtk_image_set_pixel_size (GTK_IMAGE (image), 30);
gtk_grid_attach (GTK_GRID (grid), image, 2, 4, 1, 1);
label = gtk_label_new ("GTK_IMAGE_GICON");
gtk_grid_attach (GTK_GRID (grid), label, 0, 5, 1, 1);
icon = g_themed_icon_new_with_default_fallbacks ("folder-remote");
image = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_DIALOG);
g_object_unref (icon);
gtk_grid_attach (GTK_GRID (grid), image, 1, 5, 1, 1);
file = g_file_new_for_path ("apple-red.png");
icon = g_file_icon_new (file);
image = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_DIALOG);
g_object_unref (icon);
gtk_image_set_pixel_size (GTK_IMAGE (image), 30);
gtk_grid_attach (GTK_GRID (grid), image, 2, 5, 1, 1);
if (anim_filename)
{
label = gtk_label_new ("GTK_IMAGE_ANIMATION (from file)");
gtk_grid_attach (GTK_GRID (grid), label, 0, 6, 1, 1);
image = gtk_image_new_from_file (anim_filename);
gtk_image_set_pixel_size (GTK_IMAGE (image), 30);
gtk_grid_attach (GTK_GRID (grid), image, 2, 6, 1, 1);
/* produce high load */
g_signal_connect_after (image, "draw",
G_CALLBACK (anim_image_draw),
NULL);
}
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
/**
* filter_editor_new:
*
* Returns: a new #GtkWidget
*/
GtkWidget *
filter_editor_new (TConnection *tcnc)
{
FilterEditor *feditor;
GtkWidget *grid, *label, *entry;
GdaDataModel *model;
GList *values;
GValue *v1, *v2;
g_return_val_if_fail (T_IS_CONNECTION (tcnc), NULL);
feditor = FILTER_EDITOR (g_object_new (FILTER_EDITOR_TYPE, NULL));
feditor->priv->tcnc = g_object_ref ((GObject*) tcnc);
grid = gtk_grid_new ();
gtk_grid_set_column_spacing (GTK_GRID (grid), 5);
gtk_box_pack_start (GTK_BOX (feditor), grid, TRUE, TRUE, 0);
label = gtk_label_new (_("Base DN:"));
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1);
label = gtk_label_new (_("Filter expression:"));
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1);
label = gtk_label_new (_("Attributes to fetch:"));
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_grid_attach (GTK_GRID (grid), label, 0, 2, 1, 1);
label = gtk_label_new (_("Search scope:"));
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_grid_attach (GTK_GRID (grid), label, 0, 3, 1, 1);
entry = gtk_entry_new ();
gtk_widget_set_hexpand (entry, TRUE);
gtk_grid_attach (GTK_GRID (grid), entry, 1, 0, 1, 1);
feditor->priv->base_dn = entry;
g_signal_connect (entry, "activate",
G_CALLBACK (activated_cb), feditor);
entry = gtk_entry_new ();
gtk_widget_set_hexpand (entry, TRUE);
gtk_grid_attach (GTK_GRID (grid), entry, 1, 1, 1, 1);
feditor->priv->filter = entry;
g_signal_connect (entry, "activate",
G_CALLBACK (activated_cb), feditor);
entry = gtk_entry_new ();
gtk_widget_set_hexpand (entry, TRUE);
gtk_grid_attach (GTK_GRID (grid), entry, 1, 2, 1, 1);
feditor->priv->attributes = entry;
g_signal_connect (entry, "activate",
G_CALLBACK (activated_cb), feditor);
model = gda_data_model_array_new_with_g_types (2, G_TYPE_INT, G_TYPE_STRING);
g_value_set_string ((v1 = gda_value_new (G_TYPE_STRING)), "Base (search the base DN only)");
values = g_list_prepend (NULL, v1);
g_value_set_int ((v2 = gda_value_new (G_TYPE_INT)), GDA_LDAP_SEARCH_BASE);
values = g_list_prepend (values, v2);
g_assert (gda_data_model_append_values (model, values, NULL) >= 0);
gda_value_free (v1);
gda_value_free (v2);
g_value_set_string ((v1 = gda_value_new (G_TYPE_STRING)), "Onelevel (search immediate children of base DN only)");
values = g_list_prepend (NULL, v1);
g_value_set_int ((v2 = gda_value_new (G_TYPE_INT)), GDA_LDAP_SEARCH_ONELEVEL);
values = g_list_prepend (values, v2);
g_assert (gda_data_model_append_values (model, values, NULL) >= 0);
gda_value_free (v1);
gda_value_free (v2);
g_value_set_string ((v1 = gda_value_new (G_TYPE_STRING)), "Subtree (search of the base DN and the entire subtree below)");
values = g_list_prepend (NULL, v1);
g_value_set_int ((v2 = gda_value_new (G_TYPE_INT)), GDA_LDAP_SEARCH_SUBTREE);
values = g_list_prepend (values, v2);
g_assert (gda_data_model_append_values (model, values, NULL) >= 0);
gda_value_free (v1);
gda_value_free (v2);
gint cols[] = {1};
entry = gdaui_combo_new_with_model (model, 1, cols);
gtk_widget_set_hexpand (entry, TRUE);
g_object_unref (model);
gtk_grid_attach (GTK_GRID (grid), entry, 1, 3, 1, 1);
feditor->priv->scope = entry;
filter_editor_clear (feditor);
gtk_widget_show_all (grid);
return (GtkWidget*) feditor;
}
static void ugtk_download_form_init_page2 (UgtkDownloadForm* dform)
{
GtkWidget* widget;
GtkGrid* grid;
dform->page2 = gtk_grid_new ();
grid = (GtkGrid*) dform->page2;
gtk_container_set_border_width (GTK_CONTAINER (grid), 2);
// label - cookie file
widget = gtk_label_new (_("Cookie file:"));
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5); // left, center
g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (grid, widget, 0, 0, 1, 1);
dform->cookie_label = widget;
// entry - cookie file
widget = gtk_entry_new ();
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
#if GTK_MAJOR_VERSION >= 3 && GTK_MINOR_VERSION >= 10
gtk_entry_set_icon_from_icon_name (GTK_ENTRY (widget),
GTK_ENTRY_ICON_SECONDARY, "text-x-generic");
#else
gtk_entry_set_icon_from_stock (GTK_ENTRY (widget),
GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_FILE);
#endif
gtk_entry_set_icon_tooltip_text (GTK_ENTRY (widget),
GTK_ENTRY_ICON_SECONDARY, _("Select Cookie File"));
g_object_set (widget, "margin", 1, "hexpand", TRUE, NULL);
gtk_grid_attach (grid, widget, 1, 0, 3, 1);
g_signal_connect (widget, "icon-release",
G_CALLBACK (on_select_cookie), dform);
g_signal_connect (GTK_EDITABLE (widget), "changed",
G_CALLBACK (on_http_entry_changed), dform);
dform->cookie_entry = widget;
// label - post file
widget = gtk_label_new (_("Post file:"));
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5); // left, center
g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (grid, widget, 0, 1, 1, 1);
dform->post_label = widget;
// entry - post file
widget = gtk_entry_new ();
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
#if GTK_MAJOR_VERSION >= 3 && GTK_MINOR_VERSION >= 10
gtk_entry_set_icon_from_icon_name (GTK_ENTRY (widget),
GTK_ENTRY_ICON_SECONDARY, "text-x-generic");
#else
gtk_entry_set_icon_from_stock (GTK_ENTRY (widget),
GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_FILE);
#endif
gtk_entry_set_icon_tooltip_text (GTK_ENTRY (widget),
GTK_ENTRY_ICON_SECONDARY, _("Select Post File"));
g_object_set (widget, "margin", 1, "hexpand", TRUE, NULL);
gtk_grid_attach (grid, widget, 1, 1, 3, 1);
g_signal_connect (widget, "icon-release",
G_CALLBACK (on_select_post), dform);
g_signal_connect (GTK_EDITABLE (widget), "changed",
G_CALLBACK (on_http_entry_changed), dform);
dform->post_entry = widget;
// label - user agent
widget = gtk_label_new (_("User Agent:"));
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5); // left, center
g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (grid, widget, 0, 2, 1, 1);
dform->agent_label = widget;
// entry - user agent
widget = gtk_entry_new ();
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
g_object_set (widget, "margin", 1, "hexpand", TRUE, NULL);
gtk_grid_attach (grid, widget, 1, 2, 3, 1);
g_signal_connect (GTK_EDITABLE (widget), "changed",
G_CALLBACK (on_http_entry_changed), dform);
dform->agent_entry = widget;
// Retry limit - label
widget = gtk_label_new_with_mnemonic (_("Retry _limit:"));
gtk_label_set_mnemonic_widget (GTK_LABEL (widget), dform->spin_retry);
g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (grid, widget, 0, 3, 2, 1);
// Retry limit - spin button
widget = gtk_spin_button_new_with_range (0.0, 99.0, 1.0);
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (grid, widget, 2, 3, 1, 1);
g_signal_connect (GTK_EDITABLE (widget), "changed",
G_CALLBACK (on_spin_changed), dform);
dform->spin_retry = widget;
// counts - label
widget = gtk_label_new (_("counts"));
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5);
g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (grid, widget, 3, 3, 1, 1);
// Retry delay - label
widget = gtk_label_new_with_mnemonic (_("Retry _delay:"));
gtk_label_set_mnemonic_widget (GTK_LABEL (widget), dform->spin_delay);
g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (grid, widget, 0, 4, 2, 1);
// Retry delay - spin button
widget = gtk_spin_button_new_with_range (0.0, 600.0, 1.0);
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (grid, widget, 2, 4, 1, 1);
g_signal_connect (GTK_EDITABLE (widget), "changed",
G_CALLBACK (on_spin_changed), dform);
dform->spin_delay = widget;
// seconds - label
widget = gtk_label_new (_("seconds"));
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5);
g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (grid, widget, 3, 4, 1, 1);
// label - Max upload speed
widget = gtk_label_new (_("Max upload speed:"));
g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (grid, widget, 0, 5, 2, 1);
// spin - Max upload speed
widget = gtk_spin_button_new_with_range (0, 99999999, 1);
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
gtk_entry_set_width_chars (GTK_ENTRY (widget), 8);
g_object_set (widget, "margin", 1, NULL);
gtk_grid_attach (grid, widget, 2, 5, 1, 1);
dform->spin_upload_speed = (GtkSpinButton*) widget;
// label - "KiB/s"
widget = gtk_label_new (_("KiB/s"));
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5); // left, center
g_object_set (widget, "margin", 2, "hexpand", TRUE, NULL);
gtk_grid_attach (grid, widget, 3, 5, 1, 1);
// label - Max download speed
widget = gtk_label_new (_("Max download speed:"));
g_object_set (widget, "margin-left", 2, "margin-right", 2, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (grid, widget, 0, 6, 2, 1);
// spin - Max download speed
widget = gtk_spin_button_new_with_range (0, 99999999, 1);
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
gtk_entry_set_width_chars (GTK_ENTRY (widget), 8);
g_object_set (widget, "margin", 1, NULL);
gtk_grid_attach (grid, widget, 2, 6, 1, 1);
dform->spin_download_speed = (GtkSpinButton*) widget;
// label - "KiB/s"
widget = gtk_label_new (_("KiB/s"));
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5); // left, center
g_object_set (widget, "margin", 2, "hexpand", TRUE, NULL);
gtk_grid_attach (grid, widget, 3, 6, 1, 1);
// Retrieve timestamp
widget = gtk_check_button_new_with_label (_("Retrieve timestamp"));
gtk_grid_attach (grid, widget, 0, 7, 3, 1);
dform->timestamp = (GtkToggleButton*) widget;
}
static void
cc_sharing_panel_setup_media_sharing_dialog (CcSharingPanel *self)
{
CcSharingPanelPrivate *priv = self->priv;
gchar **folders, **list;
GtkWidget *box, *networks, *grid, *w;
char *path;
path = g_find_program_in_path ("rygel");
if (path == NULL)
{
gtk_widget_hide (WID ("media-sharing-button"));
return;
}
g_free (path);
g_signal_connect (WID ("media-sharing-dialog"), "response",
G_CALLBACK (cc_sharing_panel_media_sharing_dialog_response),
self);
cc_media_sharing_get_preferences (&folders);
box = WID ("shared-folders-listbox");
gtk_list_box_set_header_func (GTK_LIST_BOX (box),
cc_list_box_update_header_func, NULL,
NULL);
cc_list_box_setup_scrolling (GTK_LIST_BOX (box), 3);
list = folders;
while (list && *list)
{
GtkWidget *row;
row = cc_sharing_panel_new_media_sharing_row (*list, self);
gtk_list_box_insert (GTK_LIST_BOX (box), row, -1);
list++;
}
gtk_list_box_insert (GTK_LIST_BOX (box),
cc_sharing_panel_new_add_media_sharing_row (self), -1);
cc_list_box_adjust_scrolling (GTK_LIST_BOX (box));
g_signal_connect (G_OBJECT (box), "row-activated",
G_CALLBACK (cc_sharing_panel_add_folder), self);
g_strfreev (folders);
networks = cc_sharing_networks_new (self->priv->sharing_proxy, "rygel");
grid = WID ("grid4");
gtk_grid_attach (GTK_GRID (grid), networks, 0, 4, 2, 1);
gtk_widget_show (networks);
w = cc_sharing_switch_new (networks);
gtk_header_bar_pack_start (GTK_HEADER_BAR (WID ("media-sharing-headerbar")), w);
self->priv->media_sharing_switch = w;
cc_sharing_panel_bind_networks_to_label (self, networks,
WID ("media-sharing-status-label"));
}
void
create_study_screen (){
GtkWidget *grid;
GtkWidget *instruction_label;
GtkWidget *text;
/* Here we construct the container that is going pack our buttons */
grid = gtk_grid_new ();
gtk_grid_set_column_homogeneous (GTK_GRID (grid), TRUE);
gtk_container_set_border_width (GTK_CONTAINER (grid), 15);
GtkWidget *frame = gtk_frame_new ("");
add_screen_onto_gtk_stack(frame, "study_screen");
gtk_widget_set_halign (frame,GTK_ALIGN_CENTER);
gtk_widget_set_valign (frame,GTK_ALIGN_CENTER);
gtk_container_set_border_width (GTK_CONTAINER (frame), 15);
gtk_container_add (GTK_CONTAINER (frame), grid);
const int margin = 5;
/* create label */
instruction_label = gtk_label_new ("click next to begin");
gtk_grid_attach (GTK_GRID (grid), instruction_label, 0, 0, 2, 1);
/*Create a new entry box, and add it to the window*/
GtkWidget *frame2 = gtk_frame_new ("");
gtk_widget_set_margin_bottom (frame2, margin);
gtk_grid_attach (GTK_GRID (grid), frame2, 0, 1, 2, 1);
text = gtk_label_new ("");
gtk_widget_set_name (text, "large_text_200");
gtk_widget_set_margin_bottom (text, margin*3);
gtk_widget_set_size_request (text, 400 , -1);
gtk_container_add (GTK_CONTAINER (frame2), text);
info = malloc (sizeof (study_screen_info));
/* create button */
GtkWidget *button1;
button1 = gtk_button_new_with_label ("Previous");
gtk_grid_attach (GTK_GRID (grid), button1, 0, 2, 1, 1);
g_signal_connect (GTK_BUTTON (button1), "clicked",
G_CALLBACK (on_previous), NULL);
GtkWidget *button2;
button2 = gtk_button_new_with_label ("Next");
gtk_grid_attach (GTK_GRID (grid), button2, 1, 2, 1, 1);
g_signal_connect (GTK_BUTTON (button2), "clicked",
G_CALLBACK (on_next), info);
info->current = 0;
info->instruction_label = instruction_label;
info->text = text;
info->previous_button = button1;
info->next_button = button2;
// gtk_widget_show_all (grid);
}
//Connect popup, no cancel button and not always in front
extern void popup_connect(const char *msg)
{
GtkWidget *dialog_content_area = NULL,
*msg_label = NULL,
*addr_grid = NULL,
*addr_label = NULL,
*address_entry_field = NULL,
*port_grid = NULL,
*port_label = NULL,
*port_entry_field = NULL;
/*dialog*/
dialog_connect = gtk_dialog_new();
gtk_window_set_title(GTK_WINDOW(dialog_connect), "Connect to server");
//set it to transient (belongs to window below, may not outlast it and is always on top)
gtk_window_set_transient_for(GTK_WINDOW(dialog_connect), GTK_WINDOW(window) );
dialog_content_area = gtk_dialog_get_content_area(GTK_DIALOG(dialog_connect));
/*message label*/
msg_label = gtk_label_new(msg);
/*address grid*/
addr_grid = gtk_grid_new();
gtk_grid_set_column_spacing(GTK_GRID(addr_grid), 10);
/*address label*/
addr_label = gtk_label_new("Address:");
gtk_widget_set_hexpand(addr_label, TRUE);
gtk_widget_set_halign(addr_label, GTK_ALIGN_START);
/*address entry*/
address_entry_field = gtk_entry_new();
/*port grid*/
port_grid = gtk_grid_new();
gtk_grid_set_column_spacing(GTK_GRID(port_grid), 10);
/*port label*/
port_label = gtk_label_new("Port:");
gtk_widget_set_hexpand(port_label, TRUE);
gtk_widget_set_halign(port_label, GTK_ALIGN_START);
/*port entry*/
port_entry_field = gtk_entry_new();
gtk_entry_set_input_purpose(GTK_ENTRY(port_entry_field), GTK_INPUT_PURPOSE_DIGITS); //help the onscreen keyboards
/*pack message and address and port inputs*/
gtk_box_pack_start( GTK_BOX(dialog_content_area), msg_label, FALSE, FALSE, 0 );
gtk_grid_attach(GTK_GRID(addr_grid), addr_label, 0, 0, 1, 1);
gtk_grid_attach(GTK_GRID(addr_grid), address_entry_field, 1, 0, 1, 1);
gtk_box_pack_start( GTK_BOX(dialog_content_area), addr_grid, FALSE, FALSE, 0 );
gtk_grid_attach(GTK_GRID(port_grid), port_label, 0, 0, 1, 1);
gtk_grid_attach(GTK_GRID(port_grid), port_entry_field, 1, 0, 1, 1);
gtk_box_pack_start( GTK_BOX(dialog_content_area), port_grid, FALSE, FALSE, 0 );
gtk_dialog_add_button( GTK_DIALOG(dialog_connect), "Connect", GTK_RESPONSE_OK );
/*connect the "response" signal*/
g_signal_connect( GTK_DIALOG(dialog_connect), "response", G_CALLBACK(connect_cb), NULL);
g_signal_connect_swapped( GTK_DIALOG(dialog_connect), "response", G_CALLBACK(gtk_widget_destroy), dialog_connect);
//show
gtk_widget_show(msg_label);
gtk_widget_show(addr_grid);
gtk_widget_show(addr_label);
gtk_widget_show(address_entry_field);
gtk_widget_show(port_grid);
gtk_widget_show(port_label);
gtk_widget_show(port_entry_field);
gtk_widget_show(dialog_connect);
//we no longer need the pointer to the dialog, the callbacks have it if they need it
dialog_connect = NULL;
return;
}
static void
empathy_local_xmpp_assistant_widget_constructed (GObject *object)
{
EmpathyLocalXmppAssistantWidget *self = (EmpathyLocalXmppAssistantWidget *)
object;
GtkWidget *w;
GdkPixbuf *pix;
TpawAccountWidget *account_widget;
gchar *markup;
G_OBJECT_CLASS (empathy_local_xmpp_assistant_widget_parent_class)->
constructed (object);
gtk_container_set_border_width (GTK_CONTAINER (self), 12);
w = gtk_label_new (
_("Empathy can automatically discover and chat with the people "
"connected on the same network as you. "
"If you want to use this feature, please check that the "
"details below are correct."));
gtk_misc_set_alignment (GTK_MISC (w), 0, 0.5);
gtk_label_set_line_wrap (GTK_LABEL (w), TRUE);
gtk_label_set_max_width_chars (GTK_LABEL (w), 60);
gtk_grid_attach (GTK_GRID (self), w, 0, 0, 1, 1);
gtk_widget_show (w);
pix = tpaw_pixbuf_from_icon_name_sized ("im-local-xmpp", 48);
if (pix != NULL)
{
w = gtk_image_new_from_pixbuf (pix);
gtk_grid_attach (GTK_GRID (self), w, 1, 0, 1, 1);
gtk_widget_show (w);
g_object_unref (pix);
}
self->priv->settings = tpaw_account_settings_new ("salut", "local-xmpp",
NULL, _("People nearby"));
account_widget = tpaw_account_widget_new_for_protocol (
self->priv->settings, NULL, TRUE);
tpaw_account_widget_hide_buttons (account_widget);
g_signal_connect (account_widget, "handle-apply",
G_CALLBACK (handle_apply_cb), self);
gtk_grid_attach (GTK_GRID (self), GTK_WIDGET (account_widget), 0, 1, 2, 1);
gtk_widget_show (GTK_WIDGET (account_widget));
w = gtk_label_new (NULL);
markup = g_strdup_printf (
"<span size=\"small\">%s</span>",
_("You can change these details later or disable this feature "
"by choosing <span style=\"italic\">Edit → Accounts</span> "
"in the Contact List."));
gtk_label_set_markup (GTK_LABEL (w), markup);
g_free (markup);
gtk_misc_set_alignment (GTK_MISC (w), 0, 0.5);
gtk_label_set_line_wrap (GTK_LABEL (w), TRUE);
gtk_grid_attach (GTK_GRID (self), w, 0, 2, 2, 1);
gtk_widget_show (w);
}
gint
main (gint argc,
gchar ** argv)
{
GtkWidget *window, *revealer, *box, *widget, *entry;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request (window, 300, 300);
box = gtk_grid_new ();
gtk_container_add (GTK_CONTAINER (window), box);
widget = gtk_label_new ("Some filler text just to avoid\nresizing of the window");
gtk_widget_set_margin_top (widget, 10);
gtk_widget_set_margin_bottom (widget, 10);
gtk_widget_set_margin_start (widget, 10);
gtk_widget_set_margin_end (widget, 10);
gtk_grid_attach (GTK_GRID (box), widget, 1, 1, 1, 1);
widget = gtk_label_new ("Some filler text just to avoid\nresizing of the window");
gtk_widget_set_margin_top (widget, 10);
gtk_widget_set_margin_bottom (widget, 10);
gtk_widget_set_margin_start (widget, 10);
gtk_widget_set_margin_end (widget, 10);
gtk_grid_attach (GTK_GRID (box), widget, 3, 3, 1, 1);
widget = gtk_toggle_button_new_with_label ("None");
gtk_grid_attach (GTK_GRID (box), widget, 0, 0, 1, 1);
revealer = gtk_revealer_new ();
gtk_widget_set_halign (revealer, GTK_ALIGN_START);
gtk_widget_set_valign (revealer, GTK_ALIGN_START);
entry = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (entry), "00000");
gtk_container_add (GTK_CONTAINER (revealer), entry);
g_object_bind_property (widget, "active", revealer, "reveal-child", 0);
gtk_revealer_set_transition_type (GTK_REVEALER (revealer), GTK_REVEALER_TRANSITION_TYPE_NONE);
gtk_revealer_set_transition_duration (GTK_REVEALER (revealer), 2000);
gtk_grid_attach (GTK_GRID (box), revealer, 1, 0, 1, 1);
widget = gtk_toggle_button_new_with_label ("Fade");
gtk_grid_attach (GTK_GRID (box), widget, 4, 4, 1, 1);
revealer = gtk_revealer_new ();
gtk_widget_set_halign (revealer, GTK_ALIGN_END);
gtk_widget_set_valign (revealer, GTK_ALIGN_END);
entry = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (entry), "00000");
gtk_container_add (GTK_CONTAINER (revealer), entry);
g_object_bind_property (widget, "active", revealer, "reveal-child", 0);
gtk_revealer_set_transition_type (GTK_REVEALER (revealer), GTK_REVEALER_TRANSITION_TYPE_CROSSFADE);
gtk_revealer_set_transition_duration (GTK_REVEALER (revealer), 2000);
gtk_grid_attach (GTK_GRID (box), revealer, 3, 4, 1, 1);
widget = gtk_toggle_button_new_with_label ("Right");
gtk_grid_attach (GTK_GRID (box), widget, 0, 2, 1, 1);
revealer = gtk_revealer_new ();
gtk_widget_set_hexpand (revealer, TRUE);
gtk_widget_set_halign (revealer, GTK_ALIGN_START);
entry = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (entry), "12345");
gtk_container_add (GTK_CONTAINER (revealer), entry);
g_object_bind_property (widget, "active", revealer, "reveal-child", 0);
gtk_revealer_set_transition_type (GTK_REVEALER (revealer), GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT);
gtk_revealer_set_transition_duration (GTK_REVEALER (revealer), 2000);
gtk_grid_attach (GTK_GRID (box), revealer, 1, 2, 1, 1);
widget = gtk_toggle_button_new_with_label ("Down");
gtk_grid_attach (GTK_GRID (box), widget, 2, 0, 1, 1);
revealer = gtk_revealer_new ();
gtk_widget_set_vexpand (revealer, TRUE);
gtk_widget_set_valign (revealer, GTK_ALIGN_START);
entry = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (entry), "23456");
gtk_container_add (GTK_CONTAINER (revealer), entry);
g_object_bind_property (widget, "active", revealer, "reveal-child", 0);
gtk_revealer_set_transition_type (GTK_REVEALER (revealer), GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN);
gtk_revealer_set_transition_duration (GTK_REVEALER (revealer), 2000);
gtk_grid_attach (GTK_GRID (box), revealer, 2, 1, 1, 1);
widget = gtk_toggle_button_new_with_label ("Left");
gtk_grid_attach (GTK_GRID (box), widget, 4, 2, 1, 1);
revealer = gtk_revealer_new ();
gtk_widget_set_hexpand (revealer, TRUE);
gtk_widget_set_halign (revealer, GTK_ALIGN_END);
entry = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (entry), "34567");
gtk_container_add (GTK_CONTAINER (revealer), entry);
g_object_bind_property (widget, "active", revealer, "reveal-child", 0);
gtk_revealer_set_transition_type (GTK_REVEALER (revealer), GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT);
gtk_revealer_set_transition_duration (GTK_REVEALER (revealer), 2000);
gtk_grid_attach (GTK_GRID (box), revealer, 3, 2, 1, 1);
widget = gtk_toggle_button_new_with_label ("Up");
gtk_grid_attach (GTK_GRID (box), widget, 2, 4, 1, 1);
revealer = gtk_revealer_new ();
gtk_widget_set_vexpand (revealer, TRUE);
gtk_widget_set_valign (revealer, GTK_ALIGN_END);
entry = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (entry), "45678");
gtk_container_add (GTK_CONTAINER (revealer), entry);
g_object_bind_property (widget, "active", revealer, "reveal-child", 0);
gtk_revealer_set_transition_type (GTK_REVEALER (revealer), GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP);
gtk_revealer_set_transition_duration (GTK_REVEALER (revealer), 2000);
gtk_grid_attach (GTK_GRID (box), revealer, 2, 3, 1, 1);
gtk_widget_show_all (window);
gtk_main ();
gtk_widget_destroy (window);
return 0;
}
/**
* browser_connections_list_show
* @current: (allow-none): a connection to select for displaed properties, or %NULL
*
* Creates a new #BrowserConnectionsList widget and displays it.
* Only one is created and shown (singleton)
*
* Returns: the new object
*/
void
browser_connections_list_show (BrowserConnection *current)
{
if (!_clist) {
GtkWidget *clist, *sw, *grid, *treeview, *label, *wid;
gchar *str;
clist = GTK_WIDGET (g_object_new (BROWSER_TYPE_CONNECTIONS_LIST,
NULL));
gtk_window_set_default_size ((GtkWindow*) clist, 550, 450);
_clist = (BrowserConnectionsList *) clist;
gtk_window_set_title (GTK_WINDOW (clist), _("Opened connections"));
gtk_container_set_border_width (GTK_CONTAINER (clist), 6);
g_signal_connect (G_OBJECT (clist), "delete-event",
G_CALLBACK (delete_event), NULL);
str = gda_gbr_get_file_path (GDA_DATA_DIR, LIBGDA_ABI_NAME, "pixmaps", "gda-browser-connected.png", NULL);
gtk_window_set_icon_from_file (GTK_WINDOW (clist), str, NULL);
g_free (str);
/* table layout */
grid = gtk_grid_new ();
gtk_grid_set_column_spacing (GTK_GRID (grid), 10);
gtk_grid_set_row_spacing (GTK_GRID (grid), 6);
gtk_container_add (GTK_CONTAINER (clist), grid);
_clist->priv->layout_grid = GTK_GRID (grid);
/* image and explaining label */
GtkWidget *hbox;
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_grid_attach (GTK_GRID (grid), hbox, 0, 0, 3, 1);
str = gda_gbr_get_file_path (GDA_DATA_DIR, LIBGDA_ABI_NAME, "pixmaps", "gda-browser-connected-big.png", NULL);
wid = gtk_image_new_from_file (str);
g_free (str);
gtk_box_pack_start (GTK_BOX (hbox), wid, FALSE, FALSE, 0);
wid = gtk_label_new ("");
str = g_strdup_printf ("<big><b>%s:\n</b></big>%s",
_("List of opened connections"),
"The connection properties are read-only.");
gtk_label_set_markup (GTK_LABEL (wid), str);
g_free (str);
gtk_misc_set_alignment (GTK_MISC (wid), 0., -1);
gtk_box_pack_start (GTK_BOX (hbox), wid, TRUE, FALSE, 6);
/* left column */
label = gtk_label_new ("");
str = g_strdup_printf ("<b>%s:</b>", _("Connections"));
gtk_label_set_markup (GTK_LABEL (label), str);
g_free (str);
gtk_misc_set_alignment (GTK_MISC (label), 0., -1);
gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_grid_attach (GTK_GRID (grid), sw, 0, 2, 1, 2);
/* connection's properties */
label = gtk_label_new ("");
str = g_strdup_printf ("<b>%s:</b>", _("Connection's properties"));
gtk_label_set_markup (GTK_LABEL (label), str);
g_free (str);
gtk_misc_set_alignment (GTK_MISC (label), 0., -1);
gtk_grid_attach (GTK_GRID (grid), label, 1, 1, 1, 1);
/* buttons at the bottom*/
GtkWidget *bbox, *button;
bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_grid_attach (GTK_GRID (grid), bbox, 1, 3, 1, 1);
gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_END);
button = gtk_button_new_with_label (_("Close connection"));
gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
g_signal_connect (button, "clicked",
G_CALLBACK (connection_close_cb), clist);
gtk_widget_set_tooltip_text (button, _("Close selected connection"));
_clist->priv->close_cnc_button = button;
button = gtk_button_new_with_label (_("Connect"));
gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
g_signal_connect (button, "clicked",
G_CALLBACK (connection_new_cb), clist);
gtk_widget_set_tooltip_text (button, _("Open a new connection"));
/* GtkTreeModel and view */
GtkListStore *store;
store = gtk_list_store_new (NUM_COLUMNS,
BROWSER_TYPE_CONNECTION);
treeview = browser_make_tree_view (GTK_TREE_MODEL (store));
_clist->priv->treeview = GTK_TREE_VIEW (treeview);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview), TRUE);
g_object_unref (G_OBJECT (store));
gtk_container_add (GTK_CONTAINER (sw), treeview);
/* treeview's columns */
GtkTreeViewColumn *col;
GtkCellRenderer *cell;
cell = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new ();
gtk_tree_view_column_pack_start (col, cell, TRUE);
gtk_tree_view_column_set_cell_data_func (col, cell,
(GtkTreeCellDataFunc) cell_name_data_func, NULL, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), col);
/* selection handling */
GtkTreeSelection *select;
select = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE);
g_signal_connect (G_OBJECT (select), "changed",
G_CALLBACK (selection_changed_cb), clist);
/* initial filling */
GSList *connections, *list;
connections = browser_core_get_connections ();
for (list = connections; list; list = list->next)
connection_added_cb (browser_core_get(), BROWSER_CONNECTION (list->data),
(BrowserConnectionsList*) clist);
g_slist_free (connections);
_clist->priv->cnc_added_sigid = g_signal_connect (browser_core_get (), "connection-added",
G_CALLBACK (connection_added_cb), _clist);
_clist->priv->cnc_removed_sigid = g_signal_connect (browser_core_get (), "connection-removed",
G_CALLBACK (connection_removed_cb), _clist);
gtk_widget_show_all (clist);
}
else {
gtk_window_set_screen (GTK_WINDOW (_clist), gdk_screen_get_default ()); /* FIXME: specify GdkScreen */
gtk_window_present (GTK_WINDOW (_clist));
}
if (current) {
GtkTreeModel *model;
GtkTreeIter iter;
model = gtk_tree_view_get_model (GTK_TREE_VIEW (_clist->priv->treeview));
if (gtk_tree_model_get_iter_first (model, &iter)) {
do {
BrowserConnection *bcnc;
gtk_tree_model_get (model, &iter, COLUMN_BCNC, &bcnc, -1);
g_object_unref (bcnc);
if (bcnc == current) {
GtkTreeSelection *select;
select = gtk_tree_view_get_selection (GTK_TREE_VIEW (_clist->priv->treeview));
gtk_tree_selection_select_iter (select, &iter);
break;
}
} while (gtk_tree_model_iter_next (model, &iter));
}
}
else {
/* select the 1st available */
GtkTreeModel *model;
GtkTreeIter iter;
model = gtk_tree_view_get_model (GTK_TREE_VIEW (_clist->priv->treeview));
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (model), &iter)) {
GtkTreeSelection *select;
select = gtk_tree_view_get_selection (GTK_TREE_VIEW (_clist->priv->treeview));
gtk_tree_selection_select_iter (select, &iter);
}
}
}
static gboolean
set_tooltip_widget_from_marks (GtkSourceView *view,
GtkTooltip *tooltip,
GSList *marks)
{
GtkGrid *grid = NULL;
gint row_num = 0;
gint icon_size;
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, NULL, &icon_size);
for (; marks; marks = g_slist_next (marks))
{
const gchar *category;
GtkSourceMark *mark;
GtkSourceMarkAttributes *attrs;
gchar *text;
gboolean ismarkup = FALSE;
GtkWidget *label;
const GdkPixbuf *pixbuf;
mark = marks->data;
category = gtk_source_mark_get_category (mark);
attrs = gtk_source_view_get_mark_attributes (view, category, NULL);
if (attrs == NULL)
{
continue;
}
text = gtk_source_mark_attributes_get_tooltip_markup (attrs, mark);
if (text == NULL)
{
text = gtk_source_mark_attributes_get_tooltip_text (attrs, mark);
}
else
{
ismarkup = TRUE;
}
if (text == NULL)
{
continue;
}
if (grid == NULL)
{
grid = GTK_GRID (gtk_grid_new ());
gtk_grid_set_column_spacing (grid, 4);
gtk_widget_show (GTK_WIDGET (grid));
}
label = gtk_label_new (NULL);
if (ismarkup)
{
gtk_label_set_markup (GTK_LABEL (label), text);
}
else
{
gtk_label_set_text (GTK_LABEL (label), text);
}
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_valign (label, GTK_ALIGN_START);
gtk_widget_show (label);
pixbuf = gtk_source_mark_attributes_render_icon (attrs,
GTK_WIDGET (view),
icon_size);
if (pixbuf == NULL)
{
gtk_grid_attach (grid, label, 0, row_num, 2, 1);
}
else
{
GtkWidget *image;
GdkPixbuf *copy;
/* FIXME why a copy is needed? */
copy = gdk_pixbuf_copy (pixbuf);
image = gtk_image_new_from_pixbuf (copy);
g_object_unref (copy);
gtk_widget_set_halign (image, GTK_ALIGN_START);
gtk_widget_set_valign (image, GTK_ALIGN_START);
gtk_widget_show (image);
gtk_grid_attach (grid, image, 0, row_num, 1, 1);
gtk_grid_attach (grid, label, 1, row_num, 1, 1);
}
row_num++;
if (marks->next != NULL)
{
GtkWidget *separator;
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_widget_show (separator);
gtk_grid_attach (grid, separator, 0, row_num, 2, 1);
row_num++;
}
g_free (text);
}
if (grid == NULL)
{
return FALSE;
}
gtk_tooltip_set_custom (tooltip, GTK_WIDGET (grid));
return TRUE;
}
static void
selection_changed_cb (GtkTreeSelection *select, BrowserConnectionsList *clist)
{
GtkTreeModel *model;
GtkTreeIter iter;
BrowserConnection *bcnc = NULL;
const GdaDsnInfo *cncinfo = NULL;
if (gtk_tree_selection_get_selected (select, &model, &iter)) {
gtk_tree_model_get (model, &iter, COLUMN_BCNC, &bcnc, -1);
cncinfo = browser_connection_get_information (bcnc);
g_object_unref (bcnc);
gtk_widget_set_sensitive (_clist->priv->close_cnc_button, TRUE);
}
else
gtk_widget_set_sensitive (_clist->priv->close_cnc_button, FALSE);
if (clist->priv->cnc_params_editor) {
gtk_widget_destroy (clist->priv->cnc_params_editor);
clist->priv->cnc_params_editor = NULL;
}
if (cncinfo && cncinfo->provider) {
/* create GdaSet for parameters to display */
GdaSet *dset;
GdaHolder *holder;
dset = gda_set_new_inline (1, "PROVIDER_NAME", G_TYPE_STRING, cncinfo->provider);
holder = GDA_HOLDER (dset->holders->data);
g_object_set (G_OBJECT (holder), "name", _("Database provider"), NULL);
GdaProviderInfo *pinfo;
pinfo = gda_config_get_provider_info (cncinfo->provider);
if (pinfo && pinfo->dsn_params)
gda_set_merge_with_set (dset, pinfo->dsn_params);
holder = gda_holder_new_inline (G_TYPE_STRING, "GDA_BROWSER_DICT_FILE", _("In memory"));
g_object_set (G_OBJECT (holder),
"name", _("Dictionary file"),
"description", _("File used to store any information associated\n"
"to this connection (favorites, descriptions, ...)"), NULL);
gda_set_add_holder (dset, holder);
g_object_unref (holder);
if (bcnc) {
const gchar *dict_file_name;
dict_file_name = browser_connection_get_dictionary_file (bcnc);
if (dict_file_name)
gda_set_set_holder_value (dset, NULL, "GDA_BROWSER_DICT_FILE",
dict_file_name);
}
/* create form */
GtkWidget *wid;
wid = gdaui_basic_form_new (dset);
g_object_set ((GObject*) wid, "show-actions", FALSE, NULL);
gdaui_basic_form_entry_set_editable (GDAUI_BASIC_FORM (wid), NULL, FALSE);
gtk_grid_attach (clist->priv->layout_grid, wid, 1, 2, 1, 1);
gtk_widget_show (wid);
clist->priv->cnc_params_editor = wid;
/* fill GdaSet's parameters with values */
if (cncinfo->cnc_string) {
gchar **array = NULL;
array = g_strsplit (cncinfo->cnc_string, ";", 0);
if (array) {
gint index = 0;
gchar *tok;
gchar *value;
gchar *name;
for (index = 0; array[index]; index++) {
name = strtok_r (array [index], "=", &tok);
if (name)
value = strtok_r (NULL, "=", &tok);
else
value = NULL;
if (name && value) {
GdaHolder *param;
gda_rfc1738_decode (name);
gda_rfc1738_decode (value);
param = gda_set_get_holder (dset, name);
if (param)
g_assert (gda_holder_set_value_str (param, NULL, value, NULL));
}
}
g_strfreev (array);
}
}
g_object_unref (dset);
}
}
GtkWidget *
ptp_simulator_packet_detail_new(void)
{
GtkWidget *grid;
GtkWidget *label;
GtkWidget *frame;
GtkWidget *subgrid;
GdkColor color;
grid = g_object_new(PTP_SIMULATOR_TYPE_PACKET_DETAIL, NULL);
gtk_container_set_border_width(GTK_CONTAINER(grid), 20);
//g_object_set(grid, "margin", 12, NULL);
//gtk_grid_set_row_spacing(GTK_GRID(grid), 6);
/*
gtk_widget_set_halign(label, GTK_ALIGN_START);
gtk_widget_set_valign(label, GTK_ALIGN_START);
g_object_set(label, "margin-left", 24, NULL);
g_object_set(label, "margin-right", 12, NULL);
//g_object_set(label, "expand", TRUE, NULL);
gdk_color_parse("red", &color); //setting a color - you can also use RGB
gtk_widget_modify_bg(label, GTK_STATE_NORMAL, &color); //modifying the background color of the widget
//gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &color); //modifying the background color of the widget
gtk_grid_attach(GTK_GRID(grid), label, 0, 0, 1, 1);
*/
/*
gtk_widget_set_halign(label, GTK_ALIGN_START);
gtk_widget_set_valign(label, GTK_ALIGN_START);
g_object_set(label, "margin-left", 24, NULL);
g_object_set(label, "margin-right", 12, NULL);
//g_object_set(label, "expand", TRUE, NULL);
gdk_color_parse("blue", &color); //setting a color - you can also use RGB
gtk_widget_modify_bg(label, GTK_STATE_NORMAL, &color); //modifying the background color of the widget
gtk_grid_attach(GTK_GRID(grid), label, 0, 1, 1, 1);
*/
frame = gtk_frame_new("Layer 2");
g_object_set(frame, "expand", TRUE, NULL);
subgrid = gtk_grid_new();
gtk_container_add(GTK_CONTAINER(frame), subgrid);
label = gtk_label_new("Detail 1");
gtk_grid_attach(GTK_GRID(subgrid), label, 0, 0, 1, 1);
label = gtk_label_new("Detail 2");
gtk_grid_attach(GTK_GRID(subgrid), label, 0, 1, 1, 1);
gtk_grid_attach(GTK_GRID(grid), frame, 0, 0, 1, 1);
return grid;
}
void
dialog_search (WBCGtk *wbcg)
{
GtkBuilder *gui;
GtkDialog *dialog;
DialogState *dd;
GtkGrid *grid;
g_return_if_fail (wbcg != NULL);
/* Only one guru per workbook. */
if (wbc_gtk_get_guru (wbcg))
return;
gui = gnm_gtk_builder_load ("search.ui", NULL, GO_CMD_CONTEXT (wbcg));
if (gui == NULL)
return;
dialog = GTK_DIALOG (gtk_builder_get_object (gui, "search_dialog"));
dd = g_new (DialogState, 1);
dd->wbcg = wbcg;
dd->gui = gui;
dd->dialog = dialog;
dd->matches = g_ptr_array_new ();
dd->prev_button = go_gtk_builder_get_widget (gui, "prev_button");
dd->next_button = go_gtk_builder_get_widget (gui, "next_button");
dd->notebook = GTK_NOTEBOOK (gtk_builder_get_object (gui, "notebook"));
dd->notebook_matches_page =
gtk_notebook_page_num (dd->notebook,
go_gtk_builder_get_widget (gui, "matches_tab"));
dd->rangetext = gnm_expr_entry_new (wbcg, TRUE);
gnm_expr_entry_set_flags (dd->rangetext, 0, GNM_EE_MASK);
grid = GTK_GRID (gtk_builder_get_object (gui, "normal-grid"));
gtk_widget_set_hexpand (GTK_WIDGET (dd->rangetext), TRUE);
gtk_grid_attach (grid, GTK_WIDGET (dd->rangetext), 1, 6, 1, 1);
{
char *selection_text =
selection_to_string (
wb_control_cur_sheet_view (WORKBOOK_CONTROL (wbcg)),
TRUE);
gnm_expr_entry_load_from_text (dd->rangetext, selection_text);
g_free (selection_text);
}
dd->gentry = GTK_ENTRY (gtk_entry_new ());
gtk_widget_set_hexpand (GTK_WIDGET (dd->gentry), TRUE);
gtk_grid_attach (grid, GTK_WIDGET (dd->gentry), 1, 0, 1, 1);
gtk_widget_grab_focus (GTK_WIDGET (dd->gentry));
gnumeric_editable_enters (GTK_WINDOW (dialog), GTK_WIDGET (dd->gentry));
dd->matches_table = make_matches_table (dd);
{
GtkWidget *scrolled_window =
gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (scrolled_window),
GTK_WIDGET (dd->matches_table));
gtk_box_pack_start (GTK_BOX (gtk_builder_get_object (gui, "matches_vbox")),
scrolled_window,
TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_NEVER,
GTK_POLICY_ALWAYS);
}
/* Set sensitivity of buttons. */
cursor_change (dd->matches_table, dd);
#define SETW(w,f) gtk_toggle_button_set_active \
(GTK_TOGGLE_BUTTON (gtk_builder_get_object (gui, w)), f())
SETW("search_expr", gnm_conf_get_searchreplace_change_cell_expressions);
SETW("search_other", gnm_conf_get_searchreplace_change_cell_other);
SETW("search_string", gnm_conf_get_searchreplace_change_cell_strings);
SETW("search_comments", gnm_conf_get_searchreplace_change_comments);
SETW("search_expr_results", gnm_conf_get_searchreplace_search_results);
SETW("ignore_case", gnm_conf_get_searchreplace_ignore_case);
SETW("match_words", gnm_conf_get_searchreplace_whole_words_only);
#undef SETW
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON
(gtk_builder_get_object
(gui,
search_type_group[gnm_conf_get_searchreplace_regex ()])), TRUE);
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON
(gtk_builder_get_object
(gui,
direction_group
[gnm_conf_get_searchreplace_columnmajor () ? 1 : 0])), TRUE);
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON
(gtk_builder_get_object
(gui,
scope_group[gnm_conf_get_searchreplace_scope ()])), TRUE);
g_signal_connect (G_OBJECT (dd->matches_table), "cursor_changed",
G_CALLBACK (cursor_change), dd);
g_signal_connect (G_OBJECT (dd->matches_table), "select_cursor_row",
G_CALLBACK (cb_next), dd);
go_gtk_builder_signal_connect (gui, "search_button", "clicked",
G_CALLBACK (search_clicked), dd);
g_signal_connect (G_OBJECT (dd->prev_button), "clicked",
G_CALLBACK (prev_clicked), dd);
g_signal_connect (G_OBJECT (dd->next_button), "clicked",
G_CALLBACK (next_clicked), dd);
go_gtk_builder_signal_connect_swapped (gui, "close_button", "clicked",
G_CALLBACK (gtk_widget_destroy), dd->dialog);
g_signal_connect (G_OBJECT (gnm_expr_entry_get_entry (dd->rangetext)), "focus-in-event",
G_CALLBACK (range_focused), dd);
go_gtk_builder_signal_connect (gui, "scope_range", "toggled",
G_CALLBACK (cb_focus_on_entry), dd->rangetext);
wbc_gtk_attach_guru_with_unfocused_rs (wbcg, GTK_WIDGET (dialog), dd->rangetext);
g_object_set_data_full (G_OBJECT (dialog),
"state", dd, (GDestroyNotify) free_state);
gnm_dialog_setup_destroy_handlers (dialog, wbcg,
GNM_DIALOG_DESTROY_SHEET_REMOVED);
gnumeric_init_help_button (
go_gtk_builder_get_widget (gui, "help_button"),
GNUMERIC_HELP_LINK_SEARCH);
gnumeric_restore_window_geometry (GTK_WINDOW (dialog), SEARCH_KEY);
go_gtk_nonmodal_dialog (wbcg_toplevel (wbcg), GTK_WINDOW (dialog));
gtk_widget_show_all (GTK_WIDGET (dialog));
}
/* Plugin configuration function */
static GObject* plugin_configure(XfdashboardPlugin *self, gpointer inUserData)
{
GtkWidget *layout;
GtkWidget *widgetLabel;
GtkWidget *widgetValue;
XfdashboardClockViewSettings *settings;
/* Get settings of plugin */
settings=xfdashboard_clock_view_settings_new();
/* Create layout widget */
layout=gtk_grid_new();
gtk_grid_set_column_spacing(GTK_GRID(layout), 8);
/* Add widget to choose hour color */
widgetLabel=gtk_label_new(_("Hour color:"));
gtk_widget_set_halign(widgetLabel, GTK_ALIGN_END);
gtk_grid_attach(GTK_GRID(layout), widgetLabel, 0, 0, 1, 1);
widgetValue=gtk_color_button_new();
#if GTK_CHECK_VERSION(3, 4, 0)
gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(widgetValue), TRUE);
#else
gtk_color_button_set_use_alpha(GTK_COLOR_BUTTON(widgetValue), TRUE);
#endif
gtk_color_button_set_title(GTK_COLOR_BUTTON(widgetValue), _("Choose color for hour hand"));
_plugin_configure_setup_color_button(GTK_COLOR_BUTTON(widgetValue), settings, "hour-color");
gtk_grid_attach_next_to(GTK_GRID(layout), widgetValue, widgetLabel, GTK_POS_RIGHT, 1, 1);
/* Add widget to choose minute color */
widgetLabel=gtk_label_new(_("Minute color:"));
gtk_widget_set_halign(widgetLabel, GTK_ALIGN_END);
gtk_grid_attach(GTK_GRID(layout), widgetLabel, 0, 1, 1, 1);
widgetValue=gtk_color_button_new();
#if GTK_CHECK_VERSION(3, 4, 0)
gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(widgetValue), TRUE);
#else
gtk_color_button_set_use_alpha(GTK_COLOR_BUTTON(widgetValue), TRUE);
#endif
gtk_color_button_set_title(GTK_COLOR_BUTTON(widgetValue), _("Choose color for minute hand"));
_plugin_configure_setup_color_button(GTK_COLOR_BUTTON(widgetValue), settings, "minute-color");
gtk_grid_attach_next_to(GTK_GRID(layout), widgetValue, widgetLabel, GTK_POS_RIGHT, 1, 1);
/* Add widget to choose second color */
widgetLabel=gtk_label_new(_("Second color:"));
gtk_widget_set_halign(widgetLabel, GTK_ALIGN_END);
gtk_grid_attach(GTK_GRID(layout), widgetLabel, 0, 2, 1, 1);
widgetValue=gtk_color_button_new();
#if GTK_CHECK_VERSION(3, 4, 0)
gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(widgetValue), TRUE);
#else
gtk_color_button_set_use_alpha(GTK_COLOR_BUTTON(widgetValue), TRUE);
#endif
gtk_color_button_set_title(GTK_COLOR_BUTTON(widgetValue), _("Choose color for second hand"));
_plugin_configure_setup_color_button(GTK_COLOR_BUTTON(widgetValue), settings, "second-color");
gtk_grid_attach_next_to(GTK_GRID(layout), widgetValue, widgetLabel, GTK_POS_RIGHT, 1, 1);
/* Add widget to choose minute color */
widgetLabel=gtk_label_new(_("Background color:"));
gtk_widget_set_halign(widgetLabel, GTK_ALIGN_END);
gtk_grid_attach(GTK_GRID(layout), widgetLabel, 0, 3, 1, 1);
widgetValue=gtk_color_button_new();
#if GTK_CHECK_VERSION(3, 4, 0)
gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(widgetValue), TRUE);
#else
gtk_color_button_set_use_alpha(GTK_COLOR_BUTTON(widgetValue), TRUE);
#endif
gtk_color_button_set_title(GTK_COLOR_BUTTON(widgetValue), _("Choose color for background of second hand"));
_plugin_configure_setup_color_button(GTK_COLOR_BUTTON(widgetValue), settings, "background-color");
gtk_grid_attach_next_to(GTK_GRID(layout), widgetValue, widgetLabel, GTK_POS_RIGHT, 1, 1);
/* Release allocated resources */
if(settings) g_object_unref(settings);
/* Make all widgets visible */
gtk_widget_show_all(layout);
/* Return layout widget containing all other widgets */
return(G_OBJECT(layout));
}
/* Construct the status bar widget. */
static GtkWidget *
libre_impuesto_window_construct_headerbar (LibreImpuestoWindow *impuesto_window)
{
gint size;
time_t secs;
GDate *today;
struct tm *tm;
GtkStateFlags state;
GtkWidget *headerbar;
gchar buffer[100] = "";
GtkWidget *header_area;
GtkWidget *grid_layout;
GtkStyleContext *context;
PangoFontDescription *font_desc;
GtkWidget *label_libre_impuesto, *label_software_libre, *label_date;
secs = time (NULL);
tm = localtime (&secs);
header_area = gtk_box_new (GTK_ORIENTATION_VERTICAL, 1);
g_object_bind_property (
impuesto_window, "headerbar-visible",
header_area, "visible",
G_BINDING_SYNC_CREATE);
headerbar = gtk_event_box_new();
gtk_box_pack_start (GTK_BOX (header_area),
headerbar, FALSE, FALSE, 0);
gtk_widget_set_name (headerbar, "libre-impuesto-header");
gtk_widget_set_size_request (headerbar, -1, 56);
grid_layout = gtk_grid_new ();
gtk_container_add (GTK_CONTAINER (headerbar), grid_layout);
gtk_grid_set_column_homogeneous (GTK_GRID(grid_layout), TRUE);
gtk_grid_set_row_homogeneous (GTK_GRID (grid_layout), TRUE);
label_libre_impuesto = gtk_label_new (_("Libre Impuestos"));
gtk_grid_attach (GTK_GRID (grid_layout), label_libre_impuesto, 0, 0, 1, 1);
context = gtk_widget_get_style_context (label_libre_impuesto);
state = gtk_widget_get_state_flags (label_libre_impuesto);
size = pango_font_description_get_size (gtk_style_context_get_font (
context,
state));
font_desc = pango_font_description_new ();
pango_font_description_set_weight (font_desc, PANGO_WEIGHT_BOLD);
pango_font_description_set_size (font_desc, size * PANGO_SCALE_X_LARGE);
gtk_widget_override_font (label_libre_impuesto, font_desc);
pango_font_description_free (font_desc);
gtk_misc_set_alignment (GTK_MISC (label_libre_impuesto), 0.2, 0.4);
gtk_widget_show (label_libre_impuesto);
label_software_libre = gtk_label_new (_("www.softwarelibre.org.bo"));
gtk_grid_attach (GTK_GRID (grid_layout), label_software_libre, 1, 0, 1, 1);
gtk_misc_set_alignment (GTK_MISC (label_software_libre), 0.5, 0.8);
gtk_widget_show (label_software_libre);
today = g_date_new_dmy((gint)tm->tm_mday,
(gint)tm->tm_mon + 1,
1900 + tm->tm_year);
g_date_strftime (buffer, 100-1, "%A, %d de %B de %Y", today);
label_date = gtk_label_new (g_ascii_strup (buffer,100-1));
g_date_free(today);
gtk_grid_attach (GTK_GRID (grid_layout), label_date, 2, 0, 1, 1);
gtk_misc_set_alignment (GTK_MISC (label_date), 0.9, 0.5);
return header_area;
}
int main(int argc, char **argv)
{
gtk_init(&argc, &argv);
printf("%llf\n", exp_fall_function(0.0));
if(argc != 2) {
exit(1);
}
file_info = malloc(sizeof(SF_INFO));
SNDFILE *sndfile = sf_open (argv[1], SFM_READ, file_info);
printf("channels: %d, samplerate: %d, samples: %lld\n", file_info->channels, file_info->samplerate, file_info->frames);
snd_data = malloc(sizeof(short) * file_info->frames);
p_pos = malloc(sizeof(double) * file_info->frames);
for(int i=0; i<file_info->frames; i++) {
p_pos[i] = snd_data[i];
}
float *snd_dataf = malloc(sizeof(float) * file_info->frames);
sf_count_t items_read = sf_read_short(sndfile, snd_data, file_info->frames);
printf("items read: %lld\n", items_read);
sf_close(sndfile);
min_fall_lenght = (int) (0.4 * (file_info->samplerate / MAX_FREQ));
GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect(window, "destroy",
G_CALLBACK(delete_cb), window);
GtkWidget *grid = gtk_grid_new();
drawing_area = gtk_drawing_area_new();
gtk_widget_set_size_request(drawing_area, 1000, 400);
g_signal_connect (drawing_area, "draw", G_CALLBACK(draw_callback),
NULL);
scroll_adj = gtk_adjustment_new(0.0, 0.0, (double) file_info->frames, 1.0, SHOW_FRAMES, SHOW_FRAMES);
g_signal_connect(G_OBJECT(scroll_adj), "value-changed",
G_CALLBACK(drawing_area_redraw_cb), NULL);
GtkWidget *scrollbar = gtk_hscrollbar_new(GTK_ADJUSTMENT(scroll_adj));
gtk_grid_attach(GTK_GRID(grid), scrollbar, 0, 1, 2, 1);
spin = gtk_spin_button_new_with_range(0.0, (double) file_info->frames, 1.0);
gtk_spin_button_set_adjustment(GTK_SPIN_BUTTON(spin), GTK_ADJUSTMENT(scroll_adj));
gtk_grid_attach(GTK_GRID(grid), spin, 0, 2, 1, 1);
g_signal_connect(G_OBJECT(spin), "value-changed",
G_CALLBACK(drawing_area_redraw_cb), NULL);
window_spin = gtk_spin_button_new_with_range(1.0, (double) file_info->frames, 1.0);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(window_spin), 1000.0);
gtk_grid_attach(GTK_GRID(grid), window_spin, 1,2,1,1);
g_signal_connect(G_OBJECT(window_spin), "value-changed",
G_CALLBACK(drawing_area_redraw_cb), NULL);
GtkWidget* button = gtk_button_new_with_label("Calculate");
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(calculate_click_cb), NULL);
gtk_grid_attach(GTK_GRID(grid), button, 0, 3, 1, 1);
gtk_grid_attach(GTK_GRID(grid), drawing_area, 0, 0, 2, 1);
gtk_container_add(GTK_CONTAINER(window), grid);
gtk_widget_show (grid);
gtk_widget_show (drawing_area);
gtk_widget_show_all (window);
gtk_main();
free(snd_data);
free(p_pos);
return 0;
}
void
dialog_tabulate (WBCGtk *wbcg, Sheet *sheet)
{
GtkBuilder *gui;
GtkDialog *dialog;
DialogState *dd;
int i;
g_return_if_fail (wbcg != NULL);
/* Only one guru per workbook. */
if (wbc_gtk_get_guru (wbcg))
return;
if (gnm_dialog_raise_if_exists (wbcg, TABULATE_KEY))
return;
gui = gnm_gtk_builder_load ("tabulate.ui", NULL, GO_CMD_CONTEXT (wbcg));
if (gui == NULL)
return;
dialog = GTK_DIALOG (go_gtk_builder_get_widget (gui, "tabulate_dialog"));
dd = g_new (DialogState, 1);
dd->wbcg = wbcg;
dd->gui = gui;
dd->dialog = dialog;
dd->sheet = sheet;
dd->grid = GTK_GRID (go_gtk_builder_get_widget (gui, "main-grid"));
/* we might get the 4 below from the positon of some of the widgets inside the grid */
for (i = 1; i < 4; i++) {
GnmExprEntry *ge = gnm_expr_entry_new (wbcg, TRUE);
gnm_expr_entry_set_flags (ge,
GNM_EE_SINGLE_RANGE | GNM_EE_SHEET_OPTIONAL,
GNM_EE_MASK);
gtk_grid_attach (dd->grid, GTK_WIDGET (ge), COL_CELL, i + 1, 1, 1);
gtk_widget_set_margin_left (GTK_WIDGET (ge), 18);
gtk_widget_show (GTK_WIDGET (ge));
}
dd->resultrangetext = gnm_expr_entry_new (wbcg, TRUE);
gnm_expr_entry_set_flags (dd->resultrangetext,
GNM_EE_SINGLE_RANGE | GNM_EE_SHEET_OPTIONAL,
GNM_EE_MASK);
gtk_grid_attach (dd->grid, GTK_WIDGET (dd->resultrangetext), 0, 6, 4, 1);
gtk_widget_set_margin_left (GTK_WIDGET (dd->resultrangetext), 18);
gtk_widget_show (GTK_WIDGET (dd->resultrangetext));
g_signal_connect (G_OBJECT (go_gtk_builder_get_widget (gui, "ok_button")),
"clicked",
G_CALLBACK (tabulate_ok_clicked), dd);
g_signal_connect (G_OBJECT (go_gtk_builder_get_widget (gui, "cancel_button")),
"clicked",
G_CALLBACK (cancel_clicked), dd);
/* FIXME: Add correct helpfile address */
gnm_init_help_button (
go_gtk_builder_get_widget (gui, "help_button"),
GNUMERIC_HELP_LINK_TABULATE);
g_object_set_data_full (G_OBJECT (dialog),
"state", dd, (GDestroyNotify) cb_dialog_destroy);
gnm_dialog_setup_destroy_handlers (dialog, wbcg,
GNM_DIALOG_DESTROY_SHEET_REMOVED);
gtk_widget_show_all (gtk_dialog_get_content_area (dialog));
wbc_gtk_attach_guru (wbcg, GTK_WIDGET (dialog));
non_model_dialog (wbcg, dialog, TABULATE_KEY);
}
extern void popup_register()
{
GtkWidget *dialog_content_area = NULL,
*username_grid = NULL,
*username_label = NULL,
*username_entry_field = NULL,
*password_grid = NULL,
*password_label = NULL,
*password_entry_field = NULL;
/*dialog*/
dialog_register = gtk_dialog_new();
gtk_window_set_title(GTK_WINDOW(dialog_register), "Register");
gtk_window_set_transient_for(GTK_WINDOW(dialog_register), GTK_WINDOW(window) );
dialog_content_area = gtk_dialog_get_content_area(GTK_DIALOG(dialog_register));
/*username grid*/
username_grid = gtk_grid_new();
gtk_grid_set_column_spacing(GTK_GRID(username_grid), 10);
/*username label*/
username_label = gtk_label_new("Username:"******"Password:"******"Cancel", GTK_RESPONSE_CANCEL );
gtk_dialog_add_button( GTK_DIALOG(dialog_register), "Register", GTK_RESPONSE_OK );
/*connect the "response" signal*/
g_signal_connect( GTK_DIALOG(dialog_register), "response", G_CALLBACK(Register_cb), NULL );
g_signal_connect_swapped( GTK_DIALOG(dialog_register), "response", G_CALLBACK(gtk_widget_destroy), dialog_register);
gtk_widget_show(username_grid);
gtk_widget_show(username_label);
gtk_widget_show(username_entry_field);
gtk_widget_show(password_grid);
gtk_widget_show(password_label);
gtk_widget_show(password_entry_field);
gtk_widget_show(dialog_register);
return;
}
static void remmina_string_list_init(RemminaStringList *gsl)
{
GtkWidget *widget;
GtkWidget *image;
GtkWidget *scrolled_window;
GtkWidget *vbox;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkWidget *frame;
//gtk_table_resize(GTK_TABLE(gsl), 3, 2);
/* Create the frame and add a new scrolled window, followed by the group list */
frame = gtk_frame_new(NULL);
gtk_widget_show(frame);
gtk_widget_set_hexpand(frame, TRUE);
gtk_widget_set_vexpand(frame, TRUE);
#if GTK_CHECK_VERSION(3, 12, 0)
gtk_widget_set_margin_end (GTK_FRAME(frame), 80);
#else
gtk_widget_set_margin_right (GTK_FRAME(frame), 80);
#endif
gtk_grid_attach(GTK_GRID(gsl), frame, 0, 0, 1, 1);
scrolled_window = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolled_window);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(frame), scrolled_window);
gsl->store = gtk_list_store_new(NUM_COLUMNS, G_TYPE_STRING, G_TYPE_STRING);
gsl->list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(gsl->store));
gtk_widget_show(gsl->list);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(gsl->list), FALSE);
gtk_container_add(GTK_CONTAINER(scrolled_window), gsl->list);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "editable", TRUE, NULL);
g_signal_connect(renderer, "edited", G_CALLBACK(remmina_string_list_cell_edited), gsl);
column = gtk_tree_view_column_new_with_attributes(NULL, renderer, "text", COLUMN_TEXT, "foreground", COLUMN_COLOR,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(gsl->list), column);
/* buttons packed into a vbox */
#if GTK_VERSION == 3
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
#elif GTK_VERSION == 2
vbox = gtk_vbox_new(FALSE, 0);
#endif
gtk_widget_show(vbox);
gtk_grid_attach(GTK_GRID(gsl), vbox, 1, 0, 2, 1);
image = gtk_image_new_from_icon_name("list-add", GTK_ICON_SIZE_MENU);
gtk_widget_show(image);
widget = gtk_button_new();
gtk_widget_show(widget);
gtk_container_add(GTK_CONTAINER(widget), image);
gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(remmina_string_list_add), gsl);
image = gtk_image_new_from_icon_name("list-remove", GTK_ICON_SIZE_MENU);
gtk_widget_show(image);
widget = gtk_button_new();
gtk_widget_show(widget);
gtk_container_add(GTK_CONTAINER(widget), image);
gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(remmina_string_list_remove), gsl);
image = gtk_image_new_from_icon_name("go-up", GTK_ICON_SIZE_MENU);
gtk_widget_show(image);
widget = gtk_button_new();
gtk_widget_show(widget);
gtk_container_add(GTK_CONTAINER(widget), image);
gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(remmina_string_list_up), gsl);
gsl->up_button = widget;
image = gtk_image_new_from_icon_name("go-down", GTK_ICON_SIZE_MENU);
gtk_widget_show(image);
widget = gtk_button_new();
gtk_widget_show(widget);
gtk_container_add(GTK_CONTAINER(widget), image);
gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(remmina_string_list_down), gsl);
gsl->down_button = widget;
/* The last status label */
gsl->status_label = gtk_label_new(NULL);
gtk_widget_show(gsl->status_label);
gtk_misc_set_alignment(GTK_MISC(gsl->status_label), 0.0, 0.5);
gtk_widget_set_hexpand(gsl->status_label, TRUE);
gtk_grid_attach(GTK_GRID(gsl), gsl->status_label, 0, 2, 2, 1);
gsl->hints = NULL;
gsl->validation_func = NULL;
}
/* Show the preferences dialog */
static void
command_settings_callback (GtkAction *action, CommandApplet *command_applet)
{
GtkDialog *dialog;
GtkGrid *grid;
GtkWidget *widget;
GtkWidget *command;
GtkWidget *interval;
GtkWidget *width;
GtkWidget *showicon;
dialog = GTK_DIALOG (gtk_dialog_new_with_buttons(_("Command Applet Preferences"),
NULL,
GTK_DIALOG_MODAL,
GTK_STOCK_CLOSE,
GTK_RESPONSE_CLOSE,
NULL));
grid = GTK_GRID (gtk_grid_new ());
gtk_grid_set_row_spacing (grid, 12);
gtk_grid_set_column_spacing (grid, 12);
gtk_window_set_default_size (GTK_WINDOW (dialog), 350, 150);
gtk_container_set_border_width (GTK_CONTAINER (dialog), 10);
widget = gtk_label_new (_("Command:"));
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (widget), 1.0);
gtk_label_set_yalign (GTK_LABEL (widget), 0.5);
#else
gtk_misc_set_alignment (GTK_MISC (widget), 1.0, 0.5);
#endif
gtk_grid_attach (grid, widget, 1, 0, 1, 1);
command = gtk_entry_new ();
gtk_grid_attach (grid, command, 2, 0, 1, 1);
widget = gtk_label_new (_("Interval (seconds):"));
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (widget), 1.0);
gtk_label_set_yalign (GTK_LABEL (widget), 0.5);
#else
gtk_misc_set_alignment (GTK_MISC (widget), 1.0, 0.5);
#endif
gtk_grid_attach (grid, widget, 1, 1, 1, 1);
interval = gtk_spin_button_new_with_range (1.0, 600.0, 1.0);
gtk_grid_attach (grid, interval, 2, 1, 1, 1);
widget = gtk_label_new (_("Maximum width (chars):"));
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (widget), 1.0);
gtk_label_set_yalign (GTK_LABEL (widget), 0.5);
#else
gtk_misc_set_alignment (GTK_MISC (widget), 1.0, 0.5);
#endif
gtk_grid_attach (grid, widget, 1, 2, 1, 1);
width = gtk_spin_button_new_with_range(1.0, 100.0, 1.0);
gtk_grid_attach (grid, width, 2, 2, 1, 1);
showicon = gtk_check_button_new_with_label (_("Show icon"));
gtk_grid_attach (grid, showicon, 2, 3, 1, 1);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (dialog)), GTK_WIDGET (grid), TRUE, TRUE, 0);
g_signal_connect (dialog, "response", G_CALLBACK (gtk_widget_destroy), dialog);
/* use g_settings_bind to manage settings */
g_settings_bind (command_applet->settings, COMMAND_KEY, command, "text", G_SETTINGS_BIND_DEFAULT);
g_settings_bind (command_applet->settings, INTERVAL_KEY, interval, "value", G_SETTINGS_BIND_DEFAULT);
g_settings_bind (command_applet->settings, WIDTH_KEY, width, "value", G_SETTINGS_BIND_DEFAULT);
g_settings_bind (command_applet->settings, SHOW_ICON_KEY, showicon, "active", G_SETTINGS_BIND_DEFAULT);
gtk_widget_show_all (GTK_WIDGET (dialog));
}
static void
gm_pw_init_sound_events_page (GtkWidget *prefs_window,
GtkWidget *container)
{
GmPreferencesWindow *pw= NULL;
GtkWidget *button = NULL;
GtkWidget *hbox = NULL;
GtkWidget *frame = NULL;
GtkWidget *vbox = NULL;
GtkWidget *subsection = NULL;
GtkWidget *selector_hbox = NULL;
GtkWidget *selector_playbutton = NULL;
GtkListStore *list_store = NULL;
GtkTreeSelection *selection = NULL;
GtkTreeViewColumn *column = NULL;
GtkCellRenderer *renderer = NULL;
GtkFileFilter *filefilter = NULL;
PStringArray devs;
pw = gm_pw_get_pw (prefs_window);
subsection = gnome_prefs_subsection_new (prefs_window, container,
_("Ekiga Sound Events"),
1, 1);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_grid_attach (GTK_GRID (subsection), vbox, 0, 0, 1, 1);
/* The 3rd column will be invisible and contain the config key containing
the file to play. The 4th one contains the key determining if the
sound event is enabled or not. */
list_store =
gtk_list_store_new (5,
G_TYPE_BOOLEAN,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING);
pw->sound_events_list =
gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store));
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (pw->sound_events_list), TRUE);
selection =
gtk_tree_view_get_selection (GTK_TREE_VIEW (pw->sound_events_list));
frame = gtk_frame_new (NULL);
gtk_container_set_border_width (GTK_CONTAINER (frame), 4);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (frame), pw->sound_events_list);
gtk_container_set_border_width (GTK_CONTAINER (pw->sound_events_list), 0);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
/* Set all Colums */
renderer = gtk_cell_renderer_toggle_new ();
column = gtk_tree_view_column_new_with_attributes (_("A"),
renderer,
"active",
0,
NULL);
gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 25);
gtk_tree_view_append_column (GTK_TREE_VIEW (pw->sound_events_list), column);
g_signal_connect (renderer, "toggled",
G_CALLBACK (sound_event_toggled_cb),
GTK_TREE_MODEL (list_store));
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Event"),
renderer,
"text",
1,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (pw->sound_events_list), column);
gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 325);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 2);
pw->fsbutton =
gtk_file_chooser_button_new (_("Choose a sound"),
GTK_FILE_CHOOSER_ACTION_OPEN);
gtk_box_pack_start (GTK_BOX (hbox), pw->fsbutton, TRUE, TRUE, 2);
filefilter = gtk_file_filter_new ();
gtk_file_filter_set_name (filefilter, _("Wavefiles"));
#ifdef WIN32
gtk_file_filter_add_pattern (filefilter, "*.wav");
#else
gtk_file_filter_add_mime_type (filefilter, "audio/x-wav");
#endif
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (pw->fsbutton), filefilter);
selector_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
selector_playbutton = gtk_button_new_with_label (_("Play"));
gtk_box_pack_end (GTK_BOX (selector_hbox),
selector_playbutton, FALSE, FALSE, 0);
gtk_widget_show (selector_playbutton);
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (pw->fsbutton),
selector_hbox);
g_signal_connect (selector_playbutton, "clicked",
G_CALLBACK (audioev_filename_browse_play_cb),
(gpointer) prefs_window);
g_signal_connect (pw->fsbutton, "selection-changed",
G_CALLBACK (audioev_filename_browse_cb),
(gpointer) prefs_window);
g_signal_connect (selection, "changed",
G_CALLBACK (sound_event_clicked_cb),
(gpointer) pw->fsbutton);
button = gtk_button_new_with_label (_("Play"));
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 2);
g_signal_connect (button, "clicked",
G_CALLBACK (sound_event_play_cb),
(gpointer) prefs_window);
/* Place it after the signals so that we can make sure they are run if
required */
gm_prefs_window_sound_events_list_build (prefs_window);
}
static void ugtk_download_form_init_page1 (UgtkDownloadForm* dform, UgtkProxyForm* proxy)
{
GtkWidget* widget;
GtkGrid* top_grid;
GtkGrid* grid;
GtkWidget* frame;
GtkBox* top_vbox;
GtkWidget* vbox;
GtkWidget* hbox;
dform->page1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
top_vbox = (GtkBox*) dform->page1;
gtk_container_set_border_width (GTK_CONTAINER (top_vbox), 2);
top_grid = (GtkGrid*) gtk_grid_new ();
gtk_box_pack_start (top_vbox, (GtkWidget*) top_grid, FALSE, FALSE, 0);
// URL - entry
widget = gtk_entry_new ();
// gtk_entry_set_width_chars (GTK_ENTRY (widget), 20); // remove for GTK+ 3.12
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
g_object_set (widget, "margin-left", 1, "margin-right", 1, NULL);
g_object_set (widget, "margin-top", 2, "margin-bottom", 2, NULL);
g_object_set (widget, "hexpand", TRUE, NULL);
gtk_grid_attach (top_grid, widget, 1, 0, 2, 1);
g_signal_connect (GTK_EDITABLE (widget), "changed",
G_CALLBACK (on_uri_entry_changed), dform);
dform->uri_entry = widget;
// URL - label
widget = gtk_label_new_with_mnemonic (_("_URI:"));
gtk_label_set_mnemonic_widget (GTK_LABEL(widget), dform->uri_entry);
g_object_set (widget, "margin-left", 3, "margin-right", 3, NULL);
g_object_set (widget, "margin-top", 2, "margin-bottom", 2, NULL);
gtk_grid_attach (top_grid, widget, 0, 0, 1, 1);
dform->uri_label = widget;
// Mirrors - entry
widget = gtk_entry_new ();
// gtk_entry_set_width_chars (GTK_ENTRY (widget), 20); // remove for GTK+ 3.12
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
g_object_set (widget, "margin-left", 1, "margin-right", 1, NULL);
g_object_set (widget, "margin-top", 2, "margin-bottom", 2, NULL);
g_object_set (widget, "hexpand", TRUE, NULL);
gtk_grid_attach (top_grid, widget, 1, 1, 2, 1);
g_signal_connect (GTK_EDITABLE (widget), "changed",
G_CALLBACK (on_uri_entry_changed), dform);
dform->mirrors_entry = widget;
// Mirrors - label
widget = gtk_label_new_with_mnemonic (_("Mirrors:"));
gtk_label_set_mnemonic_widget (GTK_LABEL(widget), dform->mirrors_entry);
g_object_set (widget, "margin-left", 3, "margin-right", 3, NULL);
g_object_set (widget, "margin-top", 2, "margin-bottom", 2, NULL);
gtk_grid_attach (top_grid, widget, 0, 1, 1, 1);
dform->mirrors_label = widget;
// File - entry
widget = gtk_entry_new ();
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
g_object_set (widget, "margin", 1, "hexpand", TRUE, NULL);
gtk_grid_attach (top_grid, widget, 1, 2, 2, 1);
g_signal_connect (GTK_EDITABLE (widget), "changed",
G_CALLBACK (on_entry_changed), dform);
dform->file_entry = widget;
// File - label
widget = gtk_label_new_with_mnemonic (_("File:"));
gtk_label_set_mnemonic_widget (GTK_LABEL (widget), dform->file_entry);
g_object_set (widget, "margin-left", 3, "margin-right", 3, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (top_grid, widget, 0, 2, 1, 1);
dform->file_label = widget;
// Folder - combo entry + icon
dform->folder_combo = gtk_combo_box_text_new_with_entry ();
dform->folder_entry = gtk_bin_get_child (GTK_BIN (dform->folder_combo));
widget = dform->folder_entry;
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
#if GTK_MAJOR_VERSION >= 3 && GTK_MINOR_VERSION >= 10
gtk_entry_set_icon_from_icon_name (GTK_ENTRY (widget),
GTK_ENTRY_ICON_SECONDARY, "folder");
#else
gtk_entry_set_icon_from_stock (GTK_ENTRY (widget),
GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_DIRECTORY);
#endif
gtk_entry_set_icon_tooltip_text (GTK_ENTRY (widget),
GTK_ENTRY_ICON_SECONDARY, _("Select Folder"));
g_object_set (dform->folder_combo, "margin", 1, "hexpand", TRUE, NULL);
gtk_grid_attach (top_grid, dform->folder_combo, 1, 3, 1, 1);
g_signal_connect (widget, "icon-release",
G_CALLBACK (on_select_folder), dform);
g_signal_connect (GTK_EDITABLE (widget), "changed",
G_CALLBACK (on_entry_changed), dform);
// Folder - label
widget = gtk_label_new_with_mnemonic (_("_Folder:"));
gtk_label_set_mnemonic_widget(GTK_LABEL (widget), dform->folder_combo);
g_object_set (widget, "margin-left", 3, "margin-right", 3, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (top_grid, widget, 0, 3, 1, 1);
// Referrer - entry
widget = gtk_entry_new ();
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
g_object_set (widget, "margin", 1, "hexpand", TRUE, NULL);
gtk_grid_attach (top_grid, widget, 1, 4, 2, 1);
g_signal_connect (GTK_EDITABLE (widget), "changed",
G_CALLBACK (on_http_entry_changed), dform);
dform->referrer_entry = widget;
// Referrer - label
widget = gtk_label_new_with_mnemonic (_("Referrer:"));
gtk_label_set_mnemonic_widget (GTK_LABEL (widget), dform->referrer_entry);
g_object_set (widget, "margin-left", 3, "margin-right", 3, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (top_grid, widget, 0, 4, 1, 1);
// dform->referrer_label = widget;
// ----------------------------------------------------
// Connections
// HBox for Connections
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_box_pack_start (top_vbox, hbox, FALSE, FALSE, 2);
// connections - label
// widget = gtk_label_new (_("connections"));
// gtk_box_pack_end (GTK_BOX (hbox), widget, FALSE, FALSE, 2);
// dform->label_connections = widget;
// connections - spin button
widget = gtk_spin_button_new_with_range (1.0, 16.0, 1.0);
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
// gtk_entry_set_width_chars (GTK_ENTRY (widget), 3); // remove for GTK+ 3.12
gtk_box_pack_end (GTK_BOX (hbox), widget, FALSE, FALSE, 2);
dform->spin_connections = widget;
// "Max Connections:" - title label
widget = gtk_label_new_with_mnemonic (_("_Max Connections:"));
gtk_label_set_mnemonic_widget ((GtkLabel*)widget, dform->spin_connections);
gtk_box_pack_end (GTK_BOX (hbox), widget, FALSE, FALSE, 2);
dform->title_connections = widget;
// ----------------------------------------------------
// HBox for "Status" and "Login"
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_box_pack_start (top_vbox, hbox, FALSE, FALSE, 2);
// ----------------------------------------------------
// frame for Status (start mode)
frame = gtk_frame_new (_("Status"));
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 2);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0);
dform->radio_runnable = gtk_radio_button_new_with_mnemonic (NULL,
_("_Runnable"));
dform->radio_pause = gtk_radio_button_new_with_mnemonic_from_widget (
(GtkRadioButton*)dform->radio_runnable, _("P_ause"));
gtk_box_pack_start (GTK_BOX (vbox), dform->radio_runnable, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), dform->radio_pause, FALSE, FALSE, 0);
// ----------------------------------------------------
// frame for login
frame = gtk_frame_new (_("Login"));
grid = (GtkGrid*) gtk_grid_new ();
gtk_container_set_border_width (GTK_CONTAINER (grid), 2);
gtk_container_add (GTK_CONTAINER (frame), (GtkWidget*) grid);
gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 2);
// User - entry
widget = gtk_entry_new ();
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
g_object_set (widget, "margin", 1, "hexpand", TRUE, NULL);
gtk_grid_attach (grid, widget, 1, 0, 1, 1);
g_signal_connect (GTK_EDITABLE (widget), "changed",
G_CALLBACK (on_entry_changed), dform);
dform->username_entry = widget;
// User - label
widget = gtk_label_new (_("User:"******"margin-left", 2, "margin-right", 2, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (grid, widget, 0, 0, 1, 1);
// dform->username_label = widget;
// Password - entry
widget = gtk_entry_new ();
gtk_entry_set_visibility (GTK_ENTRY (widget), FALSE);
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
g_object_set (widget, "margin", 1, "hexpand", TRUE, NULL);
gtk_grid_attach (grid, widget, 1, 1, 1, 1);
g_signal_connect (GTK_EDITABLE (widget), "changed",
G_CALLBACK (on_entry_changed), dform);
dform->password_entry = widget;
// Password - label
widget = gtk_label_new (_("Password:"******"margin-left", 2, "margin-right", 2, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (grid, widget, 0, 1, 1, 1);
// dform->password_label = widget;
// ----------------------------------------------------
// proxy
// ug_proxy_widget_init (&dform->proxy_dform);
if (proxy) {
widget = proxy->self;
gtk_box_pack_start (top_vbox, widget, FALSE, FALSE, 2);
}
}
static void
gdaui_login_init (GdauiLogin *login)
{
GtkWidget *grid;
GtkWidget *wid;
/* allocate the internal structure */
GdauiLoginPrivate *priv = gdaui_login_get_instance_private (login);
/* Init the properties*/
priv->mode = GDA_UI_LOGIN_ENABLE_CONTROL_CENTRE_MODE;
memset (&(priv->dsn_info), 0, sizeof (GdaDsnInfo));
gtk_orientable_set_orientation (GTK_ORIENTABLE (login), GTK_ORIENTATION_VERTICAL);
/* catch DSN definition changes */
GdaConfig *conf = gda_config_get ();
g_signal_connect (conf, "dsn-changed",
G_CALLBACK (config_dsn_changed_cb), login);
g_object_unref (conf);
/* table layout */
grid = gtk_grid_new ();
gtk_widget_show (grid);
gtk_grid_set_column_spacing (GTK_GRID (grid), 5);
gtk_grid_set_row_spacing (GTK_GRID (grid), 5);
gtk_box_pack_start (GTK_BOX (login), grid, TRUE, TRUE, 0);
/* radio buttons */
wid = gtk_radio_button_new_with_label (NULL, _("Use data source:"));
g_signal_connect (wid, "toggled",
G_CALLBACK (radio_button_use_dsn_toggled_cb), login);
gtk_grid_attach (GTK_GRID (grid), wid, 0, 0, 1, 1);
gtk_widget_show (wid);
priv->rb_dsn = wid;
wid = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (wid),
_("Specify connection:"));
gtk_grid_attach (GTK_GRID (grid), wid, 0, 1, 1, 1);
gtk_widget_show (wid);
priv->rb_prov = wid;
/* widget to specify a DSN to use */
priv->dsn_selector = _gdaui_dsn_selector_new ();
gtk_widget_show (priv->dsn_selector); /* Show the DSN selector */
gtk_grid_attach (GTK_GRID (grid), priv->dsn_selector, 1, 0, 1, 1);
g_signal_connect (G_OBJECT (priv->dsn_selector), "changed",
G_CALLBACK (dsn_entry_changed_cb), login);
/* Create the DSN add button */
priv->cc_button = gtk_button_new_with_label (_("Data sources..."));
gtk_button_set_image (GTK_BUTTON (priv->cc_button),
gtk_image_new_from_icon_name ("preferences-system", GTK_ICON_SIZE_BUTTON));
g_signal_connect (G_OBJECT (priv->cc_button), "clicked",
G_CALLBACK (run_cc_cb), login);
gtk_widget_show (priv->cc_button);
gtk_grid_attach (GTK_GRID (grid), priv->cc_button, 2, 0, 1, 1);
/* widget to specify a direct connection */
priv->prov_selector = gdaui_provider_selector_new ();
gtk_grid_attach (GTK_GRID (grid),priv->prov_selector, 1, 1, 2, 1);
gtk_widget_show (priv->prov_selector);
gtk_widget_set_sensitive (priv->prov_selector, FALSE);
g_signal_connect (priv->prov_selector, "changed",
G_CALLBACK (prov_entry_changed_cb), login);
priv->cnc_params_editor = _gdaui_provider_spec_editor_new (NULL);
gtk_grid_attach (GTK_GRID (grid), priv->cnc_params_editor, 1, 2, 2, 1);
gtk_widget_show (priv->cnc_params_editor);
gtk_widget_set_sensitive (priv->cnc_params_editor, FALSE);
g_signal_connect (priv->cnc_params_editor, "changed",
G_CALLBACK (cnc_params_editor_changed_cb), login);
/* Create the authentication part */
priv->auth_widget = _gdaui_provider_auth_editor_new (NULL);
gtk_grid_attach (GTK_GRID (grid), priv->auth_widget, 1, 3, 2, 1);
gtk_widget_show (priv->auth_widget);
g_signal_connect (priv->auth_widget, "changed",
G_CALLBACK (auth_data_changed_cb), login);
prov_entry_changed_cb (GDAUI_PROVIDER_SELECTOR (priv->prov_selector), login);
}
static gboolean
append_menu (RBButtonBar *bar, GMenuModel *menu, gboolean need_separator)
{
int i;
gulong id;
id = g_signal_connect (menu, "items-changed", G_CALLBACK (items_changed_cb), bar);
g_hash_table_insert (bar->priv->handlers, (gpointer)id, g_object_ref (menu));
for (i = 0; i < g_menu_model_get_n_items (menu); i++) {
char *label_text;
char *accel;
GtkWidget *button;
GtkWidget *label;
GMenuModel *submenu;
/* recurse into sections */
submenu = g_menu_model_get_item_link (menu, i, G_MENU_LINK_SECTION);
if (submenu != NULL) {
need_separator = append_menu (bar, submenu, TRUE);
continue;
}
/* if this item and the previous item are in different sections, add
* a separator between them. this may not be a good idea.
*/
if (need_separator) {
GtkWidget *sep;
if (bar->priv->position > 0) {
sep = gtk_separator_new (GTK_ORIENTATION_VERTICAL);
gtk_widget_show (sep);
gtk_grid_attach (GTK_GRID (bar), sep, bar->priv->position++, 0, 1, 1);
}
need_separator = FALSE;
}
button = NULL;
/* submenus become menu buttons, normal items become buttons */
submenu = g_menu_model_get_item_link (menu, i, G_MENU_LINK_SUBMENU);
if (submenu != NULL) {
button = gtk_menu_button_new ();
gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (button), submenu);
g_object_set_data_full (G_OBJECT (button), "rb-menu-model", g_object_ref (submenu), (GDestroyNotify)g_object_unref);
} else {
GMenuAttributeIter *iter;
const char *name;
GVariant *value;
char *str;
guint signal_id;
/* we can't do more than one of action and rb-property-bind
* and rb-signal-bind, so just do whichever turns up first
* in the iterator
*/
iter = g_menu_model_iterate_item_attributes (menu, i);
while (g_menu_attribute_iter_get_next (iter, &name, &value)) {
if (g_str_equal (name, "action")) {
button = gtk_button_new ();
g_variant_get (value, "s", &str, NULL);
gtk_actionable_set_action_name (GTK_ACTIONABLE (button), str);
/* action target too somehow? */
g_free (str);
break;
} else if (g_str_equal (name, "rb-property-bind")) {
/* property has to be a boolean, can't do inverts, etc. etc. */
button = gtk_toggle_button_new ();
g_variant_get (value, "s", &str, NULL);
g_object_bind_property (bar->priv->target, str,
button, "active",
G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
g_free (str);
break;
} else if (g_str_equal (name, "rb-signal-bind")) {
button = gtk_button_new ();
g_variant_get (value, "s", &str, NULL);
signal_id = g_signal_lookup (str, G_OBJECT_TYPE (bar->priv->target));
if (signal_id != 0) {
g_object_set_data (G_OBJECT (button), "rb-signal-bind-id", GUINT_TO_POINTER (signal_id));
g_signal_connect (button, "clicked", G_CALLBACK (signal_button_clicked_cb), bar);
}
g_free (str);
break;
}
}
g_object_unref (iter);
}
if (button == NULL) {
g_warning ("no idea what's going on here");
continue;
}
gtk_widget_set_hexpand (button, FALSE);
gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
label_text = NULL;
g_menu_model_get_item_attribute (menu, i, "label", "s", &label_text);
label = gtk_label_new (g_dgettext (NULL, label_text));
g_object_set (label, "xpad", 6, NULL);
gtk_container_add (GTK_CONTAINER (button), label);
if (g_menu_model_get_item_attribute (menu, i, "accel", "s", &accel)) {
g_object_set_data_full (G_OBJECT (button), "rb-accel", accel, (GDestroyNotify) g_free);
}
gtk_widget_show_all (button);
gtk_size_group_add_widget (bar->priv->size_group, button);
gtk_grid_attach (GTK_GRID (bar), button, bar->priv->position++, 0, 1, 1);
g_free (label_text);
}
return need_separator;
}
void gui_init(dt_lib_module_t *self)
{
self->data = calloc(1, sizeof(dt_lib_camera_t));
// Setup lib data
dt_lib_camera_t *lib = self->data;
lib->data.listener = calloc(1, sizeof(dt_camctl_listener_t));
lib->data.listener->data = lib;
lib->data.listener->camera_error = _camera_error_callback;
lib->data.listener->camera_property_value_changed = _camera_property_value_changed;
lib->data.listener->camera_property_accessibility_changed = _camera_property_accessibility_changed;
// Setup gui
lib->gui.rows = 0;
lib->gui.prop_end = 0;
self->widget = gtk_grid_new();
gtk_grid_set_column_spacing(GTK_GRID(self->widget), DT_PIXEL_APPLY_DPI(5));
lib->gui.main_grid = GTK_GRID(self->widget);
gtk_grid_set_row_spacing(GTK_GRID(self->widget), DT_PIXEL_APPLY_DPI(5));
GtkBox *hbox;
// Camera control
GtkWidget *label = dt_ui_section_label_new(_("camera control"));
gtk_grid_attach(GTK_GRID(self->widget), label, lib->gui.rows++, 0, 2, 1);
lib->gui.label1 = gtk_label_new(_("modes"));
lib->gui.label2 = gtk_label_new(_("timer (s)"));
lib->gui.label3 = gtk_label_new(_("count"));
lib->gui.label4 = gtk_label_new(_("brackets"));
lib->gui.label5 = gtk_label_new(_("bkt. steps"));
gtk_widget_set_halign(GTK_WIDGET(lib->gui.label1), GTK_ALIGN_START);
gtk_widget_set_halign(GTK_WIDGET(lib->gui.label2), GTK_ALIGN_START);
gtk_widget_set_halign(GTK_WIDGET(lib->gui.label3), GTK_ALIGN_START);
gtk_widget_set_halign(GTK_WIDGET(lib->gui.label4), GTK_ALIGN_START);
gtk_widget_set_halign(GTK_WIDGET(lib->gui.label5), GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.label1), 0, lib->gui.rows++, 1, 1);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.label2), 0, lib->gui.rows++, 1, 1);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.label3), 0, lib->gui.rows++, 1, 1);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.label4), 0, lib->gui.rows++, 1, 1);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.label5), 0, lib->gui.rows++, 1, 1);
// capture modes buttons
lib->gui.tb1 = DTGTK_TOGGLEBUTTON(
dtgtk_togglebutton_new(dtgtk_cairo_paint_timer, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER));
lib->gui.tb2 = DTGTK_TOGGLEBUTTON(
dtgtk_togglebutton_new(dtgtk_cairo_paint_filmstrip, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER));
lib->gui.tb3 = DTGTK_TOGGLEBUTTON(
dtgtk_togglebutton_new(dtgtk_cairo_paint_bracket, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER));
hbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(5)));
gtk_box_pack_start(hbox, GTK_WIDGET(lib->gui.tb1), TRUE, TRUE, 0);
gtk_box_pack_start(hbox, GTK_WIDGET(lib->gui.tb2), TRUE, TRUE, 0);
gtk_box_pack_start(hbox, GTK_WIDGET(lib->gui.tb3), TRUE, TRUE, 0);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(hbox), GTK_WIDGET(lib->gui.label1), GTK_POS_RIGHT, 1, 1);
lib->gui.sb1 = gtk_spin_button_new_with_range(1, 60, 1);
lib->gui.sb2 = gtk_spin_button_new_with_range(1, 500, 1);
lib->gui.sb3 = gtk_spin_button_new_with_range(1, 5, 1);
lib->gui.sb4 = gtk_spin_button_new_with_range(1, 9, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.sb1), GTK_WIDGET(lib->gui.label2), GTK_POS_RIGHT, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.sb2), GTK_WIDGET(lib->gui.label3), GTK_POS_RIGHT, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.sb3), GTK_WIDGET(lib->gui.label4), GTK_POS_RIGHT, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.sb4), GTK_WIDGET(lib->gui.label5), GTK_POS_RIGHT, 1, 1);
lib->gui.button1 = gtk_button_new_with_label(_("capture image(s)"));
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.button1), 0, lib->gui.rows++, 2, 1);
g_object_set(G_OBJECT(lib->gui.tb1), "tooltip-text", _("toggle delayed capture mode"), (char *)NULL);
g_object_set(G_OBJECT(lib->gui.tb2), "tooltip-text", _("toggle sequenced capture mode"), (char *)NULL);
g_object_set(G_OBJECT(lib->gui.tb3), "tooltip-text", _("toggle bracketed capture mode"), (char *)NULL);
g_object_set(G_OBJECT(lib->gui.sb1), "tooltip-text",
_("the count of seconds before actually doing a capture"), (char *)NULL);
g_object_set(G_OBJECT(lib->gui.sb2), "tooltip-text",
_("the amount of images to capture in a sequence,\nyou can use this in conjunction with "
"delayed mode to create stop-motion sequences."),
(char *)NULL);
g_object_set(G_OBJECT(lib->gui.sb3), "tooltip-text",
_("the amount of brackets on each side of centered shoot, amount of images = (brackets*2)+1."),
(char *)NULL);
g_object_set(G_OBJECT(lib->gui.sb4), "tooltip-text",
_("the amount of steps per bracket, steps is camera configurable and usually 3 steps per "
"stop\nwith other words, 3 steps is 1EV exposure step between brackets."),
(char *)NULL);
g_signal_connect(G_OBJECT(lib->gui.tb1), "clicked", G_CALLBACK(_toggle_capture_mode_clicked), lib);
g_signal_connect(G_OBJECT(lib->gui.tb2), "clicked", G_CALLBACK(_toggle_capture_mode_clicked), lib);
g_signal_connect(G_OBJECT(lib->gui.tb3), "clicked", G_CALLBACK(_toggle_capture_mode_clicked), lib);
g_signal_connect(G_OBJECT(lib->gui.button1), "clicked", G_CALLBACK(_capture_button_clicked), lib);
gtk_widget_set_sensitive(GTK_WIDGET(lib->gui.sb1), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(lib->gui.sb2), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(lib->gui.sb3), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(lib->gui.sb4), FALSE);
// Camera settings
label = dt_ui_section_label_new(_("properties"));
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(label), 0, lib->gui.rows++, 2, 1);
lib->gui.prop_start = lib->gui.rows -1;
lib->gui.prop_end = lib->gui.rows;
// user specified properties
label = dt_ui_section_label_new(_("additional properties"));
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(label), 0, lib->gui.rows++, 2, 1);
label = gtk_label_new(_("label"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
lib->gui.plabel = gtk_entry_new();
gtk_entry_set_width_chars(GTK_ENTRY(lib->gui.plabel), 0);
dt_gui_key_accel_block_on_focus_connect(lib->gui.plabel);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(label), 0, lib->gui.rows++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(lib->gui.plabel), GTK_WIDGET(label), GTK_POS_RIGHT, 1, 1);
hbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(5)));
label = gtk_label_new(_("property"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
GtkWidget *widget = gtk_button_new_with_label("O");
g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(_show_property_popupmenu_clicked), lib);
lib->gui.pname = gtk_entry_new();
gtk_entry_set_width_chars(GTK_ENTRY(lib->gui.pname), 0);
dt_gui_key_accel_block_on_focus_connect(lib->gui.pname);
gtk_box_pack_start(hbox, GTK_WIDGET(lib->gui.pname), TRUE, TRUE, 0);
gtk_box_pack_start(hbox, GTK_WIDGET(widget), FALSE, FALSE, 0);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(label), 0, lib->gui.rows++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), GTK_WIDGET(hbox), GTK_WIDGET(label), GTK_POS_RIGHT, 1, 1);
widget = gtk_button_new_with_label(_("add user property"));
g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(_add_property_button_clicked), lib);
gtk_widget_show(widget);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(widget), 0, lib->gui.rows++, 2, 1);
}
static void
bluetooth_filter_widget_init(BluetoothFilterWidget *self)
{
BluetoothFilterWidgetPrivate *priv = BLUETOOTH_FILTER_WIDGET_GET_PRIVATE(self);
guint i;
GtkWidget *label;
GtkWidget *alignment;
GtkWidget *table;
GtkCellRenderer *renderer;
gtk_widget_push_composite_child ();
g_object_set (G_OBJECT (self), "orientation", GTK_ORIENTATION_VERTICAL, NULL);
gtk_box_set_homogeneous (GTK_BOX (self), FALSE);
gtk_box_set_spacing (GTK_BOX (self), 6);
priv->title = gtk_label_new ("");
/* This is the title of the filter section of the Bluetooth device chooser.
* It used to say Show Only Bluetooth Devices With... */
bluetooth_filter_widget_set_title (self, _("Show:"));
gtk_widget_show (priv->title);
gtk_box_pack_start (GTK_BOX (self), priv->title, TRUE, TRUE, 0);
gtk_misc_set_alignment (GTK_MISC (priv->title), 0, 0.5);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment);
gtk_box_pack_start (GTK_BOX (self), alignment, TRUE, TRUE, 0);
table = gtk_grid_new ();
gtk_widget_show (table);
gtk_container_add (GTK_CONTAINER (alignment), table);
gtk_grid_set_row_spacing (GTK_GRID (table), 6);
gtk_grid_set_column_spacing (GTK_GRID (table), 12);
/* The device category filter */
label = gtk_label_new_with_mnemonic (_("Device _category:"));
gtk_widget_set_no_show_all (label, TRUE);
gtk_widget_show (label);
gtk_grid_attach (GTK_GRID (table), label, 0, 0, 1, 1);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
priv->device_category_label = label;
priv->device_category = gtk_combo_box_text_new ();
gtk_widget_set_no_show_all (priv->device_category, TRUE);
gtk_widget_show (priv->device_category);
gtk_grid_attach (GTK_GRID (table), priv->device_category, 1, 0, 1, 1);
gtk_widget_set_tooltip_text (priv->device_category, _("Select the device category to filter"));
for (i = 0; i < BLUETOOTH_CATEGORY_NUM_CATEGORIES; i++) {
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (priv->device_category),
_(bluetooth_device_category_to_string (i)));
}
g_signal_connect (G_OBJECT (priv->device_category), "changed",
G_CALLBACK (filter_category_changed_cb), self);
gtk_combo_box_set_active (GTK_COMBO_BOX (priv->device_category), priv->device_category_filter);
if (priv->show_device_category) {
gtk_widget_show (priv->device_category_label);
gtk_widget_show (priv->device_category);
}
/* The device type filter */
label = gtk_label_new_with_mnemonic (_("Device _type:"));
gtk_widget_set_no_show_all (label, TRUE);
gtk_widget_show (label);
gtk_grid_attach (GTK_GRID (table), label, 0, 1, 1, 1);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
priv->device_type_label = label;
priv->device_type_filter_model = GTK_TREE_MODEL (gtk_list_store_new (DEVICE_TYPE_FILTER_NUM_COLS,
G_TYPE_STRING, G_TYPE_INT));
priv->device_type = gtk_combo_box_new_with_model (priv->device_type_filter_model);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (priv->device_type), renderer, TRUE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (priv->device_type), renderer, "text", DEVICE_TYPE_FILTER_COL_NAME);
gtk_widget_set_no_show_all (priv->device_type, TRUE);
gtk_widget_show (priv->device_type);
gtk_grid_attach (GTK_GRID (table), priv->device_type, 1, 1, 1, 1);
gtk_widget_set_tooltip_text (priv->device_type, _("Select the device type to filter"));
gtk_list_store_insert_with_values (GTK_LIST_STORE (priv->device_type_filter_model), NULL, G_MAXUINT32,
DEVICE_TYPE_FILTER_COL_NAME, _(bluetooth_type_to_filter_string (BLUETOOTH_TYPE_ANY)),
DEVICE_TYPE_FILTER_COL_MASK, BLUETOOTH_TYPE_ANY,
-1);
gtk_list_store_insert_with_values (GTK_LIST_STORE (priv->device_type_filter_model), NULL, G_MAXUINT32,
DEVICE_TYPE_FILTER_COL_NAME, _("Input devices (mice, keyboards, etc.)"),
DEVICE_TYPE_FILTER_COL_MASK, BLUETOOTH_TYPE_INPUT,
-1);
gtk_list_store_insert_with_values (GTK_LIST_STORE (priv->device_type_filter_model), NULL, G_MAXUINT32,
DEVICE_TYPE_FILTER_COL_NAME, _("Headphones, headsets and other audio devices"),
DEVICE_TYPE_FILTER_COL_MASK, BLUETOOTH_TYPE_AUDIO,
-1);
/* The types match the types used in bluetooth-client.h */
for (i = 1; i < _BLUETOOTH_TYPE_NUM_TYPES; i++) {
int mask = 1 << i;
if (mask & BLUETOOTH_TYPE_INPUT || mask & BLUETOOTH_TYPE_AUDIO)
continue;
gtk_list_store_insert_with_values (GTK_LIST_STORE (priv->device_type_filter_model), NULL, G_MAXUINT32,
DEVICE_TYPE_FILTER_COL_NAME, _(bluetooth_type_to_filter_string (mask)),
DEVICE_TYPE_FILTER_COL_MASK, mask,
-1);
}
g_signal_connect (G_OBJECT (priv->device_type), "changed",
G_CALLBACK(filter_type_changed_cb), self);
set_combobox_from_filter (self);
if (priv->show_device_type) {
gtk_widget_show (priv->device_type_label);
gtk_widget_show (priv->device_type);
}
/* The services filter */
priv->device_service_filter = NULL;
gtk_widget_pop_composite_child ();
}
static void
activate (GtkApplication *app, gpointer user_data)
{
window = gtk_application_window_new (app);
gtk_window_set_title (GTK_WINDOW (window), "Smart House");
gtk_window_set_default_size (GTK_WINDOW (window), -1, -1);
clockLabel = gtk_label_new (NULL);
helpLabel = gtk_label_new ("help");
buttonPlay = gtk_button_new_with_label ("Play");
buttonStop = gtk_button_new_with_label ("Stop");
buttonClose = gtk_button_new_with_label("Close");
buttonConnect = gtk_button_new_with_label ("Connect");
buttonDevice1 = gtk_button_new_with_label ("Device1");
buttonDevice2 = gtk_button_new_with_label ("Device2");
buttonDevice3 = gtk_button_new_with_label ("Device3");
buttonDevice4 = gtk_button_new_with_label ("Device4");
/* Create a label to be shown in the window */
// label = gtk_label_new ("Choose a number");
/* Create an adjustment representing an adjustable bounded value */
adjustment1 = gtk_adjustment_new (0, 0, 100, 1, 0, 0);
adjustment2 = gtk_adjustment_new (0, 0, 100, 1, 0, 0);
adjustment3 = gtk_adjustment_new (0, 0, 100, 1, 0, 0);
adjustment4 = gtk_adjustment_new (0, 0, 100, 1, 0, 0);
/* Create a spin button that is to be as wide as possible */
spinButtonDevice1 = gtk_spin_button_new (adjustment1, 1, 0);
spinButtonDevice2 = gtk_spin_button_new (adjustment2, 1, 0);
spinButtonDevice3 = gtk_spin_button_new (adjustment3, 1, 0);
spinButtonDevice4 = gtk_spin_button_new (adjustment4, 1, 0);
gtk_widget_set_hexpand (spinButtonDevice1, TRUE);
gtk_widget_set_hexpand (spinButtonDevice2, TRUE);
gtk_widget_set_hexpand (spinButtonDevice3, TRUE);
gtk_widget_set_hexpand (spinButtonDevice4, TRUE);
/* Connecting the "value-changed" signal for the spinbutton
* to the appropriate callback function.
*/
grid = gtk_grid_new();
gtk_grid_attach (GTK_GRID (grid),buttonConnect,0,0,1,1);
gtk_grid_attach (GTK_GRID (grid),clockLabel,1,0,2,1);
// gtk_grid_attach_next_to(GTK_GRID (grid),clockLabel,buttonConnect,GTK_POS_RIGHT,1,1);
gtk_grid_attach (GTK_GRID (grid),buttonPlay,2,1,1,1);
gtk_grid_attach (GTK_GRID (grid),buttonStop,2,2,1,1);
gtk_grid_attach (GTK_GRID (grid),buttonClose,2,3,1,1);
// gtk_grid_attach_next_to(GTK_GRID (grid),buttonStop,buttonPlay,GTK_POS_RIGHT,1,1);
gtk_grid_attach (GTK_GRID (grid),buttonDevice1,0,1,1,1);
gtk_grid_attach (GTK_GRID (grid),buttonDevice2,0,2,1,1);
gtk_grid_attach (GTK_GRID (grid),buttonDevice3,0,3,1,1);
gtk_grid_attach (GTK_GRID (grid),buttonDevice4,0,4,1,1);
gtk_grid_attach (GTK_GRID (grid), spinButtonDevice1, 1, 1, 1, 1);
gtk_grid_attach (GTK_GRID (grid), spinButtonDevice2, 1, 2, 1, 1);
gtk_grid_attach (GTK_GRID (grid), spinButtonDevice3, 1, 3, 1, 1);
gtk_grid_attach (GTK_GRID (grid), spinButtonDevice4, 1, 4, 1, 1);
// gtk_grid_attach (GTK_GRID (grid),buttonClose,0,6,1,1);
// gtk_grid_attach_next_to(GTK_GRID (grid),helpLabel,buttonClose,GTK_POS_RIGHT,1,1);
gtk_grid_attach(GTK_GRID (grid),helpLabel,0,5,3,1);
// gtk_grid_attach(GTK_GRID (grid),clockLabel,0,8,2,1);
gtk_widget_set_size_request (buttonDevice1,100,10);
gtk_widget_set_size_request (buttonDevice2,100,10);
gtk_widget_set_size_request (buttonDevice3,100,10);
gtk_widget_set_size_request (buttonDevice4,100,10);
g_signal_connect (buttonClose, "clicked", G_CALLBACK (connect_function), NULL);
g_signal_connect_swapped (buttonClose, "clicked", G_CALLBACK (gtk_widget_destroy), window);
g_signal_connect (buttonConnect, "clicked", G_CALLBACK (connect_function), NULL);
g_signal_connect (buttonPlay, "clicked", G_CALLBACK (play_function), NULL);
g_signal_connect (buttonStop, "clicked", G_CALLBACK (stop_function), NULL);
g_signal_connect (buttonDevice1, "clicked", G_CALLBACK (button_function), NULL);
g_signal_connect (buttonDevice2, "clicked", G_CALLBACK (button_function), NULL);
g_signal_connect (buttonDevice3, "clicked", G_CALLBACK (button_function), NULL);
g_signal_connect (buttonDevice4, "clicked", G_CALLBACK (button_function), NULL);
gtk_container_add (GTK_CONTAINER (window), grid);
/* set timeout */
g_timeout_add (500, update_clock, (gpointer) clockLabel);
g_timeout_add (5000, check_network_connectivity, (gpointer) buttonConnect);
gtk_widget_show_all (window);
}
GtkWidget*
create_hooks_settings(SFLPhoneClient *client)
{
GtkWidget *ret, *frame, *label, *widg;
// Load the user value
hooks_load_parameters(&_urlhook_config);
ret = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width(GTK_CONTAINER(ret), 10);
GtkWidget *grid;
gnome_main_section_new_with_grid(_("URL Argument"), &frame, &grid);
gtk_box_pack_start(GTK_BOX(ret), frame, FALSE, FALSE, 0);
gtk_widget_show(frame);
gchar *message = "<small>Custom commands on incoming calls with URL. %s will be replaced with the passed URL.</small>";
GtkWidget *info_bar = gnome_info_bar(message, GTK_MESSAGE_INFO);
/* 2x1 */
gtk_grid_attach(GTK_GRID(grid), info_bar, 0, 0, 2, 1);
widg = gtk_check_button_new_with_mnemonic(_("Trigger on specific _SIP header"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widg), utf8_case_equal(_urlhook_config->sip_enabled, "true"));
g_signal_connect(G_OBJECT(widg) , "clicked" , G_CALLBACK(sip_enabled_cb), NULL);
gtk_grid_attach(GTK_GRID(grid), widg, 0, 2, 1, 1);
field = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(field), _urlhook_config->sip_field);
gtk_grid_attach(GTK_GRID(grid), field, 1, 2, 1, 1);
widg = gtk_check_button_new_with_mnemonic(_("Trigger on _IAX2 URL"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widg), utf8_case_equal(_urlhook_config->iax2_enabled, "true"));
g_signal_connect(G_OBJECT(widg) , "clicked" , G_CALLBACK(iax2_enabled_cb), NULL);
/* 2x1 */
gtk_grid_attach(GTK_GRID(grid), widg, 0, 3, 2, 1);
label = gtk_label_new_with_mnemonic(_("Command to _run"));
gtk_misc_set_alignment(GTK_MISC(label), 0.05, 0.5);
gtk_grid_attach(GTK_GRID(grid), label, 0, 4, 1, 1);
command = gtk_entry_new();
gtk_label_set_mnemonic_widget(GTK_LABEL(label), command);
gtk_entry_set_text(GTK_ENTRY(command), _urlhook_config->command);
gtk_grid_attach(GTK_GRID(grid), command, 1, 4, 1, 1);
gnome_main_section_new_with_grid(_("Phone number rewriting"), &frame, &grid);
gtk_box_pack_start(GTK_BOX(ret), frame, FALSE, FALSE, 0);
gtk_widget_show(frame);
widg = gtk_check_button_new_with_mnemonic(_("_Prefix dialed numbers with"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widg), utf8_case_equal(_urlhook_config->phone_number_enabled, "true"));
g_signal_connect(G_OBJECT(widg) , "clicked" , G_CALLBACK(phone_number_enabled_cb), NULL);
gtk_grid_attach(GTK_GRID(grid), widg, 0, 0, 1, 1);
prefix = gtk_entry_new();
gtk_label_set_mnemonic_widget(GTK_LABEL(label), prefix);
gtk_entry_set_text(GTK_ENTRY(prefix), _urlhook_config->phone_number_prefix);
gtk_widget_set_sensitive(GTK_WIDGET(prefix), gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widg)));
gtk_grid_attach(GTK_GRID(grid), prefix, 1, 0, 1, 1);
gnome_main_section_new_with_grid(_("Messaging"), &frame, &grid);
gtk_box_pack_start(GTK_BOX(ret), frame, FALSE, FALSE, 0);
gtk_widget_show(frame);
label = gtk_label_new_with_mnemonic(_("Open URL in"));
url = gtk_entry_new();
gchar *url_command = g_settings_get_string(client->settings, "messaging-url-command");
if (url_command && *url_command) {
gtk_entry_set_text(GTK_ENTRY(url), url_command);
g_free(url_command);
} else
gtk_entry_set_text(GTK_ENTRY(url), "xdg-open");
gtk_label_set_mnemonic_widget(GTK_LABEL(label), url);
gtk_grid_attach(GTK_GRID(grid), label, 0, 4, 1, 1);
gtk_grid_attach(GTK_GRID(grid), url, 1, 4, 1, 1);
gtk_widget_show_all(ret);
return ret;
}
GtkWidget *
go_distribution_pref_new (GObject *obj, GogDataAllocator *dalloc, G_GNUC_UNUSED GOCmdContext *cc)
{
GtkListStore *model;
GtkCellRenderer *renderer;
GtkTreeIter iter;
GParamSpec **props;
int n, i, j;
DistPrefs *prefs = g_new0 (DistPrefs, 1);
GtkWidget *res = gtk_grid_new ();
GtkWidget *w = gtk_label_new (_("Distribution:"));
GODistribution *dist = NULL;
GODistributionType dist_type;
prefs->dalloc = dalloc;
prefs->grid = GTK_GRID (res);
g_object_get (obj, "distribution", &dist, NULL);
g_return_val_if_fail (GO_IS_DISTRIBUTION (dist), NULL);
dist_type = go_distribution_get_distribution_type (dist);
g_object_set (res, "border-width", 12, "row-spacing", 12, "column-spacing", 24, NULL);
g_object_set (w, "xalign", 0., NULL);
gtk_grid_attach (prefs->grid, w, 0, 0, 1, 1);
g_signal_connect_swapped (res, "destroy", G_CALLBACK (destroy_cb), prefs);
prefs->client = obj;
/* add the list of known distributions in a combobox */
model = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
w = gtk_combo_box_new_with_model (GTK_TREE_MODEL (model));
g_object_unref (model);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (w), renderer, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (w), renderer,
"text", 0,
NULL);
for (i = 0; i < GO_DISTRIBUTION_MAX; i++) {
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter, 0, _(go_distribution_type_to_string (i)), 1, i, -1);
if (i == dist_type)
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (w), &iter);
}
g_signal_connect (w, "changed", G_CALLBACK (distribution_changed_cb), prefs);
gtk_grid_attach (prefs->grid, w, 1, 0, 1, 1);
/* other persistent properties */
i = 1;
props = g_object_class_list_properties (G_OBJECT_GET_CLASS (dist), &n);
for (j = 0; j < n; j++)
if (props[j]->flags & GO_PARAM_PERSISTENT) {
char *lbl = g_strconcat (_(g_param_spec_get_nick (props[j])), _(":"), NULL);
w = gtk_label_new (lbl);
g_free (lbl);
g_object_set (w, "xalign", 0., NULL);
gtk_grid_attach (prefs->grid, w, 0, i, 1, 1);
prefs->labels[i-1] = w;
prefs->props[i-1] = props[n];
w = GTK_WIDGET (gog_data_allocator_editor (dalloc, GOG_DATASET (obj), i - 1, GOG_DATA_SCALAR));
gtk_grid_attach (prefs->grid, w, 1, i, 1, 1);
prefs->data[i] = w;
i++;
}
g_free (props);
gtk_widget_show_all (res);
return res;
}
