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