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; }