static void
enum_pref_create_widget (GOConfNode *node, GtkWidget *grid,
gint row, GType enum_type,
enum_conf_setter_t setter,
enum_conf_getter_t getter,
gchar const *default_label,
char const *(*label_getter)(int))
{
unsigned int i;
GtkTreeIter iter;
GtkCellRenderer *renderer;
GEnumClass *enum_class = G_ENUM_CLASS (g_type_class_ref (enum_type));
GtkWidget *combo = gtk_combo_box_new ();
GtkListStore *model = gtk_list_store_new (2,
G_TYPE_STRING, G_TYPE_POINTER);
gint current = getter ();
gint current_index = -1;
for (i = 0; i < enum_class->n_values ; i++) {
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter,
0, label_getter ((int) enum_class->values[i].value),
1, enum_class->values + i,
-1);
if (enum_class->values[i].value == current)
current_index = i;
}
g_type_class_unref (enum_class);
gtk_combo_box_set_model (GTK_COMBO_BOX (combo), GTK_TREE_MODEL (model));
g_object_unref (model);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), renderer, "text", 0, NULL);
gtk_combo_box_set_active (GTK_COMBO_BOX (combo), current_index);
gtk_grid_attach (GTK_GRID (grid), combo, 1, row, 1, 1);
g_signal_connect (G_OBJECT (combo), "changed",
G_CALLBACK (cb_enum_changed), (gpointer) setter);
connect_notification (node, (GOConfMonitorFunc)enum_pref_conf_to_widget,
combo, grid);
pref_create_label (node, grid, row, default_label, combo);
set_tip (node, combo);
}
static void
account_chooser_setup (EmpathyAccountChooser *chooser)
{
EmpathyAccountChooserPriv *priv;
GList *accounts;
GtkListStore *store;
GtkCellRenderer *renderer;
GtkComboBox *combobox;
priv = GET_PRIV (chooser);
/* Set up combo box with new store */
combobox = GTK_COMBO_BOX (chooser);
gtk_cell_layout_clear (GTK_CELL_LAYOUT (combobox));
store = gtk_list_store_new (COL_ACCOUNT_COUNT,
G_TYPE_STRING, /* Image */
G_TYPE_STRING, /* Name */
G_TYPE_BOOLEAN, /* Enabled */
EMPATHY_TYPE_ACCOUNT);
gtk_combo_box_set_model (combobox, GTK_TREE_MODEL (store));
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
"icon-name", COL_ACCOUNT_IMAGE,
"sensitive", COL_ACCOUNT_ENABLED,
NULL);
g_object_set (renderer, "stock-size", GTK_ICON_SIZE_BUTTON, NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
"text", COL_ACCOUNT_TEXT,
"sensitive", COL_ACCOUNT_ENABLED,
NULL);
/* Populate accounts */
accounts = empathy_account_manager_dup_accounts (priv->manager);
g_list_foreach (accounts,
(GFunc) account_chooser_account_add_foreach,
chooser);
g_list_free (accounts);
g_object_unref (store);
}
/**
* gpk_prefs_set_combo_model_simple_text:
**/
static void
gpk_prefs_update_freq_combo_simple_text (GtkWidget *combo_box)
{
GtkCellRenderer *cell;
GtkListStore *store;
store = gtk_list_store_new (1, G_TYPE_STRING);
gtk_combo_box_set_model (GTK_COMBO_BOX (combo_box), GTK_TREE_MODEL (store));
g_object_unref (store);
cell = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box), cell, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_box), cell,
"text", 0,
NULL);
}
static void
setup_groups_combo (void)
{
GtkWidget *combo = gst_dialog_get_widget (tool->main_dialog, "user_settings_group");
GtkWidget *table = gst_dialog_get_widget (tool->main_dialog, "groups_table");
GtkCellRenderer *cell;
GtkTreeModel *model;
cell = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT (combo), cell, TRUE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT (combo), cell, "text", 0, NULL);
model = gtk_tree_view_get_model (GTK_TREE_VIEW (table));
gtk_combo_box_set_model (GTK_COMBO_BOX (combo), model);
g_object_unref (model);
}
int
clip_GTK_COMBOBOXSETMODEL(ClipMachine * ClipMachineMemory)
{
C_widget *ccmb = _fetch_cw_arg(ClipMachineMemory);
C_object *cmodel = _fetch_cobject(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2));
CHECKCWID(ccmb, GTK_IS_COMBO_BOX);
CHECKCOBJ(cmodel, GTK_IS_TREE_MODEL(cmodel->object));
gtk_combo_box_set_model(GTK_COMBO_BOX(ccmb->widget), GTK_TREE_MODEL(cmodel->object));
return 0;
err:
return 1;
}
static void
gimp_container_combo_box_init (GimpContainerComboBox *combo)
{
GtkTreeModel *model;
GtkCellLayout *layout;
GtkCellRenderer *cell;
GType types[GIMP_CONTAINER_TREE_STORE_N_COLUMNS];
gint n_types = 0;
gimp_container_tree_store_columns_init (types, &n_types);
model = gimp_container_tree_store_new (GIMP_CONTAINER_VIEW (combo),
n_types, types);
gtk_combo_box_set_model (GTK_COMBO_BOX (combo), model);
g_object_unref (model);
layout = GTK_CELL_LAYOUT (combo);
cell = gimp_cell_renderer_viewable_new ();
gtk_cell_layout_pack_start (layout, cell, FALSE);
gtk_cell_layout_set_attributes (layout, cell,
"renderer",
GIMP_CONTAINER_TREE_STORE_COLUMN_RENDERER,
NULL);
gimp_container_tree_store_add_renderer_cell (GIMP_CONTAINER_TREE_STORE (model),
cell);
combo->viewable_renderer = cell;
cell = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (layout, cell, TRUE);
gtk_cell_layout_set_attributes (layout, cell,
"text",
GIMP_CONTAINER_TREE_STORE_COLUMN_NAME,
NULL);
combo->text_renderer = cell;
g_signal_connect (combo, "changed",
G_CALLBACK (gimp_container_combo_box_changed),
combo);
gtk_widget_set_sensitive (GTK_WIDGET (combo), FALSE);
}
static void
panel_properties_dialog_setup_orientation_combo (PanelPropertiesDialog *dialog,
GtkBuilder *gui)
{
PanelOrientation orientation;
GtkListStore *model;
GtkTreeIter iter;
GtkCellRenderer *renderer;
int i;
dialog->orientation_combo = PANEL_GTK_BUILDER_GET (gui, "orientation_combo");
g_return_if_fail (dialog->orientation_combo != NULL);
dialog->orientation_label = PANEL_GTK_BUILDER_GET (gui, "orientation_label");
g_return_if_fail (dialog->orientation_label != NULL);
orientation = panel_profile_get_toplevel_orientation (dialog->toplevel);
model = gtk_list_store_new (NUMBER_COLUMNS,
G_TYPE_STRING,
G_TYPE_POINTER);
gtk_combo_box_set_model (GTK_COMBO_BOX (dialog->orientation_combo),
GTK_TREE_MODEL (model));
for (i = 0; i < G_N_ELEMENTS (orientation_items); i++) {
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter,
COLUMN_TEXT, g_dpgettext2 (NULL, "Orientation", orientation_items [i].name),
COLUMN_ITEM, &(orientation_items [i]),
-1);
if (orientation == orientation_items [i].orientation)
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (dialog->orientation_combo),
&iter);
}
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (dialog->orientation_combo),
renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (dialog->orientation_combo),
renderer, "text", COLUMN_TEXT, NULL);
g_signal_connect_swapped (dialog->orientation_combo, "changed",
G_CALLBACK (panel_properties_dialog_orientation_changed),
dialog);
panel_properties_dialog_setup_orientation_combo_sensitivty (dialog, NULL);
}
static void
on_branch_list_command_started (AnjutaCommand *command,
GitLogPane *self)
{
GtkComboBox *branch_combo;
GtkListStore *log_branch_combo_model;
branch_combo = GTK_COMBO_BOX (gtk_builder_get_object (self->priv->builder,
"branch_combo"));
log_branch_combo_model = GTK_LIST_STORE (gtk_builder_get_object (self->priv->builder,
"log_branch_combo_model"));
gtk_combo_box_set_model (branch_combo, NULL);
gtk_list_store_clear (log_branch_combo_model);
g_hash_table_remove_all (self->priv->branches_table);
}
static void
xfce_mixer_track_combo_init (XfceMixerTrackCombo *combo)
{
GtkCellRenderer *renderer;
combo->card = NULL;
combo->track = NULL;
combo->list_store = gtk_list_store_new (2, G_TYPE_STRING, GST_TYPE_MIXER_TRACK);
gtk_combo_box_set_model (GTK_COMBO_BOX (combo), GTK_TREE_MODEL (combo->list_store));
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, TRUE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo), renderer, "text", NAME_COLUMN);
g_signal_connect_swapped (combo, "changed", G_CALLBACK (xfce_mixer_track_combo_changed), combo);
}
static gboolean
fill_algorithm_combo (SolverState *state, GnmSolverModelType type)
{
GtkListStore *store =
gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER);
GSList *solvers, *l;
int sel = 0, i;
GnmSolverParameters *param =state->sheet->solver_parameters;
gtk_combo_box_set_model (state->algorithm_combo, GTK_TREE_MODEL (store));
l = NULL;
for (solvers = gnm_solver_db_get (); solvers; solvers = solvers->next) {
GnmSolverFactory *entry = solvers->data;
if (type != entry->type)
continue;
l = g_slist_prepend (l, entry);
}
solvers = g_slist_reverse (l);
gtk_widget_set_sensitive (GTK_WIDGET (state->solve_button),
solvers != NULL);
if (!solvers)
return FALSE;
for (l = solvers, i = 0; l; l = l->next, i++) {
GnmSolverFactory *factory = l->data;
GtkTreeIter iter;
if (param->options.algorithm == factory)
sel = i;
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
0, factory->name,
1, factory,
-1);
}
g_slist_free (solvers);
gtk_combo_box_set_active (state->algorithm_combo, sel);
g_object_unref (store);
return TRUE;
}
void XAP_makeGtkComboBoxText(GtkComboBox * combo, GType secondary)
{
GtkListStore * store;
if (secondary != G_TYPE_NONE) {
store = gtk_list_store_new(2, G_TYPE_STRING, secondary);
}
else {
store = gtk_list_store_new(1, G_TYPE_STRING);
}
gtk_combo_box_set_model(combo, GTK_TREE_MODEL(store));
gtk_cell_layout_clear(GTK_CELL_LAYOUT(combo));
GtkCellRenderer *cell = GTK_CELL_RENDERER(gtk_cell_renderer_text_new());
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo), cell, TRUE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo), cell,
"text", 0, NULL);
}
void
gtk_filebutton_set_recent_group(GtkFilebutton *filebutton, const gchar *recent_group)
{
g_return_if_fail(filebutton != NULL);
g_return_if_fail(GTK_IS_FILEBUTTON(filebutton));
// Prepare for the case that we are called with the old value of
// filebutton->recent_group. In this case we need to prevent to
// access the old value after it is already feed.
gchar *old = filebutton->recent_group;
filebutton->recent_group = g_strdup(recent_group);
g_free(old);
GtkListStore *store = get_list_store(filebutton->recent_group);
gtk_combo_box_set_model(GTK_COMBO_BOX(filebutton->comboboxentry), GTK_TREE_MODEL(store));
g_object_unref(store);
}
/**
* create a text only combo_box with an index
* column 0 will contain the text
* column 1 will have the index, in the order of the strings
*
* this function takes an array of string and attribute a number beginning by the first element of the array
* to link some text with a special number, use gsb_combo_box_new_with_index_by_list
*
* \param string a pointer to an array of strings terminated by NULL, string will be appended in that order
* \param func an optional function to call when change the current item (gboolean func (GtkWidget *combox, gpointer data)
* \param data the data to send to the func
*
* \return a combo box widget
* */
GtkWidget *gsb_combo_box_new_with_index ( gchar **string,
GCallback func,
gpointer data )
{
GtkWidget *combo_box;
GtkListStore *store;
GtkCellRenderer *renderer;
gint i = 0;
combo_box = gtk_combo_box_new ();
store = gtk_list_store_new ( 2,
G_TYPE_STRING,
G_TYPE_INT );
if (string)
{
while (string[i])
{
GtkTreeIter iter;
gtk_list_store_append ( GTK_LIST_STORE (store),
&iter );
gtk_list_store_set ( store,
&iter,
0, string[i],
1, i,
-1 );
i++;
}
}
gtk_combo_box_set_model ( GTK_COMBO_BOX (combo_box),
GTK_TREE_MODEL (store));
if ( func )
g_signal_connect ( G_OBJECT (combo_box),
"changed",
G_CALLBACK(func),
data );
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_box), renderer,
"text", 0,
NULL);
return combo_box;
}
static void
notes_area_do_set_project (NotesArea *na, GttProject *proj)
{
const char * str;
GttTask *tsk;
if (!na) return;
if (na->ignore_events) return;
/* Calling gtk_entry_set_text makes 'changed' events happen,
* which causes us to get the entry text, which exposes a gtk
* bug. So we work around the bug and save cpu time by ignoring
* change events during a mass update. */
na->ignore_events = TRUE;
/* Note Bene its OK to have the proj be null: this has the
* effect of clearing all the fields out.
*/
na->proj = proj;
/* Fetch data from the data engine, stuff it into the GUI. */
str = gtt_project_get_title (proj);
if (!str) str = "";
gtk_entry_set_text (na->proj_title, str);
str = gtt_project_get_desc (proj);
if (!str) str = "";
gtk_entry_set_text (na->proj_desc, str);
str = gtt_project_get_notes (proj);
if (!str) str = "";
xxxgtk_textview_set_text (na->proj_notes, str);
GtkTreeModel *model = build_task_combo_model (proj);
gtk_combo_box_set_model (na->task_combo, model);
g_object_unref (model);
tsk = gtt_project_get_current_task (proj);
if (tsk == NULL)
tsk = gtt_project_get_first_task (proj);
notes_area_choose_task (na, tsk);
na->ignore_events = FALSE;
}
void
setup_renderer_combo (GtkBuilder *builder)
{
GtkListStore *store;
GtkCellRenderer *renderer;
/* Create the renderer combo from gtk-builder */
renderer_combo =
GTK_WIDGET(gtk_builder_get_object(builder,
"renderer-combobox"));
g_assert (renderer_combo != NULL);
/* Catch selection changes from the renderer combo */
g_signal_connect (renderer_combo, "changed",
G_CALLBACK (on_renderer_combo_changed), NULL);
/* Create a list store for renderers and set it to the combo */
store = gtk_list_store_new (RENDERER_COMBO_COLUMNS,
G_TYPE_STRING, /* Name */
G_TYPE_OBJECT, /* Renderer */
G_TYPE_UINT, /* State */
G_TYPE_UINT, /* Volume */
G_TYPE_UINT); /* Duration */
gtk_combo_box_set_model (GTK_COMBO_BOX (renderer_combo),
GTK_TREE_MODEL(store));
g_object_unref (store);
/* Create a text cell renderer for renderer name to the combo */
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (renderer_combo),
renderer, TRUE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (renderer_combo),
renderer, "text",
RENDERER_COMBO_COLUMN_NAME);
/* Get the frame-on-pause button from gtk-builder */
fop_button =
GTK_WIDGET(gtk_builder_get_object(builder,
"frame-on-pause-button"));
g_assert (fop_button != NULL);
/* Catch selection changes from the renderer combo */
g_signal_connect (fop_button, "changed",
G_CALLBACK (on_renderer_combo_changed), NULL);
}
void on_btnSearch_clicked (GtkWidget *widget, void * user_data) {
puts("\nFunction on_btnSearch_clicked:");
if (!strcmp((const char *)gtk_entry_get_text(gui->urlTxt),"")) puts("Empty URL provided");
else puts((const char *)gtk_entry_get_text(gui->urlTxt));
if (strcmp((const char *)gtk_entry_get_text(gui->urlTxt),"")) {
int size,k;
GtkListStore* list_store;
GtkCellRenderer* renderer;
GtkTreeIter iter;
gtk_cell_layout_clear(GTK_CELL_LAYOUT(gui->qualBox));
list_store = gtk_list_store_new ( 1 , GTK_TYPE_STRING);
gtk_combo_box_set_model(GTK_COMBO_BOX(gui->qualBox), GTK_TREE_MODEL(list_store));
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(gui->qualBox), renderer, 0x01);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(gui->qualBox), renderer, "text", 0, NULL);
gtk_widget_set_sensitive(widget,0x00);
get_format((const char *)gtk_entry_get_text(gui->urlTxt), &size);
printf("Got format. Size: %d\n", size);
// cstring format[size];
puts("Format info:");
for (k=0; k<size; ++k) {
cstring format = malloc(35*sizeof(char));
sprintf(format,"%d: %s [%s]%c",quality[k]->value,quality[k]->format, quality[k]->size,'\0');
GtkTreeIter * iter;
gtk_list_store_append(list_store, &iter);
gtk_list_store_set(list_store, &iter, 0, format,-1);
free(format);
}
// cstring filename = malloc(257*sizeof(char));
get_title((const char *) gtk_entry_get_text(gui->urlTxt), &title);
printf("%s.%s\n",title,quality[0]->format);
// sprintf(filename,"%s.%s", title, quality[0]->format);
gtk_combo_box_set_active(GTK_COMBO_BOX(gui->qualBox),0);
gtk_widget_set_sensitive(widget,0x01);
//http://www.youtube.com/watch?v=SniIBm-PWUM
}
}
static void
build_branches_combo(GitgWindow *window, GtkBuilder *builder)
{
GtkComboBox *combo = GTK_COMBO_BOX(gtk_builder_get_object(builder, "combo_box_branches"));
window->priv->branches_store = gtk_list_store_new(1, G_TYPE_STRING);
window->priv->combo_branches = combo;
GtkTreeIter iter;
gtk_list_store_append(window->priv->branches_store, &iter);
gtk_list_store_set(window->priv->branches_store, &iter, 0, _("Select branch"), -1);
gtk_combo_box_set_model(combo, GTK_TREE_MODEL(window->priv->branches_store));
gtk_combo_box_set_active(combo, 0);
gtk_combo_box_set_row_separator_func(combo, branches_separator_func, window, NULL);
g_signal_connect(combo, "changed", G_CALLBACK(on_branches_combo_changed), window);
}
static void
share_nfs_create_combo (void)
{
GtkWidget *combo = gst_dialog_get_widget (tool->main_dialog, "share_nfs_host_type");
GtkListStore *store;
store = gtk_list_store_new (NFS_HOST_COL_LAST,
GDK_TYPE_PIXBUF,
G_TYPE_STRING,
G_TYPE_INT,
G_TYPE_STRING,
G_TYPE_STRING);
gtk_combo_box_set_model (GTK_COMBO_BOX (combo), GTK_TREE_MODEL (store));
g_object_unref (store);
combo_add_columns (GTK_COMBO_BOX (combo));
}
GtkWidget *dev_select_combo_box_new(GtkWindow *parent)
{
GtkWidget *dev = gtk_combo_box_new();
/* Populate device list */
GtkListStore *devlist = gtk_list_store_new(3,
G_TYPE_STRING, G_TYPE_POINTER, GTK_TYPE_CHECK_MENU_ITEM);
GtkCellRenderer *cel = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(dev), cel, TRUE);
gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(dev), cel, "text", 0);
gtk_combo_box_set_model(GTK_COMBO_BOX(dev), GTK_TREE_MODEL(devlist));
g_signal_connect(dev, "changed", G_CALLBACK(dev_selected), parent);
g_object_set_data(G_OBJECT(parent), "devcombo", dev);
dev_select_rescan(NULL, parent);
return dev;
}
void xfce_mixer_card_combo_update (XfceMixerCardCombo *combo, GstElement *card)
{
GtkTreeIter tree_iter;
GList *iter;
combo->list_store = gtk_list_store_new (2, G_TYPE_STRING, GST_TYPE_ELEMENT);
gtk_combo_box_set_model (GTK_COMBO_BOX (combo), GTK_TREE_MODEL (combo->list_store));
for (iter = xfce_mixer_get_cards (); iter != NULL; iter = g_list_next (iter))
{
gtk_list_store_append (combo->list_store, &tree_iter);
gtk_list_store_set (combo->list_store, &tree_iter,
NAME_COLUMN, xfce_mixer_get_card_display_name (iter->data),
CARD_COLUMN, iter->data, -1);
}
_xfce_mixer_card_combo_set_active_card (combo, card);
}
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_default_mixer (GladeXML *dialog)
{
GtkWidget *device_widget, *tracks_widget;
GtkTreeModel *model;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
gchar *mixer_device;
device_widget = WID ("mixer_device");
tracks_widget = WID ("mixer_tracks");
model = create_mixer_device_tree_model ();
gtk_combo_box_set_model (GTK_COMBO_BOX (device_widget), model);
g_object_unref (G_OBJECT (model));
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (device_widget), renderer, TRUE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (device_widget), renderer,
"text", MIXER_DEVICE_MODEL_NAME_COLUMN);
g_signal_connect (G_OBJECT (device_widget), "changed",
G_CALLBACK (mixer_device_combobox_changed), NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tracks_widget),
-1, NULL, renderer,
"text", MIXER_TRACKS_MODEL_LABEL_COLUMN, NULL);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tracks_widget));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
g_signal_connect (G_OBJECT (selection), "changed",
G_CALLBACK (mixer_tracks_selection_changed), NULL);
gconf_client_notify_add (gconf_client, DEFAULT_MIXER_DEVICE_KEY,
(GConfClientNotifyFunc) default_mixer_device_notify, dialog, NULL, NULL);
gconf_client_notify_add (gconf_client, DEFAULT_MIXER_TRACKS_KEY,
(GConfClientNotifyFunc) default_mixer_tracks_notify, dialog, NULL, NULL);
mixer_device = gconf_client_get_string (gconf_client, DEFAULT_MIXER_DEVICE_KEY, NULL);
update_mixer_device_combobox (mixer_device, dialog);
g_free (mixer_device);
}
static void
update_from_model(MathConverter *converter)
{
GtkTreeStore *from_model;
from_model = gtk_tree_store_new(3, G_TYPE_STRING, G_TYPE_OBJECT, G_TYPE_OBJECT);
if (converter->priv->category == NULL) {
const GList *categories, *iter;
categories = unit_manager_get_categories(unit_manager_get_default());
for (iter = categories; iter; iter = iter->next) {
UnitCategory *category = iter->data;
GtkTreeIter parent;
const GList *unit_iter;
gtk_tree_store_append(from_model, &parent, NULL);
gtk_tree_store_set(from_model, &parent, 0, unit_category_get_display_name(category), 1, category, -1);
for (unit_iter = unit_category_get_units(category); unit_iter; unit_iter = unit_iter->next) {
Unit *unit = unit_iter->data;
GtkTreeIter iter;
gtk_tree_store_append(from_model, &iter, &parent);
gtk_tree_store_set(from_model, &iter, 0, unit_get_display_name(unit), 1, category, 2, unit, -1);
}
}
}
else {
UnitCategory *category;
const GList *unit_iter;
category = unit_manager_get_category(unit_manager_get_default(), converter->priv->category);
for (unit_iter = unit_category_get_units(category); unit_iter; unit_iter = unit_iter->next) {
Unit *unit = unit_iter->data;
GtkTreeIter iter;
gtk_tree_store_append(from_model, &iter, NULL);
gtk_tree_store_set(from_model, &iter, 0, unit_get_display_name(unit), 1, category, 2, unit, -1);
}
}
gtk_combo_box_set_model(GTK_COMBO_BOX(converter->priv->from_combo), GTK_TREE_MODEL(from_model));
}
static GObject *
e_source_combo_box_constructor (GType type, guint n_construct_properties,
GObjectConstructParam *construct_properties)
{
GtkCellRenderer *renderer;
GtkListStore *store;
GObject *object;
/* Chain up to parent's "constructor" method. */
object = G_OBJECT_CLASS (parent_class)->constructor (
type, n_construct_properties, construct_properties);
store = gtk_list_store_new (
NUM_COLUMNS,
GDK_TYPE_COLOR, /* COLUMN_COLOR */
G_TYPE_STRING, /* COLUMN_NAME */
G_TYPE_BOOLEAN, /* COLUMN_SENSITIVE */
G_TYPE_OBJECT, /* COLUMN_SOURCE */
G_TYPE_BOOLEAN); /* COLUMN_VISIBLE */
gtk_combo_box_set_model (
GTK_COMBO_BOX (object), GTK_TREE_MODEL (store));
renderer = e_cell_renderer_color_new ();
gtk_cell_layout_pack_start (
GTK_CELL_LAYOUT (object), renderer, FALSE);
gtk_cell_layout_set_attributes (
GTK_CELL_LAYOUT (object), renderer,
"color", COLUMN_COLOR,
"sensitive", COLUMN_SENSITIVE,
"visible", COLUMN_VISIBLE,
NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (
GTK_CELL_LAYOUT (object), renderer, TRUE);
gtk_cell_layout_set_attributes (
GTK_CELL_LAYOUT (object), renderer,
"text", COLUMN_NAME,
"sensitive", COLUMN_SENSITIVE,
NULL);
return object;
}
QMetaObject::Connection
gtk_combo_box_set_qmodel(GtkComboBox *box, QAbstractItemModel *qmodel, QItemSelectionModel *selection_model)
{
QMetaObject::Connection connection;
GtkTreeModel *model;
model = (GtkTreeModel *)gtk_q_tree_model_new(
qmodel,
1,
0, Qt::DisplayRole, G_TYPE_STRING);
/* use a filter model to remove disabled items */
GtkTreeModel *filter_model = gtk_tree_model_filter_new(model, NULL);
gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(filter_model),
(GtkTreeModelFilterVisibleFunc)filter_disabled_items,
NULL, NULL);
gtk_combo_box_set_model(box, GTK_TREE_MODEL(filter_model));
GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(box), renderer, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(box), renderer,
"text", 0, NULL);
if (!selection_model) return connection;
/* sync the initial selection */
gtk_combo_box_set_active_index(box, selection_model->currentIndex());
/* connect signals to and from the selection model */
connection = QObject::connect(
selection_model,
&QItemSelectionModel::currentChanged,
[=](const QModelIndex current, G_GNUC_UNUSED const QModelIndex & previous) {
gtk_combo_box_set_active_index(box, current);
}
);
g_signal_connect(box,
"changed",
G_CALLBACK(update_selection),
selection_model);
return connection;
}
static void
presence_chooser_dialog_setup (CustomMessageDialog *dialog)
{
GtkListStore *store;
GtkCellRenderer *renderer;
GtkTreeIter iter;
guint i;
store = gtk_list_store_new (COL_COUNT,
G_TYPE_STRING, /* Icon name */
G_TYPE_STRING, /* Label */
MC_TYPE_PRESENCE); /* Presence */
gtk_combo_box_set_model (GTK_COMBO_BOX (dialog->combobox_status),
GTK_TREE_MODEL (store));
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (dialog->combobox_status), renderer, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (dialog->combobox_status), renderer,
"icon-name", COL_ICON,
NULL);
g_object_set (renderer, "stock-size", GTK_ICON_SIZE_BUTTON, NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (dialog->combobox_status), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (dialog->combobox_status), renderer,
"text", COL_LABEL,
NULL);
for (i = 0; i < G_N_ELEMENTS (states); i += 2) {
if (!states[i+1]) {
continue;
}
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
COL_ICON, empathy_icon_name_for_presence (states[i]),
COL_LABEL, empathy_presence_get_default_message (states[i]),
COL_PRESENCE, states[i],
-1);
}
gtk_combo_box_set_active (GTK_COMBO_BOX (dialog->combobox_status), 0);
}
int
ags_channel_link_collection_editor_parent_set_callback(GtkWidget *widget, GtkObject *old_parent, AgsChannelLinkCollectionEditor *channel_link_collection_editor)
{
AgsMachineEditor *machine_editor;
if(old_parent != NULL)
return(0);
machine_editor = (AgsMachineEditor *) gtk_widget_get_ancestor(widget,
AGS_TYPE_MACHINE_EDITOR);
if(machine_editor != NULL &&
machine_editor->machine != NULL){
gtk_combo_box_set_model(channel_link_collection_editor->link,
GTK_TREE_MODEL(ags_machine_get_possible_links(machine_editor->machine)));
ags_channel_link_collection_editor_check(channel_link_collection_editor);
}
}
static void
gimp_enum_combo_box_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GtkComboBox *combo_box = GTK_COMBO_BOX (object);
switch (prop_id)
{
case PROP_MODEL:
gtk_combo_box_set_model (combo_box, g_value_get_object (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
/*!
\brief fills in the AFR calibrator combobutton with the appropriate
choices. The model stores the corresponding enum for later
\param combo is a pointer to the combobutton to initialize
\returns TRUE on success, FALSE otherwise
*/
G_MODULE_EXPORT gboolean populate_afr_calibrator_combo(GtkWidget *combo)
{
GtkListStore *store = NULL;
GtkTreeIter iter;
gint i = 0;
g_return_val_if_fail(GTK_IS_COMBO_BOX(combo),FALSE);
store = gtk_list_store_new(NUM_COLS,G_TYPE_STRING,G_TYPE_INT);
for (i=0;i<num_symbols;i++)
{
gtk_list_store_append(store,&iter);
gtk_list_store_set(store,&iter,COL_NAME,AFR_Tables[i].name,COL_SYMBOL,AFR_Tables[i].symbol,-1);
}
gtk_combo_box_set_model(GTK_COMBO_BOX(combo),GTK_TREE_MODEL(store));
gtk_combo_box_entry_set_text_column(GTK_COMBO_BOX_ENTRY(combo),0);
return TRUE;
}
static void
setup_filesystem_menu(FormatDialog* dialog)
{
GtkTreeStore* model;
model = gtk_tree_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN);
GtkComboBox* combo = dialog->fs_combo;
GtkCellRenderer* text_renderer;
gtk_combo_box_set_model(combo, GTK_TREE_MODEL(model));
dialog->fs_model = model;
/* Set up the column */
gtk_cell_layout_pack_start( GTK_CELL_LAYOUT(combo), (text_renderer = gtk_cell_renderer_text_new()), TRUE );
gtk_cell_layout_add_attribute( GTK_CELL_LAYOUT(combo), text_renderer, "markup", FS_COLUMN_MARKUP );
gtk_cell_layout_add_attribute( GTK_CELL_LAYOUT(combo), text_renderer, "sensitive", FS_COLUMN_SENSITIVE );
/* Add the default items */
gtk_tree_store_insert_with_values(model, NULL, NULL, 100 /*Always at end*/,
FS_COLUMN_REALNAME, "friendly_vfat",
FS_COLUMN_MARKUP, _("For all computers"),
FS_COLUMN_SENSITIVE, TRUE, -1);
gtk_tree_store_insert_with_values(model, NULL, NULL, 100 /*Always at end*/,
FS_COLUMN_REALNAME, "friendly_ext2",
FS_COLUMN_MARKUP, _("For Linux computers"),
FS_COLUMN_SENSITIVE, TRUE, -1);
gtk_tree_store_insert_with_values(model, NULL, NULL, 100 /*Always at end*/,
FS_COLUMN_REALNAME, "friendly_hfsplus",
FS_COLUMN_MARKUP, _("For Apple computers"),
FS_COLUMN_SENSITIVE, TRUE, -1);
GtkTreeIter parent = {0, NULL};
gtk_tree_store_insert_with_values(model, &parent, NULL, 100 /*Always at end*/,
FS_COLUMN_REALNAME, "specific_fs",
FS_COLUMN_MARKUP, _("Specific Filesystem"),
FS_COLUMN_SENSITIVE, TRUE, -1);
/* Populate the specific fs list */
struct _setup_fs_duple s;
s.model = model; s.parent = &parent;
dialog->fs_map = build_supported_fs_list();
g_hash_table_foreach(dialog->fs_map, setup_fs_cb, &s);
}
