static void wifi_private_init (CEPageWifi *self) { CEPageWifiPrivate *priv = CE_PAGE_WIFI_GET_PRIVATE (self); GtkBuilder *builder; GtkWidget *widget; GtkWidget *vbox; GtkLabel *label; builder = CE_PAGE (self)->builder; priv->group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); priv->ssid = GTK_ENTRY (gtk_builder_get_object (builder, "wifi_ssid")); priv->cloned_mac = GTK_ENTRY (gtk_builder_get_object (builder, "wifi_cloned_mac")); priv->mode = GTK_COMBO_BOX (gtk_builder_get_object (builder, "wifi_mode")); priv->band = GTK_COMBO_BOX (gtk_builder_get_object (builder, "wifi_band")); priv->channel = GTK_SPIN_BUTTON (gtk_builder_get_object (builder, "wifi_channel")); /* BSSID */ priv->bssid = GTK_COMBO_BOX_TEXT (gtk_combo_box_text_new_with_entry ()); gtk_combo_box_set_entry_text_column (GTK_COMBO_BOX (priv->bssid), 0); gtk_widget_set_tooltip_text (GTK_WIDGET (priv->bssid), _("This option locks this connection to the Wi-Fi access point (AP) specified by the BSSID entered here. Example: 00:11:22:33:44:55")); vbox = GTK_WIDGET (gtk_builder_get_object (builder, "wifi_bssid_vbox")); gtk_container_add (GTK_CONTAINER (vbox), GTK_WIDGET (priv->bssid)); gtk_widget_set_halign (GTK_WIDGET (priv->bssid), GTK_ALIGN_FILL); gtk_widget_show_all (GTK_WIDGET (priv->bssid)); /* Device MAC */ priv->device_combo = GTK_COMBO_BOX_TEXT (gtk_combo_box_text_new_with_entry ()); gtk_combo_box_set_entry_text_column (GTK_COMBO_BOX (priv->device_combo), 0); gtk_widget_set_tooltip_text (GTK_WIDGET (priv->device_combo), _("This option locks this connection to the network device specified " "either by its interface name or permanent MAC or both. Examples: " "\"wlan0\", \"3C:97:0E:42:1A:19\", \"wlan0 (3C:97:0E:42:1A:19)\"")); vbox = GTK_WIDGET (gtk_builder_get_object (builder, "wifi_device_vbox")); gtk_container_add (GTK_CONTAINER (vbox), GTK_WIDGET (priv->device_combo)); gtk_widget_set_halign (GTK_WIDGET (priv->device_combo), GTK_ALIGN_FILL); gtk_widget_show_all (GTK_WIDGET (priv->device_combo)); /* Set mnemonic widget for Device label */ label = GTK_LABEL (gtk_builder_get_object (builder, "wifi_device_label")); gtk_label_set_mnemonic_widget (label, GTK_WIDGET (priv->device_combo)); priv->rate = GTK_SPIN_BUTTON (gtk_builder_get_object (builder, "wifi_rate")); widget = GTK_WIDGET (gtk_builder_get_object (builder, "rate_units")); gtk_size_group_add_widget (priv->group, widget); priv->tx_power = GTK_SPIN_BUTTON (gtk_builder_get_object (builder, "wifi_tx_power")); widget = GTK_WIDGET (gtk_builder_get_object (builder, "tx_power_units")); gtk_size_group_add_widget (priv->group, widget); priv->mtu = GTK_SPIN_BUTTON (gtk_builder_get_object (builder, "wifi_mtu")); widget = GTK_WIDGET (gtk_builder_get_object (builder, "mtu_units")); gtk_size_group_add_widget (priv->group, widget); }
static GObject * gtk_combo_box_text_constructor (GType type, guint n_construct_properties, GObjectConstructParam *construct_properties) { GObject *object; const gint text_column = 0; object = G_OBJECT_CLASS (gtk_combo_box_text_parent_class)->constructor (type, n_construct_properties, construct_properties); gtk_combo_box_set_entry_text_column (GTK_COMBO_BOX (object), text_column); gtk_combo_box_set_id_column (GTK_COMBO_BOX (object), 1); if (!gtk_combo_box_get_has_entry (GTK_COMBO_BOX (object))) { GtkCellRenderer *cell; cell = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (object), cell, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (object), cell, "text", text_column, NULL); } return object; }
static void enterprise_init (UmAccountDialog *self, GtkBuilder *builder) { GtkWidget *widget; self->enterprise_realms = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_OBJECT); widget = (GtkWidget *) gtk_builder_get_object (builder, "enterprise-domain"); g_signal_connect (widget, "changed", G_CALLBACK (on_domain_changed), self); self->enterprise_domain = GTK_COMBO_BOX (widget); gtk_combo_box_set_model (self->enterprise_domain, GTK_TREE_MODEL (self->enterprise_realms)); gtk_combo_box_set_entry_text_column (self->enterprise_domain, 0); self->enterprise_domain_entry = GTK_ENTRY (gtk_bin_get_child (GTK_BIN (widget))); widget = (GtkWidget *) gtk_builder_get_object (builder, "enterprise-login"); g_signal_connect (widget, "changed", G_CALLBACK (on_entry_changed), self); self->enterprise_login = GTK_ENTRY (widget); widget = (GtkWidget *) gtk_builder_get_object (builder, "enterprise-password"); g_signal_connect (widget, "changed", G_CALLBACK (on_entry_changed), self); self->enterprise_password = GTK_ENTRY (widget); /* Initially we hide the 'Enterprise Login' stuff */ widget = (GtkWidget *) gtk_builder_get_object (builder, "enterprise-button"); self->enterprise_button = widget; gtk_widget_hide (widget); self->realmd_watch = g_bus_watch_name (G_BUS_TYPE_SYSTEM, "org.freedesktop.realmd", G_BUS_NAME_WATCHER_FLAGS_AUTO_START, on_realmd_appeared, on_realmd_disappeared, self, NULL); }
static void wired_private_init (CEPageWired *self) { CEPageWiredPrivate *priv = CE_PAGE_WIRED_GET_PRIVATE (self); GtkBuilder *builder; GtkWidget *align; GtkLabel *label; builder = CE_PAGE (self)->builder; #if GTK_CHECK_VERSION(2,24,0) priv->device_mac = GTK_COMBO_BOX_TEXT (gtk_combo_box_text_new_with_entry ()); gtk_combo_box_set_entry_text_column (GTK_COMBO_BOX (priv->device_mac), 0); #else priv->device_mac = GTK_COMBO_BOX_ENTRY (gtk_combo_box_entry_new_text ()); gtk_combo_box_entry_set_text_column (GTK_COMBO_BOX_ENTRY (priv->device_mac), 0); #endif gtk_widget_set_tooltip_text (GTK_WIDGET (priv->device_mac), _("This option locks this connection to the network device specified by its permanent MAC address entered here. Example: 00:11:22:33:44:55")); align = GTK_WIDGET (gtk_builder_get_object (builder, "wired_device_mac_alignment")); gtk_container_add (GTK_CONTAINER (align), GTK_WIDGET (priv->device_mac)); gtk_widget_show_all (GTK_WIDGET (priv->device_mac)); /* Set mnemonic widget for device MAC label */ label = GTK_LABEL (GTK_WIDGET (gtk_builder_get_object (builder, "wired_device_mac_label"))); gtk_label_set_mnemonic_widget (label, GTK_WIDGET (priv->device_mac)); priv->cloned_mac = GTK_ENTRY (GTK_WIDGET (gtk_builder_get_object (builder, "wired_cloned_mac"))); priv->port = GTK_COMBO_BOX (GTK_WIDGET (gtk_builder_get_object (builder, "wired_port"))); priv->speed = GTK_COMBO_BOX (GTK_WIDGET (gtk_builder_get_object (builder, "wired_speed"))); priv->duplex = GTK_TOGGLE_BUTTON (GTK_WIDGET (gtk_builder_get_object (builder, "wired_duplex"))); priv->autonegotiate = GTK_TOGGLE_BUTTON (GTK_WIDGET (gtk_builder_get_object (builder, "wired_autonegotiate"))); priv->mtu = GTK_SPIN_BUTTON (GTK_WIDGET (gtk_builder_get_object (builder, "wired_mtu"))); }
static void vlan_private_init (CEPageVlan *self) { CEPageVlanPrivate *priv = CE_PAGE_VLAN_GET_PRIVATE (self); GtkBuilder *builder; GtkWidget *align; GtkLabel *label; builder = CE_PAGE (self)->builder; #if GTK_CHECK_VERSION(2,24,0) priv->parent = GTK_COMBO_BOX (gtk_combo_box_text_new_with_entry ()); gtk_combo_box_set_entry_text_column (priv->parent, 0); #else priv->parent = GTK_COMBO_BOX (gtk_combo_box_entry_new_text ()); gtk_combo_box_entry_set_text_column (GTK_COMBO_BOX_ENTRY (priv->parent), 0); #endif priv->parent_entry = GTK_ENTRY (gtk_bin_get_child (GTK_BIN (priv->parent))); align = GTK_WIDGET (gtk_builder_get_object (builder, "vlan_parent_alignment")); gtk_container_add (GTK_CONTAINER (align), GTK_WIDGET (priv->parent)); gtk_widget_show_all (GTK_WIDGET (priv->parent)); /* Set mnemonic widget for parent label */ label = GTK_LABEL (GTK_WIDGET (gtk_builder_get_object (builder, "vlan_parent_label"))); gtk_label_set_mnemonic_widget (label, GTK_WIDGET (priv->parent)); priv->id_entry = GTK_SPIN_BUTTON (GTK_WIDGET (gtk_builder_get_object (builder, "vlan_id_entry"))); priv->name_entry = GTK_ENTRY (GTK_WIDGET (gtk_builder_get_object (builder, "vlan_name_entry"))); priv->cloned_mac = GTK_ENTRY (GTK_WIDGET (gtk_builder_get_object (builder, "vlan_cloned_mac_entry"))); priv->mtu = GTK_SPIN_BUTTON (GTK_WIDGET (gtk_builder_get_object (builder, "vlan_mtu"))); }
/* Create a new GNCCurrencyEdit widget which can be used to provide * an easy way to enter ISO currency codes. * * @return A GNCCurrencyEdit widget. */ GtkWidget * gnc_currency_edit_new (void) { GNCCurrencyEdit *gce; GtkListStore *store; store = gtk_list_store_new (1, G_TYPE_STRING); gce = g_object_new (GNC_TYPE_CURRENCY_EDIT, "model", store, "has-entry", TRUE, NULL); g_object_unref (store); /* Set the column for the text */ gtk_combo_box_set_entry_text_column (GTK_COMBO_BOX(gce), 0); /* Now the signals to make sure the user can't leave the widget without a valid currency. */ gnc_cbwe_require_list_item(GTK_COMBO_BOX(gce)); /* Fill in all the data. */ fill_currencies (gce); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE(store), 0, GTK_SORT_ASCENDING); return GTK_WIDGET (gce); }
void glade_gtk_combo_box_set_property (GladeWidgetAdaptor * adaptor, GObject * object, const gchar * id, const GValue * value) { if (!strcmp (id, "entry-text-column")) { /* Avoid warnings */ if (g_value_get_int (value) >= 0) GWA_GET_CLASS (GTK_TYPE_CONTAINER)->set_property (adaptor, object, id, value); } else if (!strcmp (id, "text-column")) { if (g_value_get_int (value) >= 0) gtk_combo_box_set_entry_text_column (GTK_COMBO_BOX (object), g_value_get_int (value)); } else if (!strcmp (id, "add-tearoffs")) { GladeWidget *widget = glade_widget_get_from_gobject (object); if (g_value_get_boolean (value)) glade_widget_property_set_sensitive (widget, "tearoff-title", TRUE, NULL); else glade_widget_property_set_sensitive (widget, "tearoff-title", FALSE, _("Tearoff menus are disabled")); } else GWA_GET_CLASS (GTK_TYPE_CONTAINER)->set_property (adaptor, object, id, value); }
void iio_combo_box_init(struct iio_widget *widget, struct iio_device *dev, struct iio_channel *chn, const char *attr_name, const char *attr_name_avail, GtkWidget *combo_box, int (*compare)(const char *a, const char *b)) { iio_widget_init(widget, dev, chn, attr_name, attr_name_avail, combo_box, (void *)compare, iio_combo_box_update, iio_combo_box_update_value, iio_combo_box_save); gtk_combo_box_set_entry_text_column(GTK_COMBO_BOX(widget->widget), 0); }
static GtkWidget* combobox_entry_new(GtkTreeModel* model) { GtkWidget* combobox; #if HAVE_COMBO_BOX_ENTRY combobox = gtk_combo_box_entry_new_with_model(model, ENCODING_COLUMN_ENCODING); #else combobox = gtk_combo_box_new_with_model_and_entry(model); gtk_combo_box_set_entry_text_column(GTK_COMBO_BOX(combobox), ENCODING_COLUMN_ENCODING); #endif return combobox; }
static void panel_run_dialog_setup_entry (PanelRunDialog *dialog, GtkBuilder *gui) { GdkScreen *screen; int width_request; GtkWidget *entry; dialog->combobox = PANEL_GTK_BUILDER_GET (gui, "comboboxentry"); entry = gtk_bin_get_child (GTK_BIN (dialog->combobox)); gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE); gtk_combo_box_set_model (GTK_COMBO_BOX (dialog->combobox), _panel_run_get_recent_programs_list (dialog)); gtk_combo_box_set_entry_text_column (GTK_COMBO_BOX (dialog->combobox), 0); screen = gtk_window_get_screen (GTK_WINDOW (dialog->run_dialog)); /* 1/4 the width of the first monitor should be a good value */ width_request = panel_multiscreen_width (screen, 0) / 4; g_object_set (G_OBJECT (dialog->combobox), "width_request", width_request, NULL); g_signal_connect (entry, "key-press-event", G_CALLBACK (entry_event), dialog); dialog->changed_id = g_signal_connect (dialog->combobox, "changed", G_CALLBACK (combobox_changed), dialog); gtk_drag_dest_unset (dialog->combobox); gtk_drag_dest_set (dialog->combobox, GTK_DEST_DEFAULT_MOTION|GTK_DEST_DEFAULT_HIGHLIGHT, NULL, 0, GDK_ACTION_COPY); gtk_drag_dest_add_uri_targets (dialog->combobox); g_signal_connect (dialog->combobox, "drag_data_received", G_CALLBACK (entry_drag_data_received), dialog); }
static void setup_combo (VinagreConnectDialog *dialog) { GtkListStore *store; GtkEntryCompletion *completion; GPtrArray *history; gint i, size; GtkEntry *entry; entry = GTK_ENTRY (gtk_bin_get_child (GTK_BIN (dialog->host_entry))); store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING); history = saved_history (); g_object_get (vinagre_prefs_get_default (), "history-size", &size, NULL); if (size <= 0) size = G_MAXINT; for (i=history->len-1; i>=0 && i>=(gint)history->len-size; i--) { GtkTreeIter iter; gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, COLUMN_TEXT, g_ptr_array_index (history, i), -1); } g_ptr_array_free (history, TRUE); gtk_combo_box_set_model (GTK_COMBO_BOX (dialog->host_entry), GTK_TREE_MODEL (store)); gtk_combo_box_set_entry_text_column (GTK_COMBO_BOX (dialog->host_entry), 0); completion = gtk_entry_completion_new (); gtk_entry_completion_set_model (completion, GTK_TREE_MODEL (store)); gtk_entry_completion_set_text_column (completion, 0); gtk_entry_completion_set_inline_completion (completion, TRUE); gtk_entry_set_completion (entry, completion); g_object_unref (completion); gtk_entry_set_activates_default (entry, TRUE); g_signal_connect (entry, "changed", G_CALLBACK (control_connect_button), dialog); }
static void gw_addvocabularywindow_init_combobox (GwAddVocabularyWindow *window) { GwAddVocabularyWindowPrivate *priv; GwAddVocabularyWindowClass *klass; GwApplication *application; GtkListStore *store; GtkTreeModel *model; priv = window->priv; klass = GW_ADDVOCABULARYWINDOW_CLASS (G_OBJECT_GET_CLASS (window)); application = gw_window_get_application (GW_WINDOW (window)); store = gw_application_get_vocabularyliststore (application); model = GTK_TREE_MODEL (store); //Initialize the combobox gtk_combo_box_set_model (priv->vocabulary_list_combobox, model); //Remove the default entry since it doesn't seem to be editable for some reason priv->list_entry = GTK_ENTRY (gtk_bin_get_child (GTK_BIN (priv->vocabulary_list_combobox))); gtk_widget_destroy (GTK_WIDGET (priv->list_entry)); //Add our entry priv->list_entry = GTK_ENTRY (gtk_entry_new ()); gtk_entry_set_activates_default (priv->list_entry, TRUE); g_signal_connect (G_OBJECT (priv->list_entry), "changed", G_CALLBACK (gw_addvocabularywindow_list_changed_cb), window); gtk_widget_show (GTK_WIDGET (priv->list_entry)); gtk_combo_box_set_entry_text_column (priv->vocabulary_list_combobox, GW_VOCABULARYLISTSTORE_COLUMN_NAME); gtk_container_add (GTK_CONTAINER (priv->vocabulary_list_combobox), GTK_WIDGET (priv->list_entry)); //Set the correct initial selection if (klass->last_selected_list_name != NULL) { gtk_entry_set_text (priv->list_entry, klass->last_selected_list_name); } else { gtk_combo_box_set_active (priv->vocabulary_list_combobox, 0); } gtk_editable_select_region (GTK_EDITABLE (priv->list_entry), 0, 0); }
static void gtk_combo_box_text_constructed (GObject *object) { const gint text_column = 0; G_OBJECT_CLASS (gtk_combo_box_text_parent_class)->constructed (object); gtk_combo_box_set_entry_text_column (GTK_COMBO_BOX (object), text_column); gtk_combo_box_set_id_column (GTK_COMBO_BOX (object), 1); if (!gtk_combo_box_get_has_entry (GTK_COMBO_BOX (object))) { GtkCellRenderer *cell; cell = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (object), cell, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (object), cell, "text", text_column, NULL); } }
void wxBitmapComboBox::GTKCreateComboBoxWidget() { GtkListStore *store; store = gtk_list_store_new( 2, G_TYPE_OBJECT, G_TYPE_STRING ); if ( HasFlag(wxCB_READONLY) ) { m_widget = gtk_combo_box_new_with_model( GTK_TREE_MODEL(store) ); } else { #ifdef __WXGTK3__ m_widget = gtk_combo_box_new_with_model_and_entry(GTK_TREE_MODEL(store)); gtk_combo_box_set_entry_text_column(GTK_COMBO_BOX(m_widget), m_stringCellIndex); #else m_widget = gtk_combo_box_entry_new_with_model( GTK_TREE_MODEL(store), m_stringCellIndex ); #endif m_entry = GTK_ENTRY(gtk_bin_get_child(GTK_BIN(m_widget))); gtk_editable_set_editable(GTK_EDITABLE(m_entry), true); } g_object_ref(m_widget); // This must be called as gtk_combo_box_entry_new_with_model adds // automatically adds one text column. gtk_cell_layout_clear( GTK_CELL_LAYOUT(m_widget) ); GtkCellRenderer* imageRenderer = gtk_cell_renderer_pixbuf_new(); gtk_cell_layout_pack_start( GTK_CELL_LAYOUT(m_widget), imageRenderer, FALSE); gtk_cell_layout_add_attribute( GTK_CELL_LAYOUT(m_widget), imageRenderer, "pixbuf", 0); GtkCellRenderer* textRenderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_end( GTK_CELL_LAYOUT(m_widget), textRenderer, TRUE ); gtk_cell_layout_add_attribute( GTK_CELL_LAYOUT(m_widget), textRenderer, "text", 1); }
void dlg_export_to_flickr (FlickrServer *server, GthBrowser *browser, GList *file_list) { DialogData *data; GList *scan; int n_total; goffset total_size; char *total_size_formatted; char *text; char *title; data = g_new0 (DialogData, 1); data->server = server; data->browser = browser; data->settings = g_settings_new (GTHUMB_FLICKR_SCHEMA); data->location = gth_file_data_dup (gth_browser_get_location_data (browser)); data->builder = _gtk_builder_new_from_file ("export-to-flickr.ui", "flicker_utils"); data->cancellable = g_cancellable_new (); data->dialog = g_object_new (GTK_TYPE_DIALOG, "transient-for", GTK_WINDOW (browser), "modal", FALSE, "destroy-with-parent", FALSE, "use-header-bar", _gtk_settings_get_dialogs_use_header (), NULL); gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (data->dialog))), _gtk_builder_get_widget (data->builder, "dialog_content")); gtk_dialog_add_buttons (GTK_DIALOG (data->dialog), _GTK_LABEL_CANCEL, GTK_RESPONSE_CANCEL, _GTK_LABEL_UPLOAD, GTK_RESPONSE_OK, NULL); _gtk_dialog_add_class_to_response (GTK_DIALOG (data->dialog), GTK_RESPONSE_OK, GTK_STYLE_CLASS_SUGGESTED_ACTION); { GtkCellLayout *cell_layout; GtkCellRenderer *renderer; data->photoset_combobox = gtk_combo_box_new_with_model_and_entry (GTK_TREE_MODEL (GET_WIDGET ("photoset_liststore"))); gtk_combo_box_set_entry_text_column (GTK_COMBO_BOX (data->photoset_combobox), PHOTOSET_TITLE_COLUMN); gtk_widget_show (data->photoset_combobox); gtk_container_add (GTK_CONTAINER (GET_WIDGET ("photoset_combobox_container")), data->photoset_combobox); cell_layout = GTK_CELL_LAYOUT (data->photoset_combobox); gtk_cell_layout_clear (cell_layout); renderer = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (cell_layout, renderer, FALSE); gtk_cell_layout_set_attributes (cell_layout, renderer, "icon-name", PHOTOSET_ICON_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (cell_layout, renderer, TRUE); gtk_cell_layout_set_attributes (cell_layout, renderer, "text", PHOTOSET_TITLE_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (cell_layout, renderer, FALSE); gtk_cell_layout_set_attributes (cell_layout, renderer, "text", PHOTOSET_N_PHOTOS_COLUMN, NULL); } data->file_list = NULL; n_total = 0; total_size = 0; for (scan = file_list; scan; scan = scan->next) { GthFileData *file_data = scan->data; const char *mime_type; mime_type = gth_file_data_get_mime_type (file_data); if (g_content_type_equals (mime_type, "image/bmp") || g_content_type_equals (mime_type, "image/gif") || g_content_type_equals (mime_type, "image/jpeg") || g_content_type_equals (mime_type, "image/png")) { total_size += g_file_info_get_size (file_data->info); n_total++; data->file_list = g_list_prepend (data->file_list, g_object_ref (file_data)); } } data->file_list = g_list_reverse (data->file_list); if (data->file_list == NULL) { GError *error; error = g_error_new_literal (GTH_ERROR, GTH_ERROR_GENERIC, _("No valid file selected.")); _gtk_error_dialog_from_gerror_show (GTK_WINDOW (browser), _("Could not export the files"), error); g_clear_error (&error); gtk_dialog_response (GTK_DIALOG (data->dialog), GTK_RESPONSE_DELETE_EVENT); return; } total_size_formatted = g_format_size (total_size); text = g_strdup_printf (g_dngettext (NULL, "%d file (%s)", "%d files (%s)", n_total), n_total, total_size_formatted); gtk_label_set_text (GTK_LABEL (GET_WIDGET ("images_info_label")), text); g_free (text); g_free (total_size_formatted); _gtk_window_resize_to_fit_screen_height (data->dialog, 500); /* Set the widget data */ data->list_view = gth_file_list_new (gth_grid_view_new (), GTH_FILE_LIST_MODE_NO_SELECTION, FALSE); gth_file_list_set_thumb_size (GTH_FILE_LIST (data->list_view), 112); gth_file_list_enable_thumbs (GTH_FILE_LIST (data->list_view), TRUE); gth_file_list_set_ignore_hidden (GTH_FILE_LIST (data->list_view), TRUE); gth_file_list_set_caption (GTH_FILE_LIST (data->list_view), "none"); gth_file_list_set_sort_func (GTH_FILE_LIST (data->list_view), gth_main_get_sort_type ("file::name")->cmp_func, FALSE); gtk_widget_show (data->list_view); gtk_box_pack_start (GTK_BOX (GET_WIDGET ("images_box")), data->list_view, TRUE, TRUE, 0); gth_file_list_set_files (GTH_FILE_LIST (data->list_view), data->file_list); gtk_entry_set_text (GTK_ENTRY (gtk_bin_get_child (GTK_BIN (data->photoset_combobox))), g_file_info_get_edit_name (data->location->info)); gtk_dialog_set_response_sensitive (GTK_DIALOG (data->dialog), GTK_RESPONSE_OK, FALSE); title = g_strdup_printf (_("Export to %s"), data->server->name); gtk_window_set_title (GTK_WINDOW (data->dialog), title); g_free (title); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("resize_checkbutton")), g_settings_get_int (data->settings, PREF_FLICKR_RESIZE_WIDTH) != -1); _gtk_combo_box_add_image_sizes (GTK_COMBO_BOX (GET_WIDGET ("resize_combobox")), g_settings_get_int (data->settings, PREF_FLICKR_RESIZE_WIDTH), g_settings_get_int (data->settings, PREF_FLICKR_RESIZE_HEIGHT)); /* Set the signals handlers. */ g_signal_connect (data->dialog, "delete-event", G_CALLBACK (gtk_true), NULL); g_signal_connect (data->dialog, "response", G_CALLBACK (export_dialog_response_cb), data); g_signal_connect (GET_WIDGET ("edit_accounts_button"), "clicked", G_CALLBACK (edit_accounts_button_clicked_cb), data); g_signal_connect (GET_WIDGET ("account_combobox"), "changed", G_CALLBACK (account_combobox_changed_cb), data); g_signal_connect (GET_WIDGET ("resize_checkbutton"), "toggled", G_CALLBACK (resize_checkbutton_toggled_cb), data); update_sensitivity (data); data->service = flickr_service_new (server, data->cancellable, GTK_WIDGET (data->browser), data->dialog); g_signal_connect (data->service, "account-ready", G_CALLBACK (authentication_ready_cb), data); g_signal_connect (data->service, "accounts-changed", G_CALLBACK (authentication_accounts_changed_cb), data); data->progress_dialog = gth_progress_dialog_new (GTK_WINDOW (data->browser)); gth_progress_dialog_add_task (GTH_PROGRESS_DIALOG (data->progress_dialog), GTH_TASK (data->service), GTH_TASK_FLAGS_DEFAULT); web_service_autoconnect (WEB_SERVICE (data->service)); }
void connection_dialog(gboolean auto_connect) { gint i; connecting = NULL; wait_for_tuner = FALSE; dialog = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(dialog), "Connect"); gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(ui.window)); gtk_window_set_modal(GTK_WINDOW(dialog), TRUE); gtk_window_set_destroy_with_parent(GTK_WINDOW(dialog), TRUE); gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE); gtk_container_set_border_width(GTK_CONTAINER(dialog), 5); g_signal_connect(dialog, "destroy", G_CALLBACK(connection_dialog_destroy), NULL); content = gtk_vbox_new(FALSE, 3); gtk_container_add(GTK_CONTAINER(dialog), content); r_serial = gtk_radio_button_new_with_label(NULL, "Serial port"); gtk_box_pack_start(GTK_BOX(content), r_serial, TRUE, TRUE, 2); c_serial = gtk_combo_box_text_new(); #ifdef G_OS_WIN32 gchar tmp[10]; for(i=1; i<=20; i++) { g_snprintf(tmp, sizeof(tmp), "COM%d", i); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(c_serial), tmp); if(g_ascii_strcasecmp(tmp, conf.serial) == 0) { gtk_combo_box_set_active(GTK_COMBO_BOX(c_serial), i-1); } } #else struct dirent *dir; DIR *d = opendir("/dev"); i=0; if(d) { while((dir = readdir(d))) { #ifdef __APPLE__ if(!strncmp(dir->d_name, "cu.usbserial", 12)) #else if(!strncmp(dir->d_name, "ttyUSB", 6) || !strncmp(dir->d_name, "ttyACM", 6) || !strncmp(dir->d_name, "ttyS", 4) || !strncmp(dir->d_name, "rfcomm", 6)) #endif { gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(c_serial), dir->d_name); if(g_ascii_strcasecmp(dir->d_name, conf.serial) == 0) { gtk_combo_box_set_active(GTK_COMBO_BOX(c_serial), i); } i++; } } closedir(d); } #endif g_signal_connect(c_serial, "changed", G_CALLBACK(connection_dialog_select), r_serial); gtk_box_pack_start(GTK_BOX(content), c_serial, TRUE, TRUE, 0); r_tcp = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(r_serial), "TCP/IP"); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(r_tcp), conf.network); gtk_box_pack_start(GTK_BOX(content), r_tcp, TRUE, TRUE, 2); box_tcp1 = gtk_hbox_new(FALSE, 5); gtk_container_add(GTK_CONTAINER(content), box_tcp1); l_host = gtk_label_new("Host:"); gtk_box_pack_start(GTK_BOX(box_tcp1), l_host, TRUE, FALSE, 1); ls_host = gtk_list_store_new(1, G_TYPE_STRING); if(conf.host) { for(i=0; conf.host[i]; i++) { GtkTreeIter iter; gtk_list_store_append(ls_host, &iter); gtk_list_store_set(ls_host, &iter, 0, conf.host[i], -1); } } e_host = gtk_combo_box_new_with_model_and_entry(GTK_TREE_MODEL(ls_host)); gtk_combo_box_set_entry_text_column(GTK_COMBO_BOX(e_host), 0); gtk_combo_box_set_active(GTK_COMBO_BOX(e_host), 0); g_signal_connect(e_host, "changed", G_CALLBACK(connection_dialog_select), r_tcp); gtk_box_pack_start(GTK_BOX(box_tcp1), e_host, TRUE, FALSE, 1); l_port = gtk_label_new("Port:"); gtk_box_pack_start(GTK_BOX(box_tcp1), l_port, TRUE, FALSE, 1); e_port = gtk_entry_new_with_max_length(5); gtk_entry_set_width_chars(GTK_ENTRY(e_port), 5); gchar *s_port = g_strdup_printf("%d", conf.port); gtk_entry_set_text(GTK_ENTRY(e_port), s_port); g_free(s_port); g_signal_connect(e_port, "changed", G_CALLBACK(connection_dialog_select), r_tcp); gtk_box_pack_start(GTK_BOX(box_tcp1), e_port, TRUE, FALSE, 1); box_tcp2 = gtk_hbox_new(FALSE, 5); gtk_container_add(GTK_CONTAINER(content), box_tcp2); l_password = gtk_label_new("Password:"******"changed", G_CALLBACK(connection_dialog_select), r_tcp); gtk_box_pack_start(GTK_BOX(box_tcp2), e_password, TRUE, TRUE, 1); c_password = gtk_check_button_new_with_label("Keep"); if(conf.password && strlen(conf.password)) { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(c_password), TRUE); } g_signal_connect(c_password, "toggled", G_CALLBACK(connection_dialog_select), r_tcp); gtk_box_pack_start(GTK_BOX(box_tcp2), c_password, FALSE, FALSE, 1); box_status_wrapper = gtk_hbox_new(TRUE, 5); gtk_box_pack_start(GTK_BOX(content), box_status_wrapper, FALSE, FALSE, 1); box_status = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(box_status_wrapper), box_status, FALSE, FALSE, 1); spinner = gtk_spinner_new(); gtk_box_pack_start(GTK_BOX(box_status), spinner, FALSE, FALSE, 1); l_status = gtk_label_new(NULL); gtk_box_pack_start(GTK_BOX(box_status), l_status, FALSE, FALSE, 1); box_button = gtk_hbutton_box_new(); gtk_button_box_set_layout(GTK_BUTTON_BOX(box_button), GTK_BUTTONBOX_END); gtk_box_set_spacing(GTK_BOX(box_button), 5); gtk_box_pack_start(GTK_BOX(content), box_button, FALSE, FALSE, 5); b_connect = gtk_button_new_from_stock(GTK_STOCK_OK); g_signal_connect(dialog, "key-press-event", G_CALLBACK(connection_dialog_key), b_connect); g_signal_connect(b_connect, "clicked", G_CALLBACK(connection_dialog_connect), NULL); gtk_container_add(GTK_CONTAINER(box_button), b_connect); b_cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL); g_signal_connect_swapped(b_cancel, "clicked", G_CALLBACK(gtk_widget_destroy), dialog); gtk_container_add(GTK_CONTAINER(box_button), b_cancel); #ifdef G_OS_WIN32 if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ui.b_ontop))) { gtk_window_set_keep_above(GTK_WINDOW(dialog), TRUE); } #endif gtk_widget_show_all(dialog); gtk_widget_hide(spinner); gtk_widget_hide(l_status); connect_button(FALSE); if(auto_connect || (conf.auto_reconnect && successfully_connected)) { gtk_button_clicked(GTK_BUTTON(b_connect)); } }
// fill_drives_list: retrieves available cd drives. At the moment it use a quite // ugly "brute force" method: we check for the most common location for cdrom // in /dev and chech if they are cdrom devices. // If your cdrom path is not listed here you'll have to type it in the dialog // entry yourself (or add it here and recompile). // Are there any other common entry to add to the list? (especially scsi, I // deliberately ignored old non standard cdroms... ) // If you come up with a better method let me know!! void fill_drives_list(GtkWidget *widget) { int i; GtkListStore *store; GtkTreeIter iter; #if defined (__linux__) static const char *cdrom_devices[] = { "/dev/cdrom", "/dev/cdrom0", "/dev/cdrom1", "/dev/cdrom2", "/dev/cdrom3", "/dev/cdroms/cdrom0", "/dev/cdroms/cdrom1", "/dev/cdroms/cdrom2", "/dev/cdroms/cdrom3", "/dev/hda", "/dev/hdb", "/dev/hdc", "/dev/hdd", "/dev/sda", "/dev/sdb", "/dev/sdc", "/dev/sdd", "/dev/scd0", "/dev/scd1", "/dev/scd2", "/dev/scd3", "/dev/optcd", ""}; #elif defined (__FreeBSD__) static const char *cdrom_devices[] = { "/dev/cd0", "/dev/cd1", "/dev/cd2", "/dev/cd3", ""}; #elif defined (__sun) char cdrom_devices[256][256]; FILE *fp; char buf[256], *devname, *nick; memset(cdrom_devices, 0, sizeof(cdrom_devices)); i = 0; fp = popen("eject -l", "r"); if (fp != NULL) { while (!feof(fp) && i < 256) { fgets(buf, 256, fp); devname = strtok(buf, " "); nick = strtok(NULL, " "); if (devname == NULL || nick == NULL) continue; if (strstr(nick, "cdrom") != NULL) { strcpy(cdrom_devices[i++], devname); } } pclose(fp); } #else static const char *cdrom_devices[] = { "" }; #endif store = gtk_list_store_new(1, G_TYPE_STRING); // first we put our current drive if (CdromDev[0] != '\0') { gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, 0, CdromDev, -1); } i = 0; // scan cdrom_devices for real cdrom and add them to list while (cdrom_devices[i][0] != '\0') { // check that is not our current dev (already in list) if (strcmp(cdrom_devices[i], CdromDev) != 0) { // check that is a cdrom device if (is_cdrom(cdrom_devices[i])) { gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, 0, cdrom_devices[i], -1); } } ++i; } gtk_combo_box_set_model(GTK_COMBO_BOX(widget), GTK_TREE_MODEL(store)); gtk_combo_box_set_entry_text_column(GTK_COMBO_BOX(widget), 0); }
int main(int argc, char*argv[]) { bindtextdomain ("testGtkGstreamer", "./locale"); bind_textdomain_codeset ("testGtkGstreamer", "UTF-8"); textdomain ("testGtkGstreamer"); setlocale(LC_ALL, ""); GtkWidget* window = NULL; GError *error = NULL; GOptionContext *context; // gtk_init(&argc, &argv); context = g_option_context_new (_("- a simple gtk gstreamer program")); g_option_context_add_main_entries (context, entries, "testGtkGstreamer"); g_option_context_add_group (context, gtk_get_option_group (TRUE)); if (!g_option_context_parse (context, &argc, &argv, &error)) { g_print ("option parsing failed: %s\n", error->message); exit (1); } gst_init (&argc, &argv); GtkBuilder* builder = gtk_builder_new_from_file("./main.ui"); gtk_builder_connect_signals(builder, builder); window = GTK_WIDGET(gtk_builder_get_object(builder, "mainWindow")); // g_signal_connect(window, "delete-event", G_CALLBACK(onWindowDeleteEvent), builder); // g_signal_connect(window, "destroy", G_CALLBACK(onDestoryed), builder); GtkWidget* video_area = GTK_WIDGET(gtk_builder_get_object(builder, "video_area")); g_signal_connect(video_area, "realize", G_CALLBACK(on_video_area_realize), builder); GtkWidget* playpausebtn = GTK_WIDGET(gtk_builder_get_object(builder, "video_play_pause")); GtkWidget* image = gtk_image_new_from_icon_name ("media-playback-start-symbolic", GTK_ICON_SIZE_MENU); gtk_button_set_image (GTK_BUTTON (playpausebtn), image); gtk_widget_set_valign (GTK_WIDGET (playpausebtn), GTK_ALIGN_CENTER); gtk_style_context_add_class (gtk_widget_get_style_context (playpausebtn), "image-button"); GtkWidget* hellobtn = GTK_WIDGET(gtk_builder_get_object(builder, "helloworld")); g_signal_connect(hellobtn, "clicked", G_CALLBACK(onButtonClicked), builder); GtkListStore* model = gtk_list_store_new(LIST_COLUMNS_N, G_TYPE_STRING, G_TYPE_STRING); int i = 0; for (i = 0; i < 50; i++) { GtkTreeIter iter; gtk_list_store_append(model, &iter); gtk_list_store_set(model, &iter, LIST_NO, g_strdup_printf("%d", i + 1), LIST_TITLE, g_strdup_printf("This is column %d", i + 1), -1); } GtkWidget* cb1 = GTK_WIDGET(gtk_builder_get_object(builder, "combobox")); gtk_combo_box_set_model(GTK_COMBO_BOX(cb1), GTK_TREE_MODEL(model)); gtk_combo_box_set_entry_text_column(GTK_COMBO_BOX(cb1), LIST_NO); gtk_widget_show_all(GTK_WIDGET(window)); gtk_widget_realize(GTK_WIDGET(video_area)); create_gst_pipline(); gst_element_set_state (g_pipeline, GST_STATE_PLAYING); gtk_main(); gst_element_set_state (g_pipeline, GST_STATE_NULL); gst_object_unref(GST_OBJECT(g_pipeline)); g_free(g_filename); return 0; }
static void gimp_scale_combo_box_constructed (GObject *object) { GimpScaleComboBox *combo_box = GIMP_SCALE_COMBO_BOX (object); GtkWidget *entry; GtkListStore *store; GtkCellLayout *layout; GtkCellRenderer *cell; GtkTreeIter iter; GtkBorder border = { 0, 0, 0, 0 }; gint i; G_OBJECT_CLASS (parent_class)->constructed (object); store = gtk_list_store_new (N_COLUMNS, G_TYPE_DOUBLE, /* SCALE */ G_TYPE_STRING, /* LABEL */ G_TYPE_BOOLEAN); /* PERSISTENT */ gtk_combo_box_set_model (GTK_COMBO_BOX (combo_box), GTK_TREE_MODEL (store)); g_object_unref (store); gtk_combo_box_set_entry_text_column (GTK_COMBO_BOX (combo_box), COLUMN_LABEL); entry = gtk_bin_get_child (GTK_BIN (combo_box)); g_object_set (entry, "xalign", 1.0, "width-chars", 7, "truncate-multiline", TRUE, "inner-border", &border, NULL); layout = GTK_CELL_LAYOUT (combo_box); cell = g_object_new (GTK_TYPE_CELL_RENDERER_TEXT, "xalign", 1.0, NULL); gtk_cell_layout_clear (layout); gtk_cell_layout_pack_start (layout, cell, TRUE); gtk_cell_layout_set_attributes (layout, cell, "text", COLUMN_LABEL, NULL); for (i = 8; i > 0; i /= 2) { gtk_list_store_append (store, &iter); gimp_scale_combo_box_scale_iter_set (store, &iter, i, TRUE); } for (i = 2; i <= 8; i *= 2) { gtk_list_store_append (store, &iter); gimp_scale_combo_box_scale_iter_set (store, &iter, 1.0 / i, TRUE); } g_signal_connect (combo_box, "changed", G_CALLBACK (gimp_scale_combo_box_changed), NULL); g_signal_connect (entry, "activate", G_CALLBACK (gimp_scale_combo_box_entry_activate), combo_box); g_signal_connect (entry, "key-press-event", G_CALLBACK (gimp_scale_combo_box_entry_key_press), combo_box); }
GtkWidget* create_tool_item( GtkAction* action ) { GtkWidget* item = 0; if ( IS_EGE_SELECT_ONE_ACTION(action) && EGE_SELECT_ONE_ACTION(action)->private_data->model ) { EgeSelectOneAction* act = EGE_SELECT_ONE_ACTION(action); item = GTK_WIDGET( gtk_tool_item_new() ); if ( act->private_data->appearanceMode == APPEARANCE_FULL ) { #if GTK_CHECK_VERSION(3,0,0) GtkWidget* holder = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_set_homogeneous(GTK_BOX(holder), FALSE); #else GtkWidget* holder = gtk_hbox_new( FALSE, 0 ); #endif GtkRadioAction* ract = 0; GSList* group = 0; GtkTreeIter iter; gboolean valid = FALSE; gint index = 0; { gchar* sss = 0; g_object_get( G_OBJECT(action), "short_label", &sss, NULL ); // If short_label not defined, g_object_get will return label. // This hack allows a label to be used with a drop-down menu when // no label is used with a set of icons that are self-explanatory. if (sss && strcmp( sss, "NotUsed" ) != 0 ) { GtkWidget* lbl = gtk_label_new(sss); gtk_box_pack_start( GTK_BOX(holder), lbl, FALSE, FALSE, 4 ); } g_free( sss ); sss = 0; } valid = gtk_tree_model_get_iter_first( act->private_data->model, &iter ); while ( valid ) { gchar* str = 0; gchar* tip = 0; gchar* iconId = 0; gboolean sens = true; /* gint size = 0; */ gtk_tree_model_get( act->private_data->model, &iter, act->private_data->labelColumn, &str, -1 ); if ( act->private_data->iconColumn >= 0 ) { gtk_tree_model_get( act->private_data->model, &iter, act->private_data->iconColumn, &iconId, -1 ); } if ( act->private_data->tooltipColumn >= 0 ) { gtk_tree_model_get( act->private_data->model, &iter, act->private_data->tooltipColumn, &tip, -1 ); } if ( act->private_data->sensitiveColumn >= 0 ) { gtk_tree_model_get( act->private_data->model, &iter, act->private_data->sensitiveColumn, &sens, -1 ); } if ( act->private_data->radioActionType ) { void* obj = g_object_new( act->private_data->radioActionType, "name", "Name 1", "label", str, "tooltip", tip, "value", index, /* "iconId", iconId, "iconSize", size, */ NULL ); if ( iconId ) { g_object_set( G_OBJECT(obj), act->private_data->iconProperty, iconId, NULL ); } if ( act->private_data->iconProperty ) { /* TODO get this string to be set instead of hardcoded */ if ( act->private_data->iconSize >= 0 ) { g_object_set( G_OBJECT(obj), "iconSize", act->private_data->iconSize, NULL ); } } ract = GTK_RADIO_ACTION(obj); } else { ract = gtk_radio_action_new( "Name 1", str, tip, iconId, index ); } if ( act->private_data->sensitiveColumn >= 0 ) { gtk_action_set_sensitive( GTK_ACTION(ract), sens ); } gtk_radio_action_set_group( ract, group ); group = gtk_radio_action_get_group( ract ); if ( index == act->private_data->active ) { gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(ract), TRUE ); } g_signal_connect( G_OBJECT(ract), "changed", G_CALLBACK( proxy_action_chagned_cb ), act ); GtkWidget* sub = gtk_action_create_tool_item( GTK_ACTION(ract) ); gtk_activatable_set_related_action( GTK_ACTIVATABLE (sub), GTK_ACTION(ract) ); gtk_tool_item_set_tooltip_text( GTK_TOOL_ITEM(sub), tip ); gtk_box_pack_start( GTK_BOX(holder), sub, FALSE, FALSE, 0 ); g_free( str ); g_free( tip ); g_free( iconId ); index++; valid = gtk_tree_model_iter_next( act->private_data->model, &iter ); } g_object_set_data( G_OBJECT(holder), "ege-proxy_action-group", group ); gtk_container_add( GTK_CONTAINER(item), holder ); } else { #if GTK_CHECK_VERSION(3,0,0) GtkWidget* holder = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4); gtk_box_set_homogeneous(GTK_BOX(holder), FALSE); #else GtkWidget *holder = gtk_hbox_new( FALSE, 4 ); #endif GtkEntry *entry = 0; GtkWidget *normal; if (act->private_data->selectionMode == SELECTION_OPEN) { normal = gtk_combo_box_new_with_model_and_entry (act->private_data->model); gtk_combo_box_set_entry_text_column (GTK_COMBO_BOX (normal), act->private_data->labelColumn); GtkWidget *child = gtk_bin_get_child( GTK_BIN(normal) ); if (GTK_IS_ENTRY(child)) { int maxUsed = scan_max_width( act->private_data->model, act->private_data->labelColumn ); GtkEntryCompletion *complete = 0; entry = GTK_ENTRY(child); gtk_entry_set_width_chars(entry, maxUsed); /* replace with property */ complete = gtk_entry_completion_new(); gtk_entry_completion_set_model( complete, act->private_data->model ); gtk_entry_completion_set_text_column( complete, act->private_data->labelColumn ); gtk_entry_completion_set_inline_completion( complete, FALSE ); gtk_entry_completion_set_inline_selection( complete, FALSE ); gtk_entry_completion_set_popup_completion( complete, TRUE ); gtk_entry_completion_set_popup_set_width( complete, FALSE ); gtk_entry_set_completion( entry, complete ); g_signal_connect( G_OBJECT(child), "activate", G_CALLBACK(combo_entry_changed_cb), act ); g_signal_connect( G_OBJECT(child), "focus-out-event", G_CALLBACK(combo_entry_focus_lost_cb), act ); } } else { GtkCellRenderer * renderer = NULL; normal = gtk_combo_box_new_with_model( act->private_data->model ); if ( act->private_data->iconColumn >= 0 ) { renderer = gtk_cell_renderer_pixbuf_new(); gtk_cell_layout_pack_start( GTK_CELL_LAYOUT(normal), renderer, TRUE ); /* "icon-name" */ gtk_cell_layout_add_attribute( GTK_CELL_LAYOUT(normal), renderer, "stock-id", act->private_data->iconColumn ); } renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start( GTK_CELL_LAYOUT(normal), renderer, TRUE ); gtk_cell_layout_add_attribute( GTK_CELL_LAYOUT(normal), renderer, "text", act->private_data->labelColumn ); } gtk_combo_box_set_active( GTK_COMBO_BOX(normal), act->private_data->active ); if ( entry && (act->private_data->active == -1) ) { gtk_entry_set_text( entry, act->private_data->activeText ); } g_signal_connect( G_OBJECT(normal), "changed", G_CALLBACK(combo_changed_cb), action ); g_object_set_data( G_OBJECT(holder), "ege-combo-box", normal ); g_object_set_data( G_OBJECT(act), "ege-combo-box", normal ); if (act->private_data->appearanceMode == APPEARANCE_COMPACT) { gchar* sss = 0; g_object_get( G_OBJECT(action), "short_label", &sss, NULL ); if (sss) { GtkWidget* lbl = gtk_label_new(sss); gtk_box_pack_start( GTK_BOX(holder), lbl, FALSE, FALSE, 4 ); g_free( sss ); sss = 0; } } gtk_box_pack_start( GTK_BOX(holder), normal, FALSE, FALSE, 0 ); { #if GTK_CHECK_VERSION(3,0,0) gtk_widget_set_halign(holder, GTK_ALIGN_START); gtk_container_add(GTK_CONTAINER(item), holder); #else GtkWidget *align = gtk_alignment_new(0, 0.5, 0, 0); gtk_container_add( GTK_CONTAINER(align), holder); gtk_container_add( GTK_CONTAINER(item), align ); #endif } } gtk_widget_show_all( item ); } else { item = GTK_ACTION_CLASS(ege_select_one_action_parent_class)->create_tool_item( action ); } return item; }
static void wifi_private_init (CEPageWifi *self) { CEPageWifiPrivate *priv = CE_PAGE_WIFI_GET_PRIVATE (self); GtkBuilder *builder; GtkWidget *widget; GtkWidget *align; GtkLabel *label; builder = CE_PAGE (self)->builder; priv->group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); priv->ssid = GTK_ENTRY (GTK_WIDGET (gtk_builder_get_object (builder, "wifi_ssid"))); priv->cloned_mac = GTK_ENTRY (GTK_WIDGET (gtk_builder_get_object (builder, "wifi_cloned_mac"))); priv->mode = GTK_COMBO_BOX (GTK_WIDGET (gtk_builder_get_object (builder, "wifi_mode"))); priv->band = GTK_COMBO_BOX (GTK_WIDGET (gtk_builder_get_object (builder, "wifi_band"))); priv->channel = GTK_SPIN_BUTTON (GTK_WIDGET (gtk_builder_get_object (builder, "wifi_channel"))); /* BSSID */ #if GTK_CHECK_VERSION(2,24,0) priv->bssid = GTK_COMBO_BOX_TEXT (gtk_combo_box_text_new_with_entry ()); gtk_combo_box_set_entry_text_column (GTK_COMBO_BOX (priv->bssid), 0); #else priv->bssid = GTK_COMBO_BOX_ENTRY (gtk_combo_box_entry_new_text ()); gtk_combo_box_entry_set_text_column (GTK_COMBO_BOX_ENTRY (priv->bssid), 0); #endif gtk_widget_set_tooltip_text (GTK_WIDGET (priv->bssid), _("This option locks this connection to the Wi-Fi access point (AP) specified by the BSSID entered here. Example: 00:11:22:33:44:55")); align = GTK_WIDGET (gtk_builder_get_object (builder, "wifi_bssid_alignment")); gtk_container_add (GTK_CONTAINER (align), GTK_WIDGET (priv->bssid)); gtk_widget_show_all (GTK_WIDGET (priv->bssid)); /* Device MAC */ #if GTK_CHECK_VERSION(2,24,0) priv->device_mac = GTK_COMBO_BOX_TEXT (gtk_combo_box_text_new_with_entry ()); gtk_combo_box_set_entry_text_column (GTK_COMBO_BOX (priv->device_mac), 0); #else priv->device_mac = GTK_COMBO_BOX_ENTRY (gtk_combo_box_entry_new_text ()); gtk_combo_box_entry_set_text_column (GTK_COMBO_BOX_ENTRY (priv->device_mac), 0); #endif gtk_widget_set_tooltip_text (GTK_WIDGET (priv->device_mac), _("This option locks this connection to the network device specified by its permanent MAC address entered here. Example: 00:11:22:33:44:55")); align = GTK_WIDGET (gtk_builder_get_object (builder, "wifi_device_mac_alignment")); gtk_container_add (GTK_CONTAINER (align), GTK_WIDGET (priv->device_mac)); gtk_widget_show_all (GTK_WIDGET (priv->device_mac)); /* Set mnemonic widget for device MAC label */ label = GTK_LABEL (GTK_WIDGET (gtk_builder_get_object (builder, "wifi_device_mac_label"))); gtk_label_set_mnemonic_widget (label, GTK_WIDGET (priv->device_mac)); priv->rate = GTK_SPIN_BUTTON (GTK_WIDGET (gtk_builder_get_object (builder, "wifi_rate"))); widget = GTK_WIDGET (gtk_builder_get_object (builder, "rate_units")); gtk_size_group_add_widget (priv->group, widget); priv->tx_power = GTK_SPIN_BUTTON (GTK_WIDGET (gtk_builder_get_object (builder, "wifi_tx_power"))); widget = GTK_WIDGET (gtk_builder_get_object (builder, "tx_power_units")); gtk_size_group_add_widget (priv->group, widget); priv->mtu = GTK_SPIN_BUTTON (GTK_WIDGET (gtk_builder_get_object (builder, "wifi_mtu"))); widget = GTK_WIDGET (gtk_builder_get_object (builder, "mtu_units")); gtk_size_group_add_widget (priv->group, widget); }
static PaymentWindow * new_payment_window (GncOwner *owner, QofBook *book, GncInvoice *invoice) { PaymentWindow *pw; GtkBuilder *builder; GtkWidget *box, *label, *credit_box, *debit_box; GtkTreeSelection *selection; GtkTreeViewColumn *column; GtkCellRenderer *renderer; char * cm_class = (gncOwnerGetType (owner) == GNC_OWNER_CUSTOMER ? DIALOG_PAYMENT_CUSTOMER_CM_CLASS : DIALOG_PAYMENT_VENDOR_CM_CLASS); /* * Find an existing payment window. If found, bring it to * the front. If we have an actual owner, then set it in * the window. */ pw = gnc_find_first_gui_component (cm_class, find_handler, NULL); if (pw) { if (gncOwnerIsValid(owner)) gnc_payment_set_owner (pw, owner); // Reset the setting about the pre-existing TXN pw->pre_existing_txn = NULL; gtk_window_present (GTK_WINDOW(pw->dialog)); return(pw); } /* Ok, we need a new window */ pw = g_new0 (PaymentWindow, 1); pw->book = book; gncOwnerCopy (owner, &(pw->owner)); /* Compute the post-to account types */ pw->acct_types = gncOwnerGetAccountTypesList (owner); if (gncOwnerIsValid(owner)) pw->acct_commodities = gncOwnerGetCommoditiesList (owner); /* Open and read the Glade File */ builder = gtk_builder_new(); gnc_builder_add_from_file (builder, "dialog-payment.glade", "docs_list_hor_adj"); gnc_builder_add_from_file (builder, "dialog-payment.glade", "docs_list_vert_adj"); gnc_builder_add_from_file (builder, "dialog-payment.glade", "docs_list_model"); gnc_builder_add_from_file (builder, "dialog-payment.glade", "post_combo_model"); gnc_builder_add_from_file (builder, "dialog-payment.glade", "Payment Dialog"); pw->dialog = GTK_WIDGET (gtk_builder_get_object (builder, "Payment Dialog")); /* Grab the widgets and build the dialog */ pw->payment_warning = GTK_WIDGET (gtk_builder_get_object (builder, "payment_warning")); pw->ok_button = GTK_WIDGET (gtk_builder_get_object (builder, "okbutton")); pw->num_entry = GTK_WIDGET (gtk_builder_get_object (builder, "num_entry")); pw->memo_entry = GTK_WIDGET (gtk_builder_get_object (builder, "memo_entry")); pw->post_combo = GTK_WIDGET (gtk_builder_get_object (builder, "post_combo")); gtk_combo_box_set_entry_text_column( GTK_COMBO_BOX( pw->post_combo ), 0 ); gnc_cbwe_require_list_item(GTK_COMBO_BOX(pw->post_combo)); label = GTK_WIDGET (gtk_builder_get_object (builder, "owner_label")); box = GTK_WIDGET (gtk_builder_get_object (builder, "owner_box")); pw->owner_choice = gnc_owner_select_create (label, box, book, owner); /* Some terminology: * Invoices are paid, credit notes are refunded. * A customer payment is a credit action, paying a vendor is debit * * So depending on the owner the payment amount should be considered * credit (customer) or debit (vendor/employee) and refunds should be * considered debit (customer) or credit (vendor/employee). * For visual consistency, the dialog box will always show a payment and * a refund field. Internally they are treated as credit or debit depending * on the owner type. */ if (gncOwnerGetType (owner) == GNC_OWNER_CUSTOMER) { debit_box = GTK_WIDGET (gtk_builder_get_object (builder, "amount_refund_box")); credit_box = GTK_WIDGET (gtk_builder_get_object (builder, "amount_payment_box")); } else { debit_box = GTK_WIDGET (gtk_builder_get_object (builder, "amount_payment_box")); credit_box = GTK_WIDGET (gtk_builder_get_object (builder, "amount_refund_box")); } pw->amount_debit_edit = gnc_amount_edit_new (); gtk_box_pack_start (GTK_BOX (debit_box), pw->amount_debit_edit, TRUE, TRUE, 0); gnc_amount_edit_set_evaluate_on_enter (GNC_AMOUNT_EDIT (pw->amount_debit_edit), TRUE); gnc_amount_edit_set_amount (GNC_AMOUNT_EDIT (pw->amount_debit_edit), gnc_numeric_zero()); g_signal_connect(G_OBJECT(gnc_amount_edit_gtk_entry(GNC_AMOUNT_EDIT(pw->amount_debit_edit))), "focus-out-event", G_CALLBACK(gnc_payment_leave_amount_cb), pw); pw->amount_credit_edit = gnc_amount_edit_new (); gtk_box_pack_start (GTK_BOX (credit_box), pw->amount_credit_edit, TRUE, TRUE, 0); gnc_amount_edit_set_evaluate_on_enter (GNC_AMOUNT_EDIT (pw->amount_credit_edit), TRUE); gnc_amount_edit_set_amount (GNC_AMOUNT_EDIT (pw->amount_credit_edit), gnc_numeric_zero()); g_signal_connect(G_OBJECT(gnc_amount_edit_gtk_entry(GNC_AMOUNT_EDIT(pw->amount_credit_edit))), "focus-out-event", G_CALLBACK(gnc_payment_leave_amount_cb), pw); box = GTK_WIDGET (gtk_builder_get_object (builder, "date_box")); pw->date_edit = gnc_date_edit_new (time(NULL), FALSE, FALSE); gtk_box_pack_start (GTK_BOX (box), pw->date_edit, TRUE, TRUE, 0); pw->docs_list_tree_view = GTK_WIDGET (gtk_builder_get_object (builder, "docs_list_tree_view")); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(pw->docs_list_tree_view)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE); /* Configure date column */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_get_column (GTK_TREE_VIEW (pw->docs_list_tree_view), 0); gtk_tree_view_column_pack_start (column, renderer, TRUE); tree_view_column_set_default_width (GTK_TREE_VIEW (pw->docs_list_tree_view), column, "31-12-2013"); gtk_tree_view_column_set_cell_data_func (column, renderer, (GtkTreeCellDataFunc) print_date, NULL, NULL); /* Configure document number column */ column = gtk_tree_view_get_column (GTK_TREE_VIEW (pw->docs_list_tree_view), 1); tree_view_column_set_default_width (GTK_TREE_VIEW (pw->docs_list_tree_view), column, "INV2013-016"); /* Configure document type column */ column = gtk_tree_view_get_column (GTK_TREE_VIEW (pw->docs_list_tree_view), 2); tree_view_column_set_default_width (GTK_TREE_VIEW (pw->docs_list_tree_view), column, _("Credit Note")); /* Configure debit column */ column = gtk_tree_view_get_column (GTK_TREE_VIEW (pw->docs_list_tree_view), 3); tree_view_column_set_default_width (GTK_TREE_VIEW (pw->docs_list_tree_view), column, "11,999.00"); /* Configure credit column */ column = gtk_tree_view_get_column (GTK_TREE_VIEW (pw->docs_list_tree_view), 4); tree_view_column_set_default_width (GTK_TREE_VIEW (pw->docs_list_tree_view), column, "11,999.00"); gtk_tree_sortable_set_sort_column_id ( GTK_TREE_SORTABLE (gtk_tree_view_get_model (GTK_TREE_VIEW (pw->docs_list_tree_view))), 0, GTK_SORT_ASCENDING); box = GTK_WIDGET (gtk_builder_get_object (builder, "acct_window")); pw->acct_tree = GTK_WIDGET(gnc_tree_view_account_new (FALSE)); gtk_container_add (GTK_CONTAINER (box), pw->acct_tree); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(pw->acct_tree), FALSE); gnc_payment_set_account_types (GNC_TREE_VIEW_ACCOUNT (pw->acct_tree)); /* Set the dialog for the 'new' owner. * Note that this also sets the post account tree. */ gnc_payment_dialog_owner_changed(pw); /* Set the dialog for the 'new' invoice */ pw->invoice = invoice; if (invoice) { Account *postacct = gncInvoiceGetPostedAcc (invoice); if (postacct) { gchar *acct_string = gnc_account_get_full_name (postacct); gnc_cbwe_set_by_string(GTK_COMBO_BOX(pw->post_combo), acct_string); gnc_payment_dialog_post_to_changed_cb (pw->post_combo, pw); g_free(acct_string); } } /* Setup signals */ gtk_builder_connect_signals_full( builder, gnc_builder_connect_full_func, pw); g_signal_connect (G_OBJECT (pw->owner_choice), "changed", G_CALLBACK (gnc_payment_dialog_owner_changed_cb), pw); g_signal_connect (G_OBJECT (pw->acct_tree), "row-activated", G_CALLBACK (gnc_payment_acct_tree_row_activated_cb), pw); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(pw->acct_tree)); g_signal_connect (G_OBJECT (selection), "changed", G_CALLBACK (gnc_payment_dialog_xfer_acct_changed_cb), pw); /* Register with the component manager */ pw->component_id = gnc_register_gui_component (cm_class, gnc_payment_window_refresh_handler, gnc_payment_window_close_handler, pw); /* Watch for any new or changed accounts */ gnc_gui_component_watch_entity_type (pw->component_id, GNC_ID_ACCOUNT, QOF_EVENT_CREATE | QOF_EVENT_MODIFY | QOF_EVENT_DESTROY); /* Show it all */ gtk_widget_show_all (pw->dialog); g_object_unref(G_OBJECT(builder)); // The customer choice widget should have keyboard focus if (GNC_IS_GENERAL_SEARCH(pw->owner_choice)) { gnc_general_search_grab_focus(GNC_GENERAL_SEARCH(pw->owner_choice)); } /* Reflect if the payment could complete now */ gnc_payment_window_check_payment (pw); /* Warn the user if they have no valid post-to accounts */ { const gchar *text; const char *acct_type; text = gtk_entry_get_text(GTK_ENTRY (gtk_bin_get_child(GTK_BIN (GTK_COMBO_BOX(pw->post_combo))))); if (!text || g_strcmp0 (text, "") == 0) { /* The code below assumes there will only be one account type. * Let's assert this to protect from potential future changes. */ g_assert (g_list_length (pw->acct_types) == 1); acct_type = xaccAccountGetTypeStr(GPOINTER_TO_INT(pw->acct_types->data)); gnc_warning_dialog(pw->dialog, _("You have no valid \"Post To\" accounts. " "Please create an account of type \"%s\" " "before you continue to process this payment. " "Perhaps you want to create an Invoice or " "Bill first?"), acct_type); } } return pw; }