void palTreeModelSetSortKey(PalTreeModel *model, PalTreeModelSortKey key) {
switch(key) {
case PalTreeModelSortKey::NICKNAME:
gtk_tree_sortable_set_default_sort_func(GTK_TREE_SORTABLE(model), GtkTreeIterCompareFunc(paltreeCompareByNameFunc), NULL,
NULL);
break;
case PalTreeModelSortKey::IP:
gtk_tree_sortable_set_default_sort_func(GTK_TREE_SORTABLE(model), GtkTreeIterCompareFunc(paltreeCompareByIPFunc), NULL,
NULL);
break;
default:
LOG_WARN("unknown PalTreeModelSortKey: %d", key);
}
}
/**
* gtr_message_table_populate:
* @table: a #GtrMessageTable
* @container: a list of #GtrMsg
*
* Populates the #GtrMessageTable with the list of #GtrMsg and
* sort them.
*/
void
gtr_message_table_populate (GtrMessageTable * table, GtrMessageContainer * container)
{
GtrMessageTablePrivate *priv;
g_return_if_fail (table != NULL);
g_return_if_fail (container != NULL);
priv = gtr_message_table_get_instance_private (table);
if (priv->store)
{
gtk_tree_view_set_model (GTK_TREE_VIEW (priv->treeview), NULL);
g_object_unref (priv->sort_model);
g_object_unref (priv->store);
}
priv->store = gtr_message_table_model_new (container);
priv->sort_model =
gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (priv->store));
gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE
(priv->sort_model),
NULL, NULL, NULL);
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (priv->sort_model),
GTR_MESSAGE_TABLE_MODEL_STATUS_COLUMN,
model_compare_by_status, NULL, NULL);
gtr_message_table_sort_by (table, priv->sort_status);
gtk_tree_view_set_model (GTK_TREE_VIEW (priv->treeview),
priv->sort_model);
}
/**
* gtr_message_table_populate:
* @table: a #GtrMessageTable
* @container: a list of #GtrMsg
*
* Populates the #GtrMessageTable with the list of #GtrMsg and
* sort them.
*/
void
gtr_message_table_populate (GtrMessageTable * table, GtrMessageContainer * container)
{
g_return_if_fail (table != NULL);
g_return_if_fail (container != NULL);
if (table->priv->store)
{
gtk_tree_view_set_model (GTK_TREE_VIEW (table->priv->treeview), NULL);
g_object_unref (table->priv->sort_model);
g_object_unref (table->priv->store);
}
table->priv->store = gtr_message_table_model_new (container);
table->priv->sort_model =
gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (table->priv->store));
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE
(table->priv->sort_model),
GTR_MESSAGE_TABLE_MODEL_ID_COLUMN,
GTK_SORT_ASCENDING);
gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE
(table->priv->sort_model),
NULL, NULL, NULL);
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (table->priv->sort_model),
GTR_MESSAGE_TABLE_MODEL_STATUS_COLUMN,
model_compare_by_status, NULL, NULL);
gtk_tree_view_set_model (GTK_TREE_VIEW (table->priv->treeview),
table->priv->sort_model);
}
GtkTreeView*
ifaces_list_create (GstTool *tool)
{
GtkWidget *table = gst_dialog_get_widget (tool->main_dialog, "interfaces_list");
GstTablePopup *table_popup;
GtkTreeSelection *selection;
GtkTreeModel *model;
model = GST_NETWORK_TOOL (tool)->interfaces_model;
gtk_tree_view_set_model (GTK_TREE_VIEW (table), model);
gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (GTK_LIST_STORE (model)),
ifaces_list_sort,
NULL, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (GTK_LIST_STORE (model)),
GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
GTK_SORT_DESCENDING);
add_list_columns (GTK_TREE_VIEW (table), model);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (table));
g_signal_connect (G_OBJECT (selection), "changed",
G_CALLBACK (on_table_selection_changed), NULL);
table_popup = g_new0 (GstTablePopup, 1);
table_popup->properties = on_iface_properties_clicked;
table_popup->popup = popup_menu_create (table);
g_signal_connect (G_OBJECT (table), "button-press-event",
G_CALLBACK (on_table_button_press), (gpointer) table_popup);
g_signal_connect (G_OBJECT (table), "popup_menu",
G_CALLBACK (on_table_popup_menu), (gpointer) table_popup);
return GTK_TREE_VIEW (table);
}
static void
eog_list_store_init (EogListStore *self)
{
GType types[EOG_LIST_STORE_NUM_COLUMNS];
types[EOG_LIST_STORE_THUMBNAIL] = GDK_TYPE_PIXBUF;
types[EOG_LIST_STORE_EOG_IMAGE] = G_TYPE_OBJECT;
types[EOG_LIST_STORE_THUMB_SET] = G_TYPE_BOOLEAN;
types[EOG_LIST_STORE_EOG_JOB] = G_TYPE_POINTER;
gtk_list_store_set_column_types (GTK_LIST_STORE (self),
EOG_LIST_STORE_NUM_COLUMNS, types);
self->priv = EOG_LIST_STORE_GET_PRIVATE (self);
self->priv->monitors = NULL;
self->priv->initial_image = -1;
self->priv->busy_image = eog_list_store_get_icon ("image-loading");
self->priv->missing_image = eog_list_store_get_icon ("image-missing");
g_mutex_init (&self->priv->mutex);
gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (self),
eog_list_store_compare_func,
NULL, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (self),
GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
GTK_SORT_ASCENDING);
}
static GtkTreeModel *
subtitle_encoding_create_store (void)
{
gchar *label;
const gchar *lastlang = "";
GtkTreeIter iter, iter2;
GtkTreeStore *store;
int i;
store = gtk_tree_store_new (2, G_TYPE_INT, G_TYPE_STRING);
for (i = 0; i < SUBTITLE_ENCODING_LAST; i++) {
if (strcmp (lastlang, encodings[i].name)) {
lastlang = encodings[i].name;
gtk_tree_store_append (store, &iter, NULL);
gtk_tree_store_set (store, &iter, INDEX_COL,
-1, NAME_COL, lastlang, -1);
}
label = g_strdup_printf("%s (%s)", lastlang, encodings[i].charset);
gtk_tree_store_append (store, &iter2, &iter);
gtk_tree_store_set (store, &iter2, INDEX_COL,
encodings[i].index, NAME_COL, label, -1);
g_free(label);
}
gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (store),
compare, NULL, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store),
NAME_COL, GTK_SORT_ASCENDING);
return GTK_TREE_MODEL (store);
}
static void
file_view_init (AnjutaFileView *object)
{
GtkCellRenderer* renderer_pixbuf;
GtkCellRenderer* renderer_display;
GtkTreeViewColumn* column;
GtkTreeSelection* selection;
GtkTreeModel* sort_model;
AnjutaFileViewPrivate* priv = ANJUTA_FILE_VIEW_GET_PRIVATE (object);
priv->current_selection = NULL;
priv->model = file_model_new (GTK_TREE_VIEW(object), NULL);
g_signal_connect_object (priv->model, "directory-expanded",
G_CALLBACK (file_view_directory_expanded), object, 0);
sort_model = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(priv->model));
gtk_tree_view_set_model (GTK_TREE_VIEW(object), sort_model);
/* set_model takes a reference so we can release the reference we got when
* the sort_model was created. */
g_object_unref (sort_model);
gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE(sort_model),
file_view_sort_model,
NULL,
NULL);
renderer_pixbuf = gtk_cell_renderer_pixbuf_new ();
renderer_display = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Filename"));
gtk_tree_view_column_pack_start (column, renderer_pixbuf, FALSE);
gtk_tree_view_column_pack_start (column, renderer_display, FALSE);
gtk_tree_view_column_set_cell_data_func(column,
renderer_pixbuf,
file_view_render_pixbuf_with_emblem,
object, NULL);
gtk_tree_view_column_set_attributes (column, renderer_display,
"markup", COLUMN_DISPLAY,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (object), column);
selection =
gtk_tree_view_get_selection (GTK_TREE_VIEW (object));
g_signal_connect (selection, "changed",
G_CALLBACK (file_view_selection_changed), object);
/* DND */
gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW(object),
GDK_BUTTON1_MASK,
uri_targets,
1,
GDK_ACTION_MOVE);
/* Typeahead search */
gtk_tree_view_set_search_column (GTK_TREE_VIEW (object), COLUMN_FILENAME);
}
static void
gsltma_set_default_sort_func(GtkTreeSortable *sortable,
GtkTreeIterCompareFunc func,
gpointer data,
GDestroyNotify destroy)
{
gtk_tree_sortable_set_default_sort_func(GTK_TREE_SORTABLE(GNC_SX_LIST_TREE_MODEL_ADAPTER(sortable)->real),
func, data, destroy);
}
UmLanguageDialog *
um_language_dialog_new (void)
{
GtkBuilder *builder;
GtkWidget *widget;
UmLanguageDialog *um;
const gchar *filename;
GtkListStore *store;
GError *error = NULL;
builder = gtk_builder_new ();
filename = UIDIR "/language-dialog.ui";
if (!g_file_test (filename, G_FILE_TEST_EXISTS))
filename = "../data/language-dialog.ui";
if (!gtk_builder_add_from_file (builder, filename, &error)) {
g_error ("%s", error->message);
g_error_free (error);
exit (1);
}
um = g_new0 (UmLanguageDialog, 1);
widget = (GtkWidget *) gtk_builder_get_object (builder, "dialog");
g_signal_connect (widget, "delete-event",
G_CALLBACK (gtk_widget_hide_on_delete), NULL);
um->dialog = widget;
widget = (GtkWidget *) gtk_builder_get_object (builder, "cancel-button");
g_signal_connect (widget, "clicked",
G_CALLBACK (cancel_language_dialog), um);
widget = (GtkWidget *) gtk_builder_get_object (builder, "ok-button");
g_signal_connect (widget, "clicked",
G_CALLBACK (accept_language_dialog), um);
gtk_widget_grab_default (widget);
store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (store),
sort_languages, NULL, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store),
GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
GTK_SORT_ASCENDING);
um->dialog_store = store;
widget = (GtkWidget *) gtk_builder_get_object (builder, "language-combobox");
gtk_combo_box_set_model (GTK_COMBO_BOX (widget), GTK_TREE_MODEL (store));
g_signal_connect (widget, "changed",
G_CALLBACK (language_combo_changed), um);
um->dialog_combo = widget;
um->user_icon = (GtkWidget *) gtk_builder_get_object (builder, "user-icon");
um->user_name = (GtkWidget *) gtk_builder_get_object (builder, "user-name");
return um;
}
void gTree::sort()
{
if (!_sorted)
return;
// BM: force the store to be sorted
gtk_tree_sortable_set_default_sort_func(GTK_TREE_SORTABLE(store), (GtkTreeIterCompareFunc)tree_compare, this, NULL);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING);
_sort_dirty = false;
}
ViewDir *vdtree_new(ViewDir *vd, FileData *dir_fd)
{
GtkTreeStore *store;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
vd->info = g_new0(ViewDirInfoTree, 1);
vd->type = DIRVIEW_TREE;
vd->dnd_drop_leave_func = vdtree_dnd_drop_expand_cancel;
vd->dnd_drop_update_func = vdtree_dnd_drop_expand;
store = gtk_tree_store_new(6, G_TYPE_POINTER, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING);
vd->view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
g_object_unref(store);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(vd->view), FALSE);
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(vd->view), FALSE);
gtk_tree_sortable_set_default_sort_func(GTK_TREE_SORTABLE(store), vdtree_sort_cb, vd, NULL);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store),
GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(vd->view));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
gtk_tree_selection_set_select_function(selection, vdtree_select_cb, vd, NULL);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", DIR_COLUMN_ICON);
gtk_tree_view_column_set_cell_data_func(column, renderer, vd_color_cb, vd, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_add_attribute(column, renderer, "text", DIR_COLUMN_NAME);
gtk_tree_view_column_set_cell_data_func(column, renderer, vd_color_cb, vd, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(vd->view), column);
gtk_tree_view_set_tooltip_column(GTK_TREE_VIEW(vd->view), DIR_COLUMN_LINK);
vdtree_setup_root(vd);
g_signal_connect(G_OBJECT(vd->view), "row_expanded",
G_CALLBACK(vdtree_row_expanded), vd);
g_signal_connect(G_OBJECT(vd->view), "row_collapsed",
G_CALLBACK(vdtree_row_collapsed), vd);
return vd;
}
int artistlist_init(GladeXML *xml)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeSelection *select;
artistlist = gtk_list_store_new (ARTIST_N_COLUMNS,
G_TYPE_POINTER, /* artist ptr */
G_TYPE_STRING /* artist */
);
artisttreeview = GTK_TREE_VIEW(glade_xml_get_widget(xml, "artist"));
gtk_tree_view_set_model(artisttreeview, GTK_TREE_MODEL(artistlist));
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Artist",
renderer,
"text", ARTIST_COLUMN,
NULL);
gtk_tree_view_append_column (artisttreeview, column);
gtk_tree_sortable_set_default_sort_func(GTK_TREE_SORTABLE(artistlist),
artistlist_default_sort,
NULL, NULL);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(artistlist),
GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
GTK_SORT_ASCENDING);
select = gtk_tree_view_get_selection(GTK_TREE_VIEW(artisttreeview));
gtk_tree_selection_set_mode(select, GTK_SELECTION_SINGLE);
g_signal_connect(G_OBJECT(select), "changed",
G_CALLBACK(on_artist_selection_changed),
NULL);
/* set it up as a drag source */
gtk_tree_view_enable_model_drag_source(GTK_TREE_VIEW(artisttreeview),
GDK_BUTTON1_MASK,
artistlist_src_targets,
artistlist_src_n_targets,
GDK_ACTION_LINK);
g_signal_connect(G_OBJECT(artisttreeview), "drag-begin",
G_CALLBACK(on_artist_drag_begin),
NULL);
g_signal_connect(G_OBJECT(artisttreeview), "drag-data-get",
G_CALLBACK(on_artist_drag_data_get),
NULL);
g_signal_connect(G_OBJECT(artisttreeview), "drag-end",
G_CALLBACK(on_artist_drag_end),
NULL);
return 1;
}
static void
file_view_init (AnjutaFileView *object)
{
GtkCellRenderer* renderer_pixbuf;
GtkCellRenderer* renderer_display;
GtkTreeViewColumn* column;
GtkTreeSelection* selection;
GtkTreeModel* sort_model;
AnjutaFileViewPrivate* priv = ANJUTA_FILE_VIEW_GET_PRIVATE (object);
priv->current_selection = NULL;
priv->model = file_model_new (GTK_TREE_VIEW(object), NULL);
sort_model = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(priv->model));
gtk_tree_view_set_model (GTK_TREE_VIEW(object), sort_model);
gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE(sort_model),
file_view_sort_model,
NULL,
NULL);
renderer_pixbuf = gtk_cell_renderer_pixbuf_new ();
renderer_display = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Filename"));
gtk_tree_view_column_pack_start (column, renderer_pixbuf, FALSE);
gtk_tree_view_column_pack_start (column, renderer_display, FALSE);
gtk_tree_view_column_set_attributes (column, renderer_pixbuf,
"pixbuf", COLUMN_PIXBUF,
NULL);
gtk_tree_view_column_set_attributes (column, renderer_display,
"markup", COLUMN_DISPLAY,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (object), column);
selection =
gtk_tree_view_get_selection (GTK_TREE_VIEW (object));
g_signal_connect (selection, "changed",
G_CALLBACK (file_view_selection_changed), object);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (object), FALSE);
g_object_set (object, "has-tooltip", TRUE, NULL);
/* DND */
gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW(object),
GDK_BUTTON1_MASK,
uri_targets,
1,
GDK_ACTION_MOVE);
}
GtkWidget *
um_language_chooser_new (void)
{
GtkBuilder *builder;
const char *filename;
GError *error = NULL;
GtkWidget *chooser;
GtkWidget *list;
GtkWidget *button;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
GtkListStore *store;
builder = gtk_builder_new ();
filename = UIDIR "/language-chooser.ui";
if (!g_file_test (filename, G_FILE_TEST_EXISTS))
filename = "../data/language-chooser.ui";
if (!gtk_builder_add_from_file (builder, filename, &error)) {
g_warning ("failed to load language chooser: %s", error->message);
g_error_free (error);
exit (1);
}
chooser = (GtkWidget *) gtk_builder_get_object (builder, "dialog");
list = (GtkWidget *) gtk_builder_get_object (builder, "language-list");
g_object_set_data (G_OBJECT (chooser), "list", list);
g_signal_connect (list, "row-activated",
G_CALLBACK (row_activated), chooser);
button = (GtkWidget *) gtk_builder_get_object (builder, "cancel-button");
button = (GtkWidget *) gtk_builder_get_object (builder, "ok-button");
gtk_widget_grab_default (button);
cell = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (NULL, cell, "text", DISPLAY_LOCALE_COL, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (list), column);
store = gtk_list_store_new (NUM_COLS, G_TYPE_STRING, G_TYPE_STRING);
gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (store),
sort_languages, NULL, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store),
GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
GTK_SORT_ASCENDING);
gtk_tree_view_set_model (GTK_TREE_VIEW (list), GTK_TREE_MODEL (store));
add_available_languages (store);
g_object_unref (builder);
return chooser;
}
static void
account_chooser_constructed (GObject *object)
{
EmpathyAccountChooser *self = (EmpathyAccountChooser *) object;
GtkListStore *store;
GtkCellRenderer *renderer;
GtkComboBox *combobox;
if (G_OBJECT_CLASS (empathy_account_chooser_parent_class)->constructed)
G_OBJECT_CLASS
(empathy_account_chooser_parent_class)->constructed (object);
/* Set up combo box with new store */
combobox = GTK_COMBO_BOX (self);
gtk_cell_layout_clear (GTK_CELL_LAYOUT (combobox));
store = gtk_list_store_new (COL_ACCOUNT_COUNT,
GDK_TYPE_PIXBUF, /* Image */
G_TYPE_STRING, /* Name */
G_TYPE_BOOLEAN, /* Enabled */
G_TYPE_UINT, /* Row type */
TP_TYPE_ACCOUNT);
gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (store),
account_cmp, self, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store),
GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING);
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,
"pixbuf", COL_ACCOUNT_IMAGE,
"sensitive", COL_ACCOUNT_ENABLED,
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 */
tp_proxy_prepare_async (self->priv->manager, NULL,
account_manager_prepared_cb, self);
g_object_unref (store);
}
void gTree::setSorted(bool v)
{
if (v == _sorted)
return;
_sorted = v;
_sort_column = v ? 0 : -1;
if (!_sorted)
{
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID, GTK_SORT_ASCENDING);
gtk_tree_sortable_set_default_sort_func(GTK_TREE_SORTABLE(store), NULL, NULL, NULL);
}
updateSort();
}
/**
* ephy_node_view_set_sort:
* @view: an #EphyNodeView
* @value_type: type of the value held at @prop_id by the model
* @prop_id: column id in the model
* @sort_type: the sort mode
*
* Adds a sort column to the @view corresponding to @prop_id in the model.
**/
void
ephy_node_view_set_sort (EphyNodeView *view, GType value_type, guint prop_id,
GtkSortType sort_type)
{
GtkTreeSortable *sortable = GTK_TREE_SORTABLE (view->priv->sortmodel);
int column;
column = ephy_tree_model_node_add_prop_column
(view->priv->nodemodel, value_type, prop_id);
view->priv->sort_column = column;
view->priv->sort_type = sort_type;
gtk_tree_sortable_set_default_sort_func
(sortable, (GtkTreeIterCompareFunc)ephy_node_view_sort_func,
view, NULL);
gtk_tree_sortable_set_sort_column_id
(sortable, GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
sort_type);
}
static GObject*
cryptui_key_store_constructor (GType type, guint n_props, GObjectConstructParam* props)
{
GObject *obj;
obj = G_OBJECT_CLASS (cryptui_key_store_parent_class)->constructor (type, n_props, props);
CryptUIKeyStore *ckstore = CRYPTUI_KEY_STORE (obj);
/* Hookup to the current object */
g_object_set (ckstore, "model", ckstore->priv->filter, NULL);
/* Default sort function */
gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (ckstore), sort_default_comparator, NULL, NULL);
g_signal_connect (ckstore, "sort-column-changed", G_CALLBACK (sort_changed), ckstore);
ckstore->priv->initialized = TRUE;
key_store_populate (ckstore);
return obj;
}
static void
on_entry_text_notify (GObject *object,
GParamSpec *pspec,
gpointer dummy)
{
GtkTreeIter iter;
GtkTreeView *view = GTK_TREE_VIEW (plugin_data.view);
GtkTreeModel *model = gtk_tree_view_get_model (view);
/* we force re-sorting the whole model from how it was before, and the
* back to the new filter. this is somewhat hackish but since we don't
* know the original sorting order, and GtkTreeSortable don't have a
* resort() API anyway. */
gtk_tree_model_sort_reset_default_sort_func (GTK_TREE_MODEL_SORT (model));
gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (model),
sort_func, NULL, NULL);
if (gtk_tree_model_get_iter_first (model, &iter)) {
tree_view_set_cursor_from_iter (view, &iter);
}
}
void
cc_common_language_setup_list (GtkWidget *treeview,
GHashTable *initial)
{
GtkCellRenderer *cell;
GtkTreeViewColumn *column;
GtkListStore *store;
cell = gtk_cell_renderer_text_new ();
g_object_set (cell,
"width-chars", 40,
"ellipsize", PANGO_ELLIPSIZE_END,
NULL);
column = gtk_tree_view_column_new_with_attributes (NULL, cell, "text", DISPLAY_LOCALE_COL, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
store = gtk_list_store_new (NUM_COLS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN);
gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (store),
cc_common_language_sort_languages, NULL, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store),
GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
GTK_SORT_ASCENDING);
gtk_tree_view_set_row_separator_func (GTK_TREE_VIEW (treeview),
separator_func,
NULL, NULL);
gtk_tree_view_set_model (GTK_TREE_VIEW (treeview), GTK_TREE_MODEL (store));
/* Add languages from the initial hashtable */
g_hash_table_foreach (initial, (GHFunc) languages_foreach_cb, store);
/* Mark the need for a separator if we had any languages added */
if (initial != NULL &&
g_hash_table_size (initial) > 0) {
g_object_set_data (G_OBJECT (store), "needs-separator", GINT_TO_POINTER (TRUE));
}
}
static void
gbf_project_model_instance_init (GbfProjectModel *model)
{
static GType types [GBF_PROJECT_MODEL_NUM_COLUMNS];
types [GBF_PROJECT_MODEL_COLUMN_DATA] = G_TYPE_POINTER;
gtk_tree_store_set_column_types (GTK_TREE_STORE (model),
GBF_PROJECT_MODEL_NUM_COLUMNS,
types);
model->priv = g_new0 (GbfProjectModelPrivate, 1);
model->priv->default_shortcut = TRUE;
/* sorting function */
gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (model),
default_sort_func,
NULL, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model),
GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
GTK_SORT_ASCENDING);
insert_empty_node (model);
}
Gobby::Browser::Browser(Gtk::Window& parent,
StatusBar& status_bar,
ConnectionManager& connection_manager):
m_parent(parent),
m_status_bar(status_bar),
m_connection_manager(connection_manager),
m_expander(_("_Direct Connection"), true),
m_hbox(false, 6),
m_label_hostname(_("Host Name:")),
m_entry_hostname(config_filename("recent_hosts"), 5)
{
m_label_hostname.show();
m_entry_hostname.get_entry()->signal_activate().connect(
sigc::mem_fun(*this, &Browser::on_hostname_activate));
m_entry_hostname.show();
m_hbox.pack_start(m_label_hostname, Gtk::PACK_SHRINK);
m_hbox.pack_start(m_entry_hostname, Gtk::PACK_EXPAND_WIDGET);
m_hbox.show();
m_expander.add(m_hbox);
m_expander.show();
m_expander.property_expanded().signal_changed().connect(
sigc::mem_fun(*this, &Browser::on_expanded_changed));
m_browser_store = inf_gtk_browser_store_new(
connection_manager.get_io(),
connection_manager.get_communication_manager());
m_sort_model = inf_gtk_browser_model_sort_new(
INF_GTK_BROWSER_MODEL(m_browser_store));
gtk_tree_sortable_set_default_sort_func(
GTK_TREE_SORTABLE(m_sort_model), compare_func, NULL, NULL);
if(m_connection_manager.get_discovery() != NULL)
{
inf_gtk_browser_store_add_discovery(
m_browser_store,
m_connection_manager.get_discovery());
}
Glib::ustring known_hosts_file = config_filename("known_hosts");
m_cert_checker = inf_gtk_certificate_manager_new(
parent.gobj(), m_connection_manager.get_xmpp_manager(),
known_hosts_file.c_str());
m_browser_view =
INF_GTK_BROWSER_VIEW(
inf_gtk_browser_view_new_with_model(
INF_GTK_BROWSER_MODEL(m_sort_model)));
gtk_widget_show(GTK_WIDGET(m_browser_view));
gtk_container_add(GTK_CONTAINER(m_scroll.gobj()),
GTK_WIDGET(m_browser_view));
m_scroll.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
m_scroll.set_shadow_type(Gtk::SHADOW_IN);
m_scroll.show();
g_signal_connect(
m_browser_store,
"set-browser",
G_CALLBACK(&on_set_browser_static),
this
);
g_signal_connect(
m_browser_view,
"activate",
G_CALLBACK(&on_activate_static),
this
);
set_spacing(6);
pack_start(m_scroll, Gtk::PACK_EXPAND_WIDGET);
pack_start(m_expander, Gtk::PACK_SHRINK);
init_accessibility();
set_focus_child(m_expander);
}
static void
init_infinity (GeditCollaborationWindowHelper *helper)
{
InfGtkIo *io;
InfCommunicationManager *communication_manager;
InfXmppManager *xmpp_manager;
InfCertificateCredentials *certificate_credentials;
InfGtkBrowserModel *model_sort;
io = inf_gtk_io_new ();
communication_manager = inf_communication_manager_new ();
xmpp_manager = inf_xmpp_manager_new ();
certificate_credentials = inf_certificate_credentials_new ();
helper->priv->io = INF_IO (io);
helper->priv->certificate_credentials = certificate_credentials;
helper->priv->browser_store = inf_gtk_browser_store_new (INF_IO (io),
communication_manager);
model_sort = INF_GTK_BROWSER_MODEL (
inf_gtk_browser_model_sort_new (
INF_GTK_BROWSER_MODEL (helper->priv->browser_store)
)
);
gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (model_sort),
compare_func,
NULL,
NULL);
helper->priv->browser_view =
inf_gtk_browser_view_new_with_model (model_sort);
gtk_widget_show (helper->priv->browser_view);
g_signal_connect_after (helper->priv->browser_store,
"set-browser",
G_CALLBACK (on_set_browser),
helper);
g_signal_connect (helper->priv->browser_view,
"selection-changed",
G_CALLBACK (on_selection_changed),
helper);
g_signal_connect (helper->priv->browser_view,
"populate-popup",
G_CALLBACK (on_populate_popup),
helper);
g_signal_connect (helper->priv->browser_view,
"activate",
G_CALLBACK (on_browser_activate),
helper);
#ifdef LIBINFINITY_HAVE_AVAHI
init_infinity_discovery (helper, xmpp_manager);
#endif
init_bookmarks (helper);
g_object_unref (communication_manager);
g_object_unref (xmpp_manager);
}
int
main (int argc, char *argv[])
{
GtkTreeModel *model;
gtk_init_with_args (&argc, &argv, NULL, entries, NULL, NULL);
model = GTK_TREE_MODEL (gtk_list_store_new (2, G_TYPE_INT, G_TYPE_STRING));
test_run ("list store append",
model,
(ClearFunc*)gtk_list_store_clear,
(InsertFunc*)list_store_append);
test_run ("list store prepend",
model,
(ClearFunc*)gtk_list_store_clear,
(InsertFunc*)list_store_prepend);
test_run ("list store insert",
model,
(ClearFunc*)gtk_list_store_clear,
(InsertFunc*)list_store_insert);
gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (model),
compare, NULL, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model),
GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
GTK_SORT_ASCENDING);
test_run ("list store insert (sorted)",
model,
(ClearFunc*)gtk_list_store_clear,
(InsertFunc*)list_store_insert);
g_object_unref (model);
model = GTK_TREE_MODEL (gtk_tree_store_new (2, G_TYPE_INT, G_TYPE_STRING));
test_run ("tree store append",
model,
(ClearFunc*)gtk_tree_store_clear,
(InsertFunc*)tree_store_append);
test_run ("tree store prepend",
model,
(ClearFunc*)gtk_tree_store_clear,
(InsertFunc*)tree_store_prepend);
test_run ("tree store insert (flat)",
model,
(ClearFunc*)gtk_tree_store_clear,
(InsertFunc*)tree_store_insert_flat);
test_run ("tree store insert (deep)",
model,
(ClearFunc*)gtk_tree_store_clear,
(InsertFunc*)tree_store_insert_deep);
gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (model),
compare, NULL, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model),
GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
GTK_SORT_ASCENDING);
test_run ("tree store insert (flat, sorted)",
model,
(ClearFunc*)gtk_tree_store_clear,
(InsertFunc*)tree_store_insert_flat);
test_run ("tree store insert (deep, sorted)",
model,
(ClearFunc*)gtk_tree_store_clear,
(InsertFunc*)tree_store_insert_deep);
return 0;
}
static GObject *
game_store_constructor (GType type,
guint n_construct_properties,
GObjectConstructParam *construct_properties)
{
GType types[GVA_GAME_STORE_NUM_COLUMNS];
GObject *object;
gint column = 0;
types[column++] = G_TYPE_STRING; /* COLUMN_NAME */
types[column++] = G_TYPE_STRING; /* COLUMN_BIOS */
types[column++] = G_TYPE_STRING; /* COLUMN_CATEGORY */
types[column++] = G_TYPE_BOOLEAN; /* COLUMN_FAVORITE */
types[column++] = G_TYPE_STRING; /* COLUMN_SOURCEFILE */
types[column++] = G_TYPE_BOOLEAN; /* COLUMN_ISBIOS */
types[column++] = G_TYPE_BOOLEAN; /* COLUMN_ISDEVICE */
types[column++] = G_TYPE_BOOLEAN; /* COLUMN_ISMECHANICAL */
types[column++] = G_TYPE_BOOLEAN; /* COLUMN_RUNNABLE */
types[column++] = G_TYPE_STRING; /* COLUMN_CLONEOF */
types[column++] = G_TYPE_STRING; /* COLUMN_ROMOF */
types[column++] = G_TYPE_STRING; /* COLUMN_ROMSET */
types[column++] = G_TYPE_STRING; /* COLUMN_SAMPLEOF */
types[column++] = G_TYPE_STRING; /* COLUMN_SAMPLESET */
types[column++] = G_TYPE_STRING; /* COLUMN_DESCRIPTION */
types[column++] = G_TYPE_STRING; /* COLUMN_YEAR */
types[column++] = G_TYPE_STRING; /* COLUMN_MANUFACTURER */
types[column++] = G_TYPE_INT; /* COLUMN_SOUND_CHANNELS */
types[column++] = G_TYPE_BOOLEAN; /* COLUMN_INPUT_SERVICE */
types[column++] = G_TYPE_BOOLEAN; /* COLUMN_INPUT_TILT */
types[column++] = G_TYPE_INT; /* COLUMN_INPUT_PLAYERS */
types[column++] = G_TYPE_INT; /* COLUMN_INPUT_PLAYERS_ALT */
types[column++] = G_TYPE_INT; /* COLUMN_INPUT_PLAYERS_SIM */
types[column++] = G_TYPE_INT; /* COLUMN_INPUT_BUTTONS */
types[column++] = G_TYPE_INT; /* COLUMN_INPUT_COINS */
types[column++] = G_TYPE_STRING; /* COLUMN_DRIVER_STATUS */
types[column++] = G_TYPE_STRING; /* COLUMN_DRIVER_EMULATION */
types[column++] = G_TYPE_STRING; /* COLUMN_DRIVER_COLOR */
types[column++] = G_TYPE_STRING; /* COLUMN_DRIVER_SOUND */
types[column++] = G_TYPE_STRING; /* COLUMN_DRIVER_GRAPHIC */
types[column++] = G_TYPE_STRING; /* COLUMN_DRIVER_COCKTAIL */
types[column++] = G_TYPE_STRING; /* COLUMN_DRIVER_PROTECTION */
types[column++] = G_TYPE_STRING; /* COLUMN_DRIVER_SAVESTATE */
types[column++] = G_TYPE_INT; /* COLUMN_DRIVER_PALETTESIZE */
types[column++] = GVA_TYPE_TIME; /* COLUMN_LAST_PLAYED */
types[column++] = G_TYPE_STRING; /* COLUMN_COMMENT */
types[column++] = G_TYPE_INT64; /* COLUMN_INODE */
types[column++] = G_TYPE_STRING; /* COLUMN_INPFILE */
types[column++] = GVA_TYPE_TIME; /* COLUMN_TIME */
g_assert (column == GVA_GAME_STORE_NUM_COLUMNS);
/* Chain up to parent's constructor() method. */
object = G_OBJECT_CLASS (gva_game_store_parent_class)->constructor (
type, n_construct_properties, construct_properties);
gtk_list_store_set_column_types (
GTK_LIST_STORE (object), G_N_ELEMENTS (types), types);
gtk_tree_sortable_set_default_sort_func (
GTK_TREE_SORTABLE (object),
(GtkTreeIterCompareFunc) game_store_compare,
GINT_TO_POINTER (DEFAULT_SORT_COLUMN), NULL);
for (column = 0; column < GVA_GAME_STORE_NUM_COLUMNS; column++)
gtk_tree_sortable_set_sort_func (
GTK_TREE_SORTABLE (object), column,
(GtkTreeIterCompareFunc) game_store_compare,
GINT_TO_POINTER (column), NULL);
return object;
}
void gui_help_dialog(void)
{
gpointer dialog;
GtkCellRenderer *r;
GtkTreeViewColumn *c;
GtkListStore *list;
GtkTreeSelection *select;
GtkWidget *window, *swin, *hbox, *tree, *view;
/* create dialog */
dialog = dialog_request(MANUAL, "Manual", NULL, NULL, NULL);
if (!dialog)
return;
window = dialog_window(dialog);
gtk_window_set_default_size(GTK_WINDOW(window), 800, 500);
/* split pane display */
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(window)->vbox), hbox, TRUE, TRUE, 1);
/* left pane - topics browser */
swin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swin),
GTK_POLICY_NEVER, GTK_POLICY_NEVER);
gtk_box_pack_start(GTK_BOX(hbox), swin, FALSE, TRUE, 0);
/* list */
list = gtk_list_store_new(1, G_TYPE_STRING);
tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(list));
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(swin), tree);
r = gtk_cell_renderer_text_new();
c = gtk_tree_view_column_new_with_attributes(" ", r, "text", 0, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), c);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), FALSE);
/* auto sort the topic list */
gtk_tree_sortable_set_default_sort_func(GTK_TREE_SORTABLE(GTK_TREE_MODEL(list)),
help_sort_topics, NULL, NULL);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(GTK_TREE_MODEL(list)),
GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
GTK_SORT_ASCENDING);
/* set the width of the topics pane */
gtk_widget_set_size_request(swin, 15*sysenv.gtk_fontsize, -1);
/* right pane - text */
swin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swin),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(hbox), swin, TRUE, TRUE, 0);
view = gtk_text_view_new();
gtk_text_view_set_editable(GTK_TEXT_VIEW(view), FALSE);
gtk_container_add(GTK_CONTAINER(swin), view);
/* configure the text viewing area */
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(view), GTK_WRAP_WORD);
/* NB: GTK_JUSTIFY_FILL was not supported at the time this was written */
/*
gtk_text_view_set_justification(GTK_TEXT_VIEW(view), GTK_JUSTIFY_FILL);
*/
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(view), PANEL_SPACING);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(view), PANEL_SPACING);
/* NB: these are associated with the text buffer and must be reallocated each */
/* time a new text buffer is created */
help_tag_bold=NULL;
help_tag_italic=NULL;
help_tag_invisible=NULL;
help_tag_fixed=NULL;
/* topic selection handler */
select = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
gtk_tree_selection_set_mode(select, GTK_SELECTION_SINGLE);
g_signal_connect(G_OBJECT(select), "changed",
G_CALLBACK(gui_help_topic_selected),
view);
/* terminating button */
gui_stock_button(GTK_STOCK_CLOSE, dialog_destroy, dialog,
GTK_DIALOG(window)->action_area);
/* populate the manual page */
gui_help_refresh(list);
/* expose the dialog */
gtk_widget_show_all(window);
}
static void
seahorse_pkcs11_generate_constructed (GObject *obj)
{
SeahorsePkcs11Generate *self = SEAHORSE_PKCS11_GENERATE (obj);
GtkCellRenderer *renderer;
GcrCollection *collection;
GtkBuilder *builder;
const gchar *path;
GError *error = NULL;
GtkWidget *content;
GtkWidget *widget;
G_OBJECT_CLASS (seahorse_pkcs11_generate_parent_class)->constructed (obj);
builder = gtk_builder_new ();
path = "/org/gnome/Seahorse/seahorse-pkcs11-generate.xml";
gtk_builder_add_from_resource (builder, path, &error);
if (error != NULL) {
g_warning ("couldn't load ui file: %s", path);
g_clear_error (&error);
g_object_unref (builder);
return;
}
gtk_window_set_resizable (GTK_WINDOW (self), FALSE);
content = gtk_dialog_get_content_area (GTK_DIALOG (self));
widget = GTK_WIDGET (gtk_builder_get_object (builder, "pkcs11-generate"));
gtk_container_add (GTK_CONTAINER (content), widget);
gtk_widget_show (widget);
self->bits_entry = GTK_SPIN_BUTTON (gtk_builder_get_object (builder, "key-bits"));
gtk_spin_button_set_range (self->bits_entry, 0, G_MAXINT); /* updated later */
gtk_spin_button_set_increments (self->bits_entry, 128, 128);
gtk_spin_button_set_value (self->bits_entry, 2048);
self->label_entry = GTK_ENTRY (gtk_builder_get_object (builder, "key-label"));
/* The mechanism */
self->mechanism_box = GTK_COMBO_BOX (gtk_builder_get_object (builder, "key-mechanism"));
G_STATIC_ASSERT (MECHANISM_N_COLS == G_N_ELEMENTS (MECHANISM_TYPES));
self->mechanism_store = gtk_list_store_newv (MECHANISM_N_COLS, MECHANISM_TYPES);
gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (self->mechanism_store),
on_mechanism_sort, NULL, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (self->mechanism_store),
GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING);
gtk_combo_box_set_model (self->mechanism_box, GTK_TREE_MODEL (self->mechanism_store));
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (self->mechanism_box), renderer, TRUE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (self->mechanism_box), renderer, "markup", MECHANISM_LABEL);
g_signal_connect (self->mechanism_box, "changed", G_CALLBACK (on_mechanism_changed), self);
/* The tokens */
self->token_box = GTK_COMBO_BOX (gtk_builder_get_object (builder, "key-token"));
collection = seahorse_pkcs11_backend_get_writable_tokens (NULL, CKM_RSA_PKCS_KEY_PAIR_GEN);
self->token_model = gcr_collection_model_new (collection, GCR_COLLECTION_MODEL_LIST,
"icon", G_TYPE_ICON, "label", G_TYPE_STRING, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (self->token_model), 1, GTK_SORT_ASCENDING);
gtk_combo_box_set_model (self->token_box, GTK_TREE_MODEL (self->token_model));
renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set (renderer, "stock-size", GTK_ICON_SIZE_BUTTON, NULL);
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (self->token_box), renderer, FALSE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (self->token_box), renderer, "gicon", 0);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (self->token_box), renderer, TRUE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (self->token_box), renderer, "text", 1);
g_signal_connect (self->token_box, "changed", G_CALLBACK (on_token_changed), self);
if (gcr_collection_get_length (collection) > 0)
gtk_combo_box_set_active (self->token_box, 0);
g_object_unref (collection);
/* The buttons */
gtk_dialog_add_buttons (GTK_DIALOG (self),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
_("Create"), GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (self), GTK_RESPONSE_OK);
update_response (self);
g_object_unref (builder);
}
UmLoginOptions *
um_login_options_new (GtkBuilder *builder)
{
GtkWidget *widget;
GtkWidget *box;
GtkListStore *store;
GtkTreeIter iter;
GError *error;
UmLoginOptions *um;
/* TODO: get actual login screen options */
um = g_new0 (UmLoginOptions, 1);
um->manager = um_user_manager_ref_default ();
g_signal_connect (um->manager, "users-loaded",
G_CALLBACK (users_loaded), um);
widget = (GtkWidget *) gtk_builder_get_object (builder, "dm-automatic-login-combobox");
um->autologin_combo = widget;
store = gtk_list_store_new (2, G_TYPE_STRING, UM_TYPE_USER);
gtk_combo_box_set_model (GTK_COMBO_BOX (widget), GTK_TREE_MODEL (store));
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
AUTOLOGIN_NAME_COL, _("Disabled"),
AUTOLOGIN_USER_COL, NULL,
-1);
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (store), sort_login_users, NULL, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store), GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING);
g_signal_connect (widget, "changed",
G_CALLBACK (update_autologin), um);
widget = (GtkWidget *) gtk_builder_get_object (builder, "dm-show-user-list-checkbutton");
um->userlist_check = widget;
g_signal_connect (widget, "toggled",
G_CALLBACK (update_login_options), um);
g_object_set_data (G_OBJECT (widget), "gconf-key",
"/apps/gdm/simple-greeter/disable_user_list");
update_boolean_from_gconf (widget, um);
widget = (GtkWidget *) gtk_builder_get_object (builder, "dm-show-power-buttons-checkbutton");
um->power_check = widget;
g_signal_connect(widget, "toggled",
G_CALLBACK (update_login_options), um);
g_object_set_data (G_OBJECT (widget), "gconf-key",
"/apps/gdm/simple-greeter/disable_restart_buttons");
update_boolean_from_gconf (widget, um);
widget = (GtkWidget *) gtk_builder_get_object (builder, "dm-show-password-hints-checkbutton");
um->hints_check = widget;
g_signal_connect (widget, "toggled",
G_CALLBACK (update_login_options), um);
widget = (GtkWidget *) gtk_builder_get_object (builder, "dm-allow-guest-login-checkbutton");
um->guest_check = widget;
g_signal_connect (widget, "toggled",
G_CALLBACK (update_login_options), um);
widget = polkit_lock_button_new ("org.freedesktop.accounts.set-login-option");
gtk_widget_show (widget);
box = (GtkWidget *)gtk_builder_get_object (builder, "lockbutton-alignment");
gtk_container_add (GTK_CONTAINER (box), widget);
g_signal_connect (widget, "changed",
G_CALLBACK (lockbutton_changed), um);
lockbutton_changed (POLKIT_LOCK_BUTTON (widget), um);
um->lock_button = widget;
error = NULL;
um->connection = dbus_g_bus_get (DBUS_BUS_SYSTEM, &error);
if (error != NULL) {
g_warning ("Failed to get system bus connection: %s", error->message);
g_error_free (error);
}
um->proxy = dbus_g_proxy_new_for_name (um->connection,
"org.gnome.GConf.Defaults",
"/",
"org.gnome.GConf.Defaults");
if (um->proxy == NULL) {
g_warning ("Cannot connect to GConf defaults mechanism");
}
return um;
}
void
gnomegedu_ui_init_userlist ()
{
GtkTreeStore *contacts_tree_store;
GtkTreeView *contacts_tree_view;
GtkTreeIter iter;
gboolean update = FALSE;
GSList *list, *list_start;
gchar *path;
gchar *root;
gchar *display, *uuid, *group;
GtkTreeSelection *selection;
contacts_tree_view = GTK_TREE_VIEW (glade_xml_get_widget (gladexml, "ContactsTreeView"));
contacts_tree_store = GTK_TREE_STORE (gtk_tree_view_get_model (contacts_tree_view));
/* create model HERE */
if (!contacts_tree_store) {
update = FALSE;
contacts_tree_store =
gtk_tree_store_new (UI_CONTACTS_N_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT,
G_TYPE_STRING, G_TYPE_BOOLEAN);
selection = gtk_tree_view_get_selection (contacts_tree_view);
gtk_tree_selection_set_mode (GTK_TREE_SELECTION (selection), GTK_SELECTION_MULTIPLE);
gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (contacts_tree_store), gnomegadu_ui_tree_sort,
NULL, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (contacts_tree_store),
GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING);
//g_signal_connect (G_OBJECT (contacts_tree_store), "row-inserted", (GCallback) gnomegadu_ui_model_row_inserted_cb, NULL);
} else {
update = TRUE;
gtk_tree_store_clear (GTK_TREE_STORE (contacts_tree_store));
}
gtk_tree_view_set_model (contacts_tree_view, NULL);
/* groups */
GList *groups = gnomegadu_userlist_get_groups ();
GList *groups_start = groups;
while (groups) {
gchar *group = groups->data;
gnomegadu_userlist_find_or_create_group (contacts_tree_store, group);
groups = g_list_next (groups);
}
g_list_foreach (groups_start, gnomegadu_conf_free_list_of_string, NULL);
g_list_free (groups_start);
/* contacts */
list = gnomegadu_conf_get_contacts ();
list_start = list;
while (list) {
root = (gchar *) list->data;
path = g_strconcat (root, "/uuid", NULL);
uuid = gconf_client_get_string (gconf, path, NULL);
g_free (path);
path = g_strconcat (root, "/display", NULL);
display = gconf_client_get_string (gconf, path, NULL);
g_free (path);
path = g_strconcat (root, "/group", NULL);
group = gconf_client_get_string (gconf, path, NULL);
g_free (path);
if (!group || g_utf8_strlen (group, -1) <= 0) {
g_free (group);
group = g_strdup (EMPTY_GROUP);
}
if (display && uuid) {
GdkPixbuf *pix;
GtkTreeIter *iter_parent = gnomegadu_userlist_group_find_iter (contacts_tree_store, group);
gtk_tree_store_append (contacts_tree_store, &iter, iter_parent);
pix = gnomegadu_stock_get_pixbuf("gnomegadu-user-not-available");
gtk_tree_store_set (contacts_tree_store, &iter, UI_CONTACTS_COLUMN_ICON, pix, -1); //TODO g_strdup ???
gtk_tree_store_set (contacts_tree_store, &iter, UI_CONTACTS_COLUMN_DISPLAYED, display, -1); //TODO g_strdup ???
gtk_tree_store_set (contacts_tree_store, &iter, UI_CONTACTS_COLUMN_UUID, uuid, -1); //TODO g_strdup ???
gtk_tree_store_set (contacts_tree_store, &iter, UI_CONTACTS_COLUMN_STATUS, GNOMEGADU_STATUS_UNAVAIL, -1); //TODO g_strdup ???
gtk_tree_store_set (contacts_tree_store, &iter, UI_CONTACTS_COLUMN_STATUS_DESCR, NULL, -1); //TODO g_strdup ???
gtk_tree_store_set (contacts_tree_store, &iter, UI_CONTACTS_COLUMN_IS_GROUP, FALSE, -1); //TODO g_strdup ???
gdk_pixbuf_unref (pix);
if (iter_parent)
gtk_tree_iter_free (iter_parent);
}
g_free (uuid);
g_free (display);
g_free (group);
list = g_slist_next (list);
}
g_slist_foreach (list_start, gnomegadu_conf_free_list_of_string, NULL);
g_slist_free (list_start);
gtk_tree_view_set_model (contacts_tree_view, GTK_TREE_MODEL (contacts_tree_store));
gtk_tree_view_expand_all (contacts_tree_view);
g_object_unref(G_OBJECT(contacts_tree_store));
}
static void
plugin_manager_construct_tree (EomPluginManager *pm)
{
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
GtkListStore *model;
eom_debug (DEBUG_PLUGINS);
model = gtk_list_store_new (N_COLUMNS,
G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN,
G_TYPE_POINTER);
gtk_tree_view_set_model (GTK_TREE_VIEW (pm->priv->tree),
GTK_TREE_MODEL (model));
g_object_unref (model);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (pm->priv->tree), TRUE);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (pm->priv->tree), FALSE);
/* First column */
cell = gtk_cell_renderer_toggle_new ();
g_object_set (cell, "xpad", 6, NULL);
g_signal_connect (cell,
"toggled",
G_CALLBACK (active_toggled_cb),
pm);
column = gtk_tree_view_column_new_with_attributes (PLUGIN_MANAGER_ACTIVE_TITLE,
cell,
"active", ACTIVE_COLUMN,
"activatable", AVAILABLE_COLUMN,
"sensitive", AVAILABLE_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (pm->priv->tree), column);
/* Second column */
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, PLUGIN_MANAGER_NAME_TITLE);
gtk_tree_view_column_set_resizable (column, TRUE);
cell = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
g_object_set (cell, "stock-size", GTK_ICON_SIZE_SMALL_TOOLBAR, NULL);
gtk_tree_view_column_set_cell_data_func (column, cell,
plugin_manager_view_icon_cell_cb,
pm, NULL);
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, TRUE);
g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_tree_view_column_set_cell_data_func (column, cell,
plugin_manager_view_info_cell_cb,
pm, NULL);
gtk_tree_view_column_set_spacing (column, 6);
gtk_tree_view_append_column (GTK_TREE_VIEW (pm->priv->tree), column);
/* Sort on the plugin names */
gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (model),
model_name_sort_func,
NULL,
NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model),
GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
GTK_SORT_ASCENDING);
/* Enable search for our non-string column */
gtk_tree_view_set_search_column (GTK_TREE_VIEW (pm->priv->tree),
INFO_COLUMN);
gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW (pm->priv->tree),
name_search_cb,
NULL,
NULL);
g_signal_connect (pm->priv->tree,
"cursor_changed",
G_CALLBACK (cursor_changed_cb),
pm);
g_signal_connect (pm->priv->tree,
"row_activated",
G_CALLBACK (row_activated_cb),
pm);
g_signal_connect (pm->priv->tree,
"button-press-event",
G_CALLBACK (button_press_event_cb),
pm);
g_signal_connect (pm->priv->tree,
"popup-menu",
G_CALLBACK (popup_menu_cb),
pm);
gtk_widget_show (pm->priv->tree);
}
