static void
on_renderer_combo_changed (GtkComboBox *widget,
gpointer user_data)
{
GtkComboBox *combo;
GtkTreeModel *model;
GtkTreeIter iter;
MafwPlayState state;
guint volume;
combo = GTK_COMBO_BOX (renderer_combo);
model = gtk_combo_box_get_model (combo);
g_assert (model != NULL);
if (!gtk_combo_box_get_active_iter (combo, &iter)) {
selected_renderer = NULL;
return;
}
if (selected_renderer != NULL) {
stop();
}
gtk_tree_model_get (model, &iter,
RENDERER_COMBO_COLUMN_RENDERER, &selected_renderer,
RENDERER_COMBO_COLUMN_STATE, &state,
RENDERER_COMBO_COLUMN_VOLUME, &volume,
-1);
set_volume_vscale (volume);
prepare_controls_for_state (state);
update_mute_button();
if (selected_renderer != NULL) {
/* Get the selected renderer's playlist */
mafw_renderer_get_status(selected_renderer,
selected_renderer_status_cb,
NULL);
set_selected_renderer_xid (get_metadata_visual_xid ());
mafw_extension_get_property(MAFW_EXTENSION(selected_renderer),
"current-frame-on-pause",
fop_status_cb, NULL);
}
}
/**
* Callback function of the save button click signal.
*/
static void
save_cb(GtkWidget *widget, HybridGroupAddWindow *window)
{
GtkTreeModel *model;
GtkTreeIter iter;
HybridAccount *account;
HybridModule *proto;
HybridIMOps *ops;
const gchar *name;
model = gtk_combo_box_get_model(GTK_COMBO_BOX(window->account_combo));
if (!gtk_combo_box_get_active_iter(
GTK_COMBO_BOX(window->account_combo), &iter)) {
hybrid_debug_error("groupadd", "no account was choosed.");
return;
}
gtk_tree_model_get(model, &iter,
GROUPADD_ACCOUNT_COLUMN, &account,
-1);
name = gtk_entry_get_text(GTK_ENTRY(window->name_entry));
if (!name || *name == '\0') {
hybrid_debug_error("groupadd", "no group name was specified.");
return;
}
proto = account->proto;
ops = proto->info->im_ops;
/* call the protocol hook function. */
if (ops->group_add) {
ops->group_add(account, name);
}
/* destroy the groupadd window. */
gtk_widget_destroy(window->window);
}
static void ui_authenticate(dt_storage_facebook_gui_data_t *ui)
{
if(ui->facebook_api == NULL)
{
ui->facebook_api = fb_api_init();
}
FBContext *ctx = ui->facebook_api;
gboolean mustsaveaccount = FALSE;
gchar *uiselectedaccounttoken = NULL;
GtkTreeIter iter;
gtk_combo_box_get_active_iter(ui->comboBox_username, &iter);
GtkTreeModel *accountModel = gtk_combo_box_get_model(ui->comboBox_username);
gtk_tree_model_get(accountModel, &iter, 1, &uiselectedaccounttoken, -1);
gtk_button_set_label(ui->button_login, _("login"));
gtk_widget_set_sensitive(GTK_WIDGET(ui->comboBox_album), FALSE);
g_free(ctx->token);
ctx->token = g_strdup(uiselectedaccounttoken);
// check selected token if we already have one
if(ctx->token != NULL && !fb_test_auth_token(ctx))
{
g_free(ctx->token);
ctx->token = NULL;
}
if(ctx->token == NULL)
{
mustsaveaccount = TRUE;
#ifdef HAVE_HTTP_SERVER
// try to get the token from the callback URL
if(facebook_get_user_auth_token_from_server(ui)) return;
#endif
// if we reached this point we either have no http server support
// or couldn't start it (no free port, ...)
ctx->token = facebook_get_user_auth_token_from_url(ui); // ask user to log in
}
ui_authenticate_finish(ui, mustsaveaccount);
}
static const gchar *
gtk_combo_box_accessible_get_name (AtkObject *obj)
{
GtkWidget *widget;
GtkComboBox *combo_box;
GtkComboBoxAccessible *accessible;
GtkTreeIter iter;
const gchar *name;
GtkTreeModel *model;
gint n_columns;
gint i;
name = ATK_OBJECT_CLASS (_gtk_combo_box_accessible_parent_class)->get_name (obj);
if (name)
return name;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
if (widget == NULL)
return NULL;
combo_box = GTK_COMBO_BOX (widget);
accessible = GTK_COMBO_BOX_ACCESSIBLE (obj);
if (gtk_combo_box_get_active_iter (combo_box, &iter))
{
model = gtk_combo_box_get_model (combo_box);
n_columns = gtk_tree_model_get_n_columns (model);
for (i = 0; i < n_columns; i++)
{
GValue value = G_VALUE_INIT;
gtk_tree_model_get_value (model, &iter, i, &value);
if (G_VALUE_HOLDS_STRING (&value))
{
g_free (accessible->name);
accessible->name = g_strdup (g_value_get_string (&value));
g_value_unset (&value);
break;
}
else
g_value_unset (&value);
}
}
return accessible->name;
}
static gchar *get_combo_text(GtkComboBox *combo)
{
GtkTreeModel *model;
GtkTreeIter iter;
gchar *text;
model = gtk_combo_box_get_model(combo);
if (!model)
return NULL;
if (!gtk_combo_box_get_active_iter(combo, &iter))
return NULL;
gtk_tree_model_get(model, &iter,
0, &text,
-1);
return text;
}
McAccount *
empathy_account_chooser_get_account (EmpathyAccountChooser *chooser)
{
EmpathyAccountChooserPriv *priv;
McAccount *account;
GtkTreeModel *model;
GtkTreeIter iter;
g_return_val_if_fail (EMPATHY_IS_ACCOUNT_CHOOSER (chooser), NULL);
priv = GET_PRIV (chooser);
model = gtk_combo_box_get_model (GTK_COMBO_BOX (chooser));
gtk_combo_box_get_active_iter (GTK_COMBO_BOX (chooser), &iter);
gtk_tree_model_get (model, &iter, COL_ACCOUNT_POINTER, &account, -1);
return account;
}
void AP_UnixDialog_CollaborationAddBuddy::event_Ok()
{
GtkTreeIter iter;
if (gtk_combo_box_get_active_iter(GTK_COMBO_BOX(m_wAccount), &iter))
{
gpointer handler = 0;
gtk_tree_model_get(m_model, &iter, HANDLER_COLUMN, &handler, -1);
if (handler)
{
m_pAccount = reinterpret_cast<AccountHandler*>(handler);
_setName(gtk_entry_get_text(GTK_ENTRY(m_wName)));
}
else
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
}
else
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
}
/*!
\brief Called when the user selects an AFR conversion combobox entry
\param widget is the combobox the user touched
\param data is unused
*/
G_MODULE_EXPORT void afr_combo_changed(GtkWidget *widget, gpointer data)
{
gboolean state = FALSE;
GtkTreeModel *model = NULL;
GtkTreeIter iter;
g_return_if_fail(GTK_IS_COMBO_BOX(widget));
state = gtk_combo_box_get_active_iter(GTK_COMBO_BOX(widget),&iter);
model = gtk_combo_box_get_model(GTK_COMBO_BOX(widget));
gtk_tree_model_get(model,&iter,0,&afr_name,1,&afr_enum,-1);
if (afr_enum == genericWB)
gtk_widget_set_sensitive(OBJ_GET(widget,"generic_controls"),TRUE);
else
gtk_widget_set_sensitive(OBJ_GET(widget,"generic_controls"),FALSE);
return;
}
static void remmina_rdp_settings_appscale_on_changed(GtkComboBox *widget, RemminaPluginRdpsetGrid *grid)
{
TRACE_CALL(__func__);
GtkTreeIter iter;
guint i = 0;
if (gtk_combo_box_get_active_iter(GTK_COMBO_BOX(grid->device_scale_factor_combo), &iter)) {
gtk_tree_model_get(GTK_TREE_MODEL(grid->device_scale_factor_store), &iter, 0, &i, -1);
}
if (i == 0) {
gtk_widget_set_sensitive(GTK_WIDGET(grid->desktop_scale_factor_spin), FALSE);
gtk_spin_button_set_range(GTK_SPIN_BUTTON(grid->desktop_scale_factor_spin), 0, 0);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(grid->desktop_scale_factor_spin), 0);
}else {
gtk_widget_set_sensitive(GTK_WIDGET(grid->desktop_scale_factor_spin), TRUE);
gtk_spin_button_set_range(GTK_SPIN_BUTTON(grid->desktop_scale_factor_spin), 100, 500);
// gtk_spin_button_set_value(GTK_SPIN_BUTTON(grid->desktop_scale_factor_spin), i);
}
}
static void
xkb_layout_chooser_enable_disable_buttons (GtkBuilder * chooser_dialog)
{
GtkWidget *cbv =
CWID (gtk_notebook_get_current_page
(GTK_NOTEBOOK (CWID ("choosers_nb"))) ?
"xkb_language_variants_available" :
"xkb_country_variants_available");
GtkTreeIter viter;
gboolean enable_ok =
gtk_combo_box_get_active_iter (GTK_COMBO_BOX (cbv),
&viter);
gtk_dialog_set_response_sensitive (GTK_DIALOG
(CWID
("xkb_layout_chooser")),
GTK_RESPONSE_OK, enable_ok);
gtk_widget_set_sensitive (CWID ("btnPrint"), enable_ok);
}
static void
action_combo_box_changed (GtkComboBox *combo_box)
{
GtkRadioAction *action;
GtkTreeModel *model;
GtkTreeIter iter;
gint value;
/* This method is virtual, so no need to chain up. */
if (!gtk_combo_box_get_active_iter (combo_box, &iter))
return;
model = gtk_combo_box_get_model (combo_box);
gtk_tree_model_get (model, &iter, COLUMN_ACTION, &action, -1);
g_object_get (action, "value", &value, NULL);
gtk_radio_action_set_current_value (action, value);
g_object_unref (action);
}
static void
pkg_sources_page_combo_changed_cb (GtkWidget *combo, /* IN */
gpointer user_data) /* IN */
{
PkgSourcesPagePrivate *priv;
PkgSourcesPage *page = user_data;
GtkTreeIter iter;
gboolean sensitive = FALSE;
g_return_if_fail(PKG_IS_SOURCES_PAGE(page));
ENTRY;
priv = page->priv;
if (gtk_combo_box_get_active_iter(GTK_COMBO_BOX(priv->combo), &iter)) {
sensitive = TRUE;
}
gtk_widget_set_sensitive(priv->add, sensitive);
EXIT;
}
gboolean
empathy_account_chooser_has_all_selected (EmpathyAccountChooser *self)
{
GtkTreeModel *model;
GtkTreeIter iter;
RowType type;
g_return_val_if_fail (EMPATHY_IS_ACCOUNT_CHOOSER (self), FALSE);
g_return_val_if_fail (self->priv->has_all_option == TRUE, FALSE);
model = gtk_combo_box_get_model (GTK_COMBO_BOX (self));
if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (self), &iter))
return FALSE;
gtk_tree_model_get (model, &iter, COL_ACCOUNT_ROW_TYPE, &type, -1);
return type == ROW_ALL;
}
void ColorICCSelector::_profileSelected( GtkWidget* /*src*/, gpointer data )
{
ColorICCSelector* self = reinterpret_cast<ColorICCSelector*>(data);
GtkTreeIter iter;
if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX(self->_profileSel), &iter)) {
GtkTreeModel *store = gtk_combo_box_get_model (GTK_COMBO_BOX(self->_profileSel));
gchar* name = 0;
gtk_tree_model_get (store, &iter, 1, &name, -1);
self->_switchToProfile( name );
gtk_widget_set_tooltip_text(self->_profileSel, name );
if ( name ) {
g_free( name );
}
}
}
GtkWidget *
ws_802_1x_nag_user (WirelessSecurity *sec,
const char *combo_name)
{
GtkTreeModel *model;
GtkTreeIter iter;
EAPMethod *eap = NULL;
GtkWidget *widget;
widget = GTK_WIDGET (gtk_builder_get_object (sec->builder, combo_name));
model = gtk_combo_box_get_model (GTK_COMBO_BOX (widget));
gtk_combo_box_get_active_iter (GTK_COMBO_BOX (widget), &iter);
gtk_tree_model_get (model, &iter, AUTH_METHOD_COLUMN, &eap, -1);
g_return_val_if_fail (eap != NULL, NULL);
widget = eap_method_nag_user (eap);
eap_method_unref (eap);
return widget;
}
HitoGroup *
hito_group_combo_get_active_group (HitoGroupCombo *combo)
{
GtkTreeIter iter;
GtkTreeModel *model;
HitoGroup *group = NULL;
g_return_val_if_fail (HITO_IS_GROUP_COMBO (combo), NULL);
if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (combo), &iter)) {
model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo));
gtk_tree_model_get (model, &iter, COL_GROUP, &group, -1);
return group;
}
return NULL;
}
static int get_active_item(GtkComboBox *combo_box, GtkTreeIter *iter, GtkListStore *model)
{
const char *desc;
if (gtk_combo_box_get_active_iter(combo_box, iter))
return TRUE;
desc = get_active_text(combo_box);
found_match = NULL;
gtk_tree_model_foreach(GTK_TREE_MODEL(model), match_desc, (void *)desc);
if (!found_match)
return FALSE;
*iter = *found_match;
gtk_combo_box_set_active_iter(combo_box, iter);
return TRUE;
}
static void
text_scaling_factor_combo_box_changed (GtkComboBox *box,
CcUaPanel *panel)
{
CcUaPanelPrivate *priv = panel->priv;
GtkTreeIter iter;
gfloat factor;
gtk_combo_box_get_active_iter (box, &iter);
gtk_tree_model_get (gtk_combo_box_get_model (box), &iter,
DPI_MODEL_FACTOR_COLUMN, &factor,
-1);
if (factor == 1.0)
g_settings_reset (priv->interface_settings, "text-scaling-factor");
else
g_settings_set_double (priv->interface_settings, "text-scaling-factor", factor);
}
static void
on_device_menu_changed (GtkComboBox * combo_box, gpointer user_data)
{
BtSettingsPageInteractionController *self =
BT_SETTINGS_PAGE_INTERACTION_CONTROLLER (user_data);
GObject *device = NULL;
BtObjectListModel *store;
GtkTreeModel *model;
GtkTreeIter iter;
GList *node, *list;
// release the old one
if (self->priv->device) {
stop_device (self);
}
GST_INFO ("interaction controller device changed");
model = gtk_combo_box_get_model (self->priv->device_menu);
if (gtk_combo_box_get_active_iter (self->priv->device_menu, &iter)) {
device =
bt_object_list_model_get_object (BT_OBJECT_LIST_MODEL (model), &iter);
}
// update list of controllers
store = bt_object_list_model_new (2, BTIC_TYPE_CONTROL, "bound", "name");
if (device) {
g_object_get (device, "controls", &list, NULL);
for (node = list; node; node = g_list_next (node)) {
bt_object_list_model_append (store, (GObject *) node->data);
g_signal_connect_object (node->data, "notify::value",
G_CALLBACK (notify_controlchange), (gpointer) self, 0);
}
g_list_free (list);
// activate the new one
self->priv->device = g_object_ref ((gpointer) device);
start_device (self);
}
GST_INFO ("control list refreshed");
gtk_widget_set_sensitive (GTK_WIDGET (self->priv->controller_list),
(device != NULL));
gtk_tree_view_set_model (self->priv->controller_list, GTK_TREE_MODEL (store));
g_object_unref (store); // drop with treeview
}
static char*
repair_dialog_get_current_encoding(GtkDialog* dialog)
{
GtkComboBox* combo;
GtkTreeModel* model;
GtkTreeIter iter;
gboolean res;
char* encoding;
combo = repair_dialog_get_encoding_combo_box(dialog);
model = gtk_combo_box_get_model(combo);
res = gtk_combo_box_get_active_iter(combo, &iter);
if (!res)
return NULL;
gtk_tree_model_get(model, &iter, ENCODING_COLUMN_ENCODING, &encoding, -1);
return encoding;
}
static void
on_combo_style_changed (GtkComboBox *combo_box,
gpointer user_data)
{
GtkToolPalette *palette = GTK_TOOL_PALETTE (user_data);
GtkTreeModel *model = gtk_combo_box_get_model (combo_box);
GtkTreeIter iter;
gint val = 0;
if (!gtk_combo_box_get_active_iter (combo_box, &iter))
return;
gtk_tree_model_get (model, &iter, 1, &val, -1);
if (val == -1)
gtk_tool_palette_unset_style (palette);
else
gtk_tool_palette_set_style (palette, val);
}
AccountHandler* AP_UnixDialog_CollaborationShare::_getActiveAccountHandler()
{
GtkTreeIter iter;
if (gtk_combo_box_get_active_iter(GTK_COMBO_BOX(m_wAccount), &iter))
{
gchar * str_data;
gpointer* ptr_data;
AccountHandler* pHandler = 0;
gtk_tree_model_get (m_pAccountModel, &iter,
0, &str_data,
1, &ptr_data,
-1);
pHandler = reinterpret_cast<AccountHandler*>(ptr_data);
return pHandler;
}
return 0;
}
static void on_custommodcombo_changed(GtkComboBox *combobox, gpointer user_data)
{
GtkTreeIter iter;
GtkTreeModel *model;
GtkTreePath *path;
char *value;
UNREFERENCED_PARAMETER(user_data);
if (gtk_combo_box_get_active_iter(combobox, &iter))
{
model = gtk_combo_box_get_model(combobox);
gtk_tree_model_get(model, &iter, 0,&value, -1);
path = gtk_tree_model_get_path(model, &iter);
if (*gtk_tree_path_get_indices(path) == NONE)
settings.custommoddir = NULL;
else settings.custommoddir = value;
}
}
static void
gth_image_saver_jpeg_save_options (GthImageSaver *base)
{
GthImageSaverJpeg *self = GTH_IMAGE_SAVER_JPEG (base);
GtkTreeIter iter;
if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (_gtk_builder_get_widget (self->priv->builder, "jpeg_default_extension_combobox")), &iter)) {
g_free (self->priv->default_ext);
gtk_tree_model_get (GTK_TREE_MODEL (gtk_builder_get_object (self->priv->builder, "jpeg_default_ext_liststore")),
&iter,
0, &self->priv->default_ext,
-1);
g_settings_set_string (self->priv->settings, PREF_JPEG_DEFAULT_EXT, self->priv->default_ext);
}
g_settings_set_int (self->priv->settings, PREF_JPEG_QUALITY, (int) gtk_adjustment_get_value (GTK_ADJUSTMENT (_gtk_builder_get_widget (self->priv->builder, "jpeg_quality_adjustment"))));
g_settings_set_int (self->priv->settings, PREF_JPEG_SMOOTHING, (int) gtk_adjustment_get_value (GTK_ADJUSTMENT (_gtk_builder_get_widget (self->priv->builder, "jpeg_smooth_adjustment"))));
g_settings_set_boolean (self->priv->settings, PREF_JPEG_OPTIMIZE, gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (_gtk_builder_get_widget (self->priv->builder, "jpeg_optimize_checkbutton"))));
g_settings_set_boolean (self->priv->settings, PREF_JPEG_PROGRESSIVE, gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (_gtk_builder_get_widget (self->priv->builder, "jpeg_progressive_checkbutton"))));
}
static void
add_to_size_group (EAPMethod *parent, GtkSizeGroup *group)
{
EAPMethodPEAP *method = (EAPMethodPEAP *) parent;
GtkWidget *widget;
GtkTreeModel *model;
GtkTreeIter iter;
EAPMethod *eap;
if (method->size_group)
g_object_unref (method->size_group);
method->size_group = g_object_ref (group);
widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_peap_ca_cert_not_required_checkbox"));
g_assert (widget);
gtk_size_group_add_widget (group, widget);
widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_peap_anon_identity_label"));
g_assert (widget);
gtk_size_group_add_widget (group, widget);
widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_peap_ca_cert_label"));
g_assert (widget);
gtk_size_group_add_widget (group, widget);
widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_peap_version_label"));
g_assert (widget);
gtk_size_group_add_widget (group, widget);
widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_peap_inner_auth_label"));
g_assert (widget);
gtk_size_group_add_widget (group, widget);
widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_peap_inner_auth_combo"));
g_assert (widget);
model = gtk_combo_box_get_model (GTK_COMBO_BOX (widget));
gtk_combo_box_get_active_iter (GTK_COMBO_BOX (widget), &iter);
gtk_tree_model_get (model, &iter, I_METHOD_COLUMN, &eap, -1);
g_assert (eap);
eap_method_add_to_size_group (eap, group);
eap_method_unref (eap);
}
static void
preferences_theme_changed_cb (GtkComboBox *combo,
EmpathyPreferences *preferences)
{
EmpathyPreferencesPriv *priv = GET_PRIV (preferences);
GtkTreeIter iter;
if (gtk_combo_box_get_active_iter (combo, &iter)) {
GtkTreeModel *model;
gboolean is_adium;
gchar *name;
gchar *path;
GHashTable *info;
model = gtk_combo_box_get_model (combo);
gtk_tree_model_get (model, &iter,
COL_THEME_IS_ADIUM, &is_adium,
COL_THEME_NAME, &name,
COL_THEME_ADIUM_PATH, &path,
COL_THEME_ADIUM_INFO, &info,
-1);
g_settings_set_string (priv->gsettings_chat,
EMPATHY_PREFS_CHAT_THEME,
name);
if (is_adium) {
gboolean variant;
g_settings_set_string (priv->gsettings_chat,
EMPATHY_PREFS_CHAT_ADIUM_PATH,
path);
variant = preferences_theme_variants_fill (preferences, info);
gtk_widget_set_visible (priv->hbox_chat_theme_variant, variant);
} else {
gtk_widget_hide (priv->hbox_chat_theme_variant);
}
g_free (name);
g_free (path);
tp_clear_pointer (&info, g_hash_table_unref);
}
}
/* callback function for change signal, in this function, we'll set the widgets
* that control line */
static void
cb_changed(GtkComboBox *combo, Data *data)
{
/* vars */
GtkTreeIter iter;
gchar *stock_id, *string;
gint value;
gboolean pix, text, prog;
gboolean active;
stock_id = NULL;
string = NULL;
active = gtk_combo_box_get_active_iter(GTK_COMBO_BOX(data->combo), &iter);
if (active==TRUE)
{
gtk_tree_model_get(data->store, &iter,
TEXT_C, &string,
TEXT_VIS_C, &text,
PIXBUF_C, &stock_id,
PIXBUF_VIS_C, &pix,
PROGRESS_C, &value,
PROGRESS_VIS_C, &prog,
-1);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data->vis_text), text);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data->vis_pixbuf), pix);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data->vis_progress), prog);
gtk_entry_set_text(GTK_ENTRY(data->e_text), string);
gtk_entry_set_text(GTK_ENTRY(data->e_pixbuf), stock_id);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(data->e_progress), value);
/* free strings */
g_free(stock_id);
g_free(string);
}
gtk_widget_set_sensitive(data->vis_text, active);
gtk_widget_set_sensitive(data->vis_pixbuf, active);
gtk_widget_set_sensitive(data->vis_progress, active);
gtk_widget_set_sensitive(data->e_text, active);
gtk_widget_set_sensitive(data->e_pixbuf, active);
gtk_widget_set_sensitive(data->e_progress, active);
}
static int SaveColors(GtkComboBox *combo)
{
int f;
gchar clr[4096];
GtkTreeIter iter;
#if GTK_MAJOR_VERSION >= 2 && GTK_MINOR_VERSION >= 12
gchar *ptr;
#else
int sz;
#endif
*clr = 0;
for(f=0;f < TERMINAL_COLOR_COUNT;f++)
{
if(f > 0)
g_strlcat(clr,",",4095);
#if GTK_MAJOR_VERSION >= 2 && GTK_MINOR_VERSION >= 12
ptr = gdk_color_to_string(color+f);
g_strlcat(clr,ptr,4095);
g_free(ptr);
#else
sz = strlen(clr);
g_snprintf(clr+sz,4094-sz,"#%04x%04x%04x",(color+f)->red,(color+f)->green,(color+f)->blue);
#endif
}
SetString("Terminal","Colors",clr);
if(gtk_combo_box_get_active_iter(combo,&iter))
{
GValue value = { 0, };
gtk_tree_model_get_value(gtk_combo_box_get_model(combo),&iter,1,&value);
SetString("Terminal","ColorScheme",g_value_get_string(&value));
}
return 0;
}
static void
xkb_layout_chooser_available_language_variants_fill (GtkBuilder *
chooser_dialog)
{
GtkWidget *cbl = CWID ("xkb_languages_available");
GtkWidget *cbv = CWID ("xkb_language_variants_available");
GtkListStore *list_store;
GtkTreeIter liter;
list_store = gtk_list_store_new
(4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING);
if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (cbl), &liter)) {
GtkTreeModel *lm =
gtk_combo_box_get_model (GTK_COMBO_BOX (cbl));
gchar *lang_id;
AddVariantData data = { list_store, 0 };
/* Now the variants of the selected layout */
gtk_tree_model_get (lm, &liter,
COMBO_BOX_MODEL_COL_REAL_ID,
&lang_id, -1);
data.lang_id = lang_id;
xkl_config_registry_foreach_language_variant
(config_registry, lang_id, (TwoConfigItemsProcessFunc)
xkb_layout_chooser_add_variant_to_available_language_variants,
&data);
g_free (lang_id);
}
/* Turn on sorting after filling the store, since that's faster */
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE
(list_store),
COMBO_BOX_MODEL_COL_SORT,
GTK_SORT_ASCENDING);
gtk_combo_box_set_model (GTK_COMBO_BOX (cbv),
GTK_TREE_MODEL (list_store));
gtk_combo_box_set_active (GTK_COMBO_BOX (cbv), 0);
}
static void
tabletmode_changed_cb (GtkComboBox *combo, gpointer user_data)
{
CcWacomPagePrivate *priv = CC_WACOM_PAGE(user_data)->priv;
GtkListStore *liststore;
GtkTreeIter iter;
gint mode;
gboolean is_absolute;
if (!gtk_combo_box_get_active_iter (combo, &iter))
return;
liststore = GTK_LIST_STORE (WID ("liststore-tabletmode"));
gtk_tree_model_get (GTK_TREE_MODEL (liststore), &iter,
MODENUMBER_COLUMN, &mode,
-1);
is_absolute = (mode == MODE_ABSOLUTE);
g_settings_set_boolean (priv->wacom_settings, "is-absolute", is_absolute);
}
