void nsgtk_history_init_sort(void)
{
GtkWidget *domain_window = glade_xml_get_widget(gladeFile,
"windowDomain");
GtkComboBox *sort_combo_box =
GTK_COMBO_BOX(glade_xml_get_widget(
gladeFile, "comboSort"));
gtk_combo_box_set_active(sort_combo_box, 0);
g_signal_connect(G_OBJECT(sort_combo_box), "changed",
G_CALLBACK(nsgtk_history_domain_sort_changed), NULL);
g_signal_connect_swapped(G_OBJECT(sort_combo_box), "changed",
G_CALLBACK(nsgtk_history_scroll_top), domain_window);
gtk_tree_sortable_set_sort_func(
GTK_TREE_SORTABLE(history->domain_sort),
DOM_LASTVISIT, (GtkTreeIterCompareFunc)
nsgtk_history_domain_sort_compare,
GUINT_TO_POINTER(DOM_LASTVISIT), NULL);
gtk_tree_sortable_set_sort_func(
GTK_TREE_SORTABLE(history->domain_sort),
DOM_TOTALVISITS, (GtkTreeIterCompareFunc)
nsgtk_history_domain_sort_compare,
GUINT_TO_POINTER(DOM_TOTALVISITS), NULL);
gtk_tree_sortable_set_sort_func(
GTK_TREE_SORTABLE(history->site_sort),
SITE_LASTVISIT, (GtkTreeIterCompareFunc)
nsgtk_history_domain_sort_compare,
GUINT_TO_POINTER(SITE_LASTVISIT), NULL);
gtk_tree_sortable_set_sort_func(
GTK_TREE_SORTABLE(history->site_sort),
SITE_TOTALVISITS, (GtkTreeIterCompareFunc)
nsgtk_history_domain_sort_compare,
GUINT_TO_POINTER(SITE_TOTALVISITS), NULL);
}
static void
set_up (EmpathyPersonaStore *self)
{
EmpathyPersonaStorePriv *priv;
GType types[] = {
GDK_TYPE_PIXBUF, /* Status pixbuf */
GDK_TYPE_PIXBUF, /* Avatar pixbuf */
G_TYPE_BOOLEAN, /* Avatar pixbuf visible */
G_TYPE_STRING, /* Name */
G_TYPE_STRING, /* Account name */
G_TYPE_STRING, /* Display ID */
G_TYPE_UINT, /* Presence type */
G_TYPE_STRING, /* Status string */
FOLKS_TYPE_PERSONA, /* Persona */
G_TYPE_BOOLEAN, /* Is active */
G_TYPE_BOOLEAN, /* Is online */
G_TYPE_BOOLEAN, /* Can make audio calls */
G_TYPE_BOOLEAN, /* Can make video calls */
};
priv = GET_PRIV (self);
gtk_list_store_set_column_types (GTK_LIST_STORE (self),
EMPATHY_PERSONA_STORE_COL_COUNT, types);
/* Set up sorting */
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (self),
EMPATHY_PERSONA_STORE_COL_NAME, name_sort_func, self, NULL);
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (self),
EMPATHY_PERSONA_STORE_COL_STATUS, state_sort_func, self, NULL);
priv->sort_criterion = EMPATHY_PERSONA_STORE_SORT_NAME;
empathy_persona_store_set_sort_criterion (self, priv->sort_criterion);
}
static void
fr_file_selector_dialog_init (FrFileSelectorDialog *self)
{
self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, FR_TYPE_FILE_SELECTOR_DIALOG, FrFileSelectorDialogPrivate);
self->priv->current_folder = NULL;
self->priv->builder = _gtk_builder_new_from_resource ("file-selector.ui");
self->priv->icon_cache = NULL;
self->priv->settings = g_settings_new ("org.gnome.FileRoller.FileSelector");
self->priv->show_hidden = g_settings_get_boolean (self->priv->settings, PREF_FILE_SELECTOR_SHOW_HIDDEN);
gtk_container_set_border_width (GTK_CONTAINER (self), 5);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (self))), GET_WIDGET ("content"), TRUE, TRUE, 0);
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (GET_WIDGET ("files_liststore")), FILE_LIST_COLUMN_NAME, files_name_column_sort_func, self, NULL);
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (GET_WIDGET ("files_liststore")), FILE_LIST_COLUMN_SIZE, files_size_column_sort_func, self, NULL);
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (GET_WIDGET ("files_liststore")), FILE_LIST_COLUMN_MODIFIED, files_modified_column_sort_func, self, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (GET_WIDGET ("files_liststore")), FILE_LIST_COLUMN_NAME, GTK_SORT_ASCENDING);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (GET_WIDGET ("show_hidden_files_menuitem")), self->priv->show_hidden);
g_signal_connect (GET_WIDGET ("is_selected_cellrenderertoggle"),
"toggled",
G_CALLBACK (is_selected_cellrenderertoggle_toggled_cb),
self);
g_signal_connect (GET_WIDGET ("files_treeview"),
"row-activated",
G_CALLBACK (files_treeview_row_activated_cb),
self);
g_signal_connect (GET_WIDGET ("go_up_button"),
"clicked",
G_CALLBACK (go_up_button_clicked_cb),
self);
g_signal_connect (GET_WIDGET ("places_sidebar"),
"open-location",
G_CALLBACK (places_sidebar_open_location_cb),
self);
g_signal_connect (GET_WIDGET ("files_treeview"),
"button-press-event",
G_CALLBACK (files_treeview_button_press_event_cb),
self);
g_signal_connect (GET_WIDGET ("select_all_menuitem"),
"activate",
G_CALLBACK (select_all_menuitem_activate_cb),
self);
g_signal_connect (GET_WIDGET ("unselect_all_menuitem"),
"activate",
G_CALLBACK (unselect_all_menuitem_activate_cb),
self);
g_signal_connect (GET_WIDGET ("show_hidden_files_menuitem"),
"toggled",
G_CALLBACK (show_hidden_files_menuitem_toggled_cb),
self);
_fr_file_selector_dialog_update_size (self);
gtk_widget_grab_focus (GET_WIDGET ("files_treeview"));
}
static GtkTreeModel *
wrap_as_sortable_model (GtkTreeModel *model)
{
GtkTreeModel *sort_model = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (model));
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (sort_model), NAME_COLUMN, name_sort_func, model, NULL);
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (sort_model), OBJECT_COLUMN, type_sort_func, model, NULL);
return sort_model;
}
void
search_gui_show_search(struct search *search)
{
GtkTreeView *tv;
g_return_if_fail(search);
tv = GTK_TREE_VIEW(search->tree);
tree_view_restore_visibility(tv, PROP_SEARCH_RESULTS_COL_VISIBLE);
tree_view_restore_widths(tv, PROP_SEARCH_RESULTS_COL_WIDTHS);
tvm_search = tree_view_motion_set_callback(tv,
search_update_tooltip, 400);
if (!search->sort) {
int i;
/*
* The signal handler for "clicked" must only be installed once,
* not each time the treeview is made visible.
*/
search->sort = TRUE;
for (i = 0; i < c_sr_num; i++) {
GtkTreeViewColumn *column;
column = gtk_tree_view_get_column(tv, i);
gtk_tree_view_column_set_sort_column_id(column, i);
gtk_tree_sortable_set_sort_func(
GTK_TREE_SORTABLE(gtk_tree_view_get_model(tv)), i,
search_gui_cmp, uint_to_pointer(i), NULL);
column_sort_tristate_register(column,
on_tree_view_search_results_click_column, search);
}
}
}
static void
core_set_sort_mode (TrCore * core, const char * mode, gboolean is_reversed)
{
const int col = MC_TORRENT;
GtkTreeIterCompareFunc sort_func;
GtkSortType type = is_reversed ? GTK_SORT_ASCENDING : GTK_SORT_DESCENDING;
GtkTreeSortable * sortable = GTK_TREE_SORTABLE (gtr_core_model (core));
if (!strcmp (mode, "sort-by-activity"))
sort_func = compare_by_activity;
else if (!strcmp (mode, "sort-by-age"))
sort_func = compare_by_age;
else if (!strcmp (mode, "sort-by-progress"))
sort_func = compare_by_progress;
else if (!strcmp (mode, "sort-by-queue"))
sort_func = compare_by_queue;
else if (!strcmp (mode, "sort-by-time-left"))
sort_func = compare_by_eta;
else if (!strcmp (mode, "sort-by-ratio"))
sort_func = compare_by_ratio;
else if (!strcmp (mode, "sort-by-state"))
sort_func = compare_by_state;
else if (!strcmp (mode, "sort-by-size"))
sort_func = compare_by_size;
else {
sort_func = compare_by_name;
type = is_reversed ? GTK_SORT_DESCENDING : GTK_SORT_ASCENDING;
}
gtk_tree_sortable_set_sort_func (sortable, col, sort_func, NULL, NULL);
gtk_tree_sortable_set_sort_column_id (sortable, col, type);
}
/**
* 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);
}
void music_artist_setup_tree (void)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeSortable *sortable;
// TreeView holen
artist_tree = GTK_TREE_VIEW (interface_get_widget ("treeview_artists"));
// Name
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Interpret", renderer,
"text", COL_ARTIST_NAME, NULL);
gtk_tree_view_column_set_sort_column_id (column, COL_ARTIST_NAME);
gtk_tree_view_append_column (GTK_TREE_VIEW (artist_tree), column);
// Store erstellen
artist_store = gtk_list_store_new (COLS_ARTIST, G_TYPE_STRING, G_TYPE_INT);
// Sortierung
sortable = GTK_TREE_SORTABLE (artist_store);
gtk_tree_sortable_set_sort_func (sortable, COL_ARTIST_NAME, sort_artist_compare_func,
GINT_TO_POINTER(COL_ARTIST_NAME), NULL);
gtk_tree_sortable_set_sort_column_id (sortable, COL_ARTIST_NAME, GTK_SORT_ASCENDING);
// Store dem Tree anhängen
gtk_tree_view_set_model (GTK_TREE_VIEW (artist_tree),
GTK_TREE_MODEL (artist_store));
}
static void
xfburn_directory_browser_init (XfburnDirectoryBrowser * browser)
{
GtkListStore *model;
GtkTreeViewColumn *column_file;
GtkCellRenderer *cell_icon, *cell_file;
GtkTreeSelection *selection;
GtkTargetEntry gte[] = { {"text/plain;charset=utf-8", 0, DATA_COMPOSITION_DND_TARGET_TEXT_PLAIN} };
model = gtk_list_store_new (DIRECTORY_BROWSER_N_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_UINT64, G_TYPE_STRING, G_TYPE_STRING);
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (model), DIRECTORY_BROWSER_COLUMN_FILE,
directory_tree_sortfunc, NULL, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model), DIRECTORY_BROWSER_COLUMN_FILE, GTK_SORT_ASCENDING);
gtk_tree_view_set_model (GTK_TREE_VIEW (browser), GTK_TREE_MODEL (model));
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (browser), TRUE);
column_file = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column_file, _("File"));
cell_icon = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column_file, cell_icon, FALSE);
gtk_tree_view_column_set_attributes (column_file, cell_icon, "pixbuf", DIRECTORY_BROWSER_COLUMN_ICON, NULL);
g_object_set (cell_icon, "xalign", 0.0, "ypad", 0, NULL);
cell_file = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column_file, cell_file, TRUE);
gtk_tree_view_column_set_attributes (column_file, cell_file, "text", DIRECTORY_BROWSER_COLUMN_FILE, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (browser), column_file);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (browser), -1, _("Size"), gtk_cell_renderer_text_new (),
"text", DIRECTORY_BROWSER_COLUMN_HUMANSIZE, NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (browser), -1, _("Type"), gtk_cell_renderer_text_new (),
"text", DIRECTORY_BROWSER_COLUMN_TYPE, NULL);
gtk_tree_view_column_set_resizable (gtk_tree_view_get_column (GTK_TREE_VIEW (browser),
(DIRECTORY_BROWSER_COLUMN_FILE - 1)), 1);
gtk_tree_view_column_set_resizable (gtk_tree_view_get_column (GTK_TREE_VIEW (browser),
(DIRECTORY_BROWSER_COLUMN_HUMANSIZE - 1)), 1);
gtk_tree_view_column_set_fixed_width (gtk_tree_view_get_column (GTK_TREE_VIEW (browser),
(DIRECTORY_BROWSER_COLUMN_FILE - 1)), 500);
gtk_tree_view_column_set_fixed_width (gtk_tree_view_get_column (GTK_TREE_VIEW (browser),
(DIRECTORY_BROWSER_COLUMN_HUMANSIZE - 1)), 100);
gtk_tree_view_column_set_min_width (gtk_tree_view_get_column (GTK_TREE_VIEW (browser),
(DIRECTORY_BROWSER_COLUMN_FILE - 1)), 100);
gtk_tree_view_column_set_min_width (gtk_tree_view_get_column (GTK_TREE_VIEW (browser),
(DIRECTORY_BROWSER_COLUMN_HUMANSIZE - 1)), 60);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (browser));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
/* set up DnD */
gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (browser), GDK_BUTTON1_MASK, gte,
G_N_ELEMENTS (gte), GDK_ACTION_COPY);
g_signal_connect (G_OBJECT (browser), "drag-data-get", G_CALLBACK (cb_browser_drag_data_get), browser);
}
static void
setSort( TrCore * core,
const char * mode,
gboolean isReversed )
{
const int col = MC_TORRENT_RAW;
GtkTreeIterCompareFunc sort_func;
GtkSortType type =
isReversed ? GTK_SORT_ASCENDING : GTK_SORT_DESCENDING;
GtkTreeSortable * sortable =
GTK_TREE_SORTABLE( tr_core_model( core ) );
if( !strcmp( mode, "sort-by-activity" ) )
sort_func = compareByActivity;
else if( !strcmp( mode, "sort-by-age" ) )
sort_func = compareByAge;
else if( !strcmp( mode, "sort-by-progress" ) )
sort_func = compareByProgress;
else if( !strcmp( mode, "sort-by-time-left" ) )
sort_func = compareByETA;
else if( !strcmp( mode, "sort-by-ratio" ) )
sort_func = compareByRatio;
else if( !strcmp( mode, "sort-by-state" ) )
sort_func = compareByState;
else if( !strcmp( mode, "sort-by-size" ) )
sort_func = compareBySize;
else {
sort_func = compareByName;
type = isReversed ? GTK_SORT_DESCENDING : GTK_SORT_ASCENDING;
}
gtk_tree_sortable_set_sort_func( sortable, col, sort_func, NULL, NULL );
gtk_tree_sortable_set_sort_column_id( sortable, col, type );
}
/**
* 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);
}
void change_sort_order(GtkWidget * button, void *data)
{
static int current = 0;
current = (current + 1) % G_N_ELEMENTS(order);
GaimGtkConversation *gtkconv = (GaimGtkConversation *) data;
GaimGtkChatPane *gtkchat = gtkconv->u.chat;
GtkTreeModel *model =
gtk_tree_view_get_model(GTK_TREE_VIEW(gtkchat->list));
GtkBox *buttonbox = GTK_BOX(button->parent);
gtk_widget_destroy(button);
button = GTK_WIDGET(gaim_gtkconv_button_new(order[current].icon, NULL, // _("E"),
//
order[current].tooltip,
gtkconv->tooltips,
change_sort_order,
gtkconv));
gtk_box_pack_end(buttonbox, button, FALSE, FALSE, 0);
gtk_widget_show(button);
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(model),
CHAT_USERS_NAME_COLUMN,
order[current].sort_funcion, NULL,
NULL);
}
static void
font_view_model_init (FontViewModel *self)
{
GType types[NUM_COLUMNS] =
{ G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_STRING };
self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, FONT_VIEW_TYPE_MODEL, FontViewModelPrivate);
if (FT_Init_FreeType (&self->priv->library) != FT_Err_Ok)
g_critical ("Can't initialize FreeType library");
gtk_list_store_set_column_types (GTK_LIST_STORE (self),
NUM_COLUMNS, types);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (self),
COLUMN_NAME,
GTK_SORT_ASCENDING);
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (self),
COLUMN_NAME,
font_view_model_sort_func,
NULL, NULL);
g_idle_add (ensure_font_list_idle, self);
create_file_monitors (self);
}
static GtkTreeModel *
create_model(const int n, evalcontext * pec, const matchstate * pms)
{
GtkTreeStore *model;
TanBoard anBoard;
cubeinfo ci;
float arOutput[NUM_ROLLOUT_OUTPUTS];
int i, j;
memcpy(anBoard, pms->anBoard, sizeof(anBoard));
/* create tree store */
model = gtk_tree_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
GetMatchStateCubeInfo(&ci, pms);
for (i = 0, j = 1; i < n; ++i, j *= 21);
ProgressStartValue(_("Calculating equities"), j);
add_level(model, NULL, n - 1, (ConstTanBoard) anBoard, pec, &ci, TRUE, arOutput);
ProgressEnd();
if (!fInterrupt) {
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(model), 2, sort_func, NULL, NULL);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(model), 2, GTK_SORT_DESCENDING);
return GTK_TREE_MODEL(model);
} else
return NULL;
}
void results_init ()
{
GObject * object;
set_threadsafe_int(&results_max, 0);
set_threadsafe_int64(&results_memory, 0);
object = get_ui_object("tree_results");
g_signal_connect(object, "button-press-event", G_CALLBACK(results_row_button_press), NULL);
object = get_ui_object("sort_results");
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(object), COLUMN_THREAD_ID, results_compare_rows, GINT_TO_POINTER(COLUMN_THREAD_ID), NULL);
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(object), COLUMN_HOSTNAME, results_compare_rows, GINT_TO_POINTER(COLUMN_HOSTNAME), NULL);
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(object), COLUMN_BYTES_SENT, results_compare_rows, GINT_TO_POINTER(COLUMN_BYTES_SENT), NULL);
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(object), COLUMN_BYTES_RECV, results_compare_rows, GINT_TO_POINTER(COLUMN_BYTES_RECV), NULL);
results_update_status_bar();
}
/**
* Sets a GtkTreeView to the active GtkTreeView.
*/
static void
item_list_view_set_tree_store (ItemListView *ilv, GtkTreeStore *itemstore)
{
GtkTreeModel *model;
/* drop old tree store */
model = gtk_tree_view_get_model (ilv->priv->treeview);
gtk_tree_view_set_model (ilv->priv->treeview, NULL);
if (model)
g_object_unref (model);
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (itemstore), IS_TIME, item_list_view_date_sort_func, NULL, NULL);
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (itemstore), IS_SOURCE, item_list_view_favicon_sort_func, NULL, NULL);
g_signal_connect (G_OBJECT (itemstore), "sort-column-changed", G_CALLBACK (itemlist_sort_column_changed_cb), NULL);
gtk_tree_view_set_model (ilv->priv->treeview, GTK_TREE_MODEL (itemstore));
item_list_view_prefocus (ilv);
}
mtscan_model_t*
mtscan_model_new(void)
{
mtscan_model_t *model = g_malloc(sizeof(mtscan_model_t));
model->store = gtk_list_store_new(COL_COUNT,
G_TYPE_UCHAR, /* COL_STATE */
G_TYPE_INT64, /* COL_ADDRESS */
G_TYPE_INT, /* COL_FREQUENCY */
G_TYPE_STRING, /* COL_CHANNEL */
G_TYPE_STRING, /* COL_MODE */
G_TYPE_CHAR, /* COL_STREAMS */
G_TYPE_STRING, /* COL_SSID */
G_TYPE_STRING, /* COL_RADIONAME */
G_TYPE_CHAR, /* COL_MAXRSSI */
G_TYPE_CHAR, /* COL_RSSI */
G_TYPE_CHAR, /* COL_NOISE */
G_TYPE_BOOLEAN, /* COL_PRIVACY */
G_TYPE_BOOLEAN, /* COL_ROUTEROS */
G_TYPE_BOOLEAN, /* COL_NSTREME */
G_TYPE_BOOLEAN, /* COL_TDMA */
G_TYPE_BOOLEAN, /* COL_WDS */
G_TYPE_BOOLEAN, /* COL_BRIDGE */
G_TYPE_STRING, /* COL_ROS_VER */
G_TYPE_BOOLEAN, /* COL_AIRMAX */
G_TYPE_BOOLEAN, /* COL_AIRMAX_AC_PTP */
G_TYPE_BOOLEAN, /* COL_AIRMAX_AC_PTMP */
G_TYPE_BOOLEAN, /* COL_AIRMAX_AC_MIXED */
G_TYPE_INT64, /* COL_FIRSTLOG */
G_TYPE_INT64, /* COL_LASTLOG */
G_TYPE_DOUBLE, /* COL_LATITUDE */
G_TYPE_DOUBLE, /* COL_LONGITUDE */
G_TYPE_FLOAT, /* COL_AZIMUTH */
G_TYPE_FLOAT, /* COL_DISTANCE */
G_TYPE_POINTER); /* COL_SIGNALS */
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(model->store), COL_SSID, model_sort_ascii_string, GINT_TO_POINTER(COL_SSID), NULL);
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(model->store), COL_RADIONAME, model_sort_ascii_string, GINT_TO_POINTER(COL_RADIONAME), NULL);
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(model->store), COL_RSSI, model_sort_rssi, NULL, NULL);
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(model->store), COL_LATITUDE, model_sort_double, GINT_TO_POINTER(COL_LATITUDE), NULL);
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(model->store), COL_LONGITUDE, model_sort_double, GINT_TO_POINTER(COL_LONGITUDE), NULL);
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(model->store), COL_AZIMUTH, model_sort_float, GINT_TO_POINTER(COL_AZIMUTH), NULL);
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(model->store), COL_DISTANCE, model_sort_float, GINT_TO_POINTER(COL_DISTANCE), NULL);
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(model->store), COL_ROUTEROS_VER, model_sort_version, GINT_TO_POINTER(COL_ROUTEROS_VER), NULL);
model->map = g_hash_table_new_full(g_int64_hash, g_int64_equal, g_free, (GDestroyNotify)gtk_tree_iter_free);
model->active = g_hash_table_new_full(g_int64_hash, g_int64_equal, NULL, NULL);
model->active_timeout = MODEL_DEFAULT_ACTIVE_TIMEOUT;
model->new_timeout = MODEL_DEFAULT_NEW_TIMEOUT;
model->disabled_sorting = FALSE;
model->buffer = NULL;
model->clear_active_all = FALSE;
return model;
}
/* Creates an entry in the specific_folder_array, and fills it with a new
* SpecificFolderArrayEntry*. If specific_folder_array already has an entry
* with the same name, return its ID. (The ID is the index in the array.) */
guint notification_register_folder_specific_list(gchar *node_name)
{
SpecificFolderArrayEntry *entry;
gint ii = 0;
/* If array does not yet exist, create it. */
if(!specific_folder_array) {
specific_folder_array = g_array_new(FALSE, FALSE,
sizeof(SpecificFolderArrayEntry*));
specific_folder_array_size = 0;
/* Register hook for folder update */
/* "The hook is registered" is bound to "the array is allocated" */
hook_folder_update = hooks_register_hook(FOLDER_UPDATE_HOOKLIST,
my_folder_update_hook, NULL);
if(hook_folder_update == (guint) -1) {
debug_print("Warning: Failed to register hook to folder update "
"hooklist. "
"Strange things can occur when deleting folders.\n");
}
}
/* Check if we already have such a name. If so, return its id. */
while(ii < specific_folder_array_size) {
entry = g_array_index(specific_folder_array,SpecificFolderArrayEntry*,ii);
if(entry) {
if(!strcmp2(entry->name,node_name))
return ii;
}
ii++;
}
/* Create an entry with the corresponding node name. */
entry = g_new(SpecificFolderArrayEntry, 1);
entry->name = g_strdup(node_name);
entry->list = NULL;
entry->window = NULL;
entry->treeview = NULL;
entry->cancelled = FALSE;
entry->finished = FALSE;
entry->recursive = FALSE;
entry->tree_store = gtk_tree_store_new(N_FOLDERCHECK_COLUMNS,
G_TYPE_STRING,
G_TYPE_POINTER,
GDK_TYPE_PIXBUF,
GDK_TYPE_PIXBUF,
G_TYPE_BOOLEAN);
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(entry->tree_store),
FOLDERCHECK_FOLDERNAME,
foldercheck_folder_name_compare,
NULL, NULL);
specific_folder_array = g_array_append_val(specific_folder_array, entry);
return specific_folder_array_size++;
}
static GtkWidget *
banlist_treeview_new (GtkWidget *box, banlist_info *banl)
{
GtkListStore *store;
GtkWidget *view;
GtkTreeSelection *select;
GtkTreeViewColumn *col;
GtkTreeSortable *sortable;
store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING);
g_return_val_if_fail (store != NULL, NULL);
sortable = GTK_TREE_SORTABLE (store);
gtk_tree_sortable_set_sort_func (sortable, DATE_COLUMN, banlist_date_sort, GINT_TO_POINTER (DATE_COLUMN), NULL);
view = gtkutil_treeview_new (box, GTK_TREE_MODEL (store), NULL,
TYPE_COLUMN, _("Type"),
MASK_COLUMN, _("Mask"),
FROM_COLUMN, _("From"),
DATE_COLUMN, _("Date"), -1);
g_signal_connect (G_OBJECT (view), "button-press-event", G_CALLBACK (banlist_button_pressed), NULL);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), MASK_COLUMN);
gtk_tree_view_column_set_alignment (col, 0.5);
gtk_tree_view_column_set_min_width (col, 100);
gtk_tree_view_column_set_sort_column_id (col, MASK_COLUMN);
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable (col, TRUE);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), TYPE_COLUMN);
gtk_tree_view_column_set_alignment (col, 0.5);
gtk_tree_view_column_set_sort_column_id (col, TYPE_COLUMN);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), FROM_COLUMN);
gtk_tree_view_column_set_alignment (col, 0.5);
gtk_tree_view_column_set_sort_column_id (col, FROM_COLUMN);
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable (col, TRUE);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), DATE_COLUMN);
gtk_tree_view_column_set_alignment (col, 0.5);
gtk_tree_view_column_set_sort_column_id (col, DATE_COLUMN);
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable (col, TRUE);
select = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
g_signal_connect (G_OBJECT (select), "changed", G_CALLBACK (banlist_select_changed), banl);
gtk_tree_selection_set_mode (select, GTK_SELECTION_MULTIPLE);
gtk_widget_show (view);
return view;
}
static void
contact_list_store_setup (EmpathyContactListStore *store)
{
EmpathyContactListStorePriv *priv;
GType types[] = {
G_TYPE_STRING, /* Status icon-name */
GDK_TYPE_PIXBUF, /* Avatar pixbuf */
G_TYPE_BOOLEAN, /* Avatar pixbuf visible */
G_TYPE_STRING, /* Name */
G_TYPE_STRING, /* Status string */
G_TYPE_BOOLEAN, /* Show status */
EMPATHY_TYPE_CONTACT, /* Contact type */
G_TYPE_BOOLEAN, /* Is group */
G_TYPE_BOOLEAN, /* Is active */
G_TYPE_BOOLEAN, /* Is online */
G_TYPE_BOOLEAN, /* Is separator */
G_TYPE_BOOLEAN, /* Can make audio calls */
G_TYPE_BOOLEAN, /* Can make video calls */
EMPATHY_TYPE_CONTACT_LIST_FLAGS, /* Flags */
};
priv = GET_PRIV (store);
gtk_tree_store_set_column_types (GTK_TREE_STORE (store),
EMPATHY_CONTACT_LIST_STORE_COL_COUNT,
types);
/* Set up sorting */
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (store),
EMPATHY_CONTACT_LIST_STORE_COL_NAME,
contact_list_store_name_sort_func,
store, NULL);
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (store),
EMPATHY_CONTACT_LIST_STORE_COL_STATUS,
contact_list_store_state_sort_func,
store, NULL);
priv->sort_criterium = EMPATHY_CONTACT_LIST_STORE_SORT_NAME;
empathy_contact_list_store_set_sort_criterium (store, priv->sort_criterium);
}
static void
gsltma_set_sort_func(GtkTreeSortable *sortable,
gint sort_column_id,
GtkTreeIterCompareFunc func,
gpointer data,
GDestroyNotify destroy)
{
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(GNC_SX_LIST_TREE_MODEL_ADAPTER(sortable)->real),
sort_column_id,
func,
data,
destroy);
}
static void
logview_loglist_init (LogviewLoglist *list)
{
GtkTreeStore *model;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
GtkCellRenderer *cell;
list->priv = GET_PRIVATE (list);
list->priv->has_day_selection = FALSE;
list->priv->selection = NULL;
model = gtk_tree_store_new (5, LOGVIEW_TYPE_LOG, G_TYPE_STRING, G_TYPE_INT,
G_TYPE_BOOLEAN, G_TYPE_POINTER);
gtk_tree_view_set_model (GTK_TREE_VIEW (list), GTK_TREE_MODEL (model));
list->priv->model = model;
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (list), FALSE);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (list));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
g_signal_connect (selection, "changed",
G_CALLBACK (tree_selection_changed_cb), list);
cell = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new ();
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_set_attributes (column, cell,
"text", LOG_NAME,
"weight-set", LOG_WEIGHT_SET,
"weight", LOG_WEIGHT,
NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (list->priv->model), LOG_NAME, GTK_SORT_ASCENDING);
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (list->priv->model),
LOG_NAME,
(GtkTreeIterCompareFunc) loglist_sort_func,
list, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (list), column);
gtk_tree_view_set_search_column (GTK_TREE_VIEW (list), -1);
list->priv->manager = logview_manager_get ();
g_signal_connect (list->priv->manager, "log-added",
G_CALLBACK (manager_log_added_cb), list);
g_signal_connect (list->priv->manager, "log-closed",
G_CALLBACK (manager_log_closed_cb), list);
g_signal_connect_after (list->priv->manager, "active-changed",
G_CALLBACK (manager_active_changed_cb), list);
g_signal_connect (list, "row-expanded",
G_CALLBACK (row_expanded_cb), list);
}
static void
protocol_chooser_constructed (GObject *object)
{
EmpathyProtocolChooser *protocol_chooser;
EmpathyProtocolChooserPriv *priv;
GtkCellRenderer *renderer;
priv = GET_PRIV (object);
protocol_chooser = EMPATHY_PROTOCOL_CHOOSER (object);
/* set up combo box with new store */
priv->store = gtk_list_store_new (COL_COUNT,
G_TYPE_STRING, /* Icon name */
G_TYPE_STRING, /* Label */
G_TYPE_OBJECT, /* CM */
G_TYPE_STRING, /* protocol name */
G_TYPE_STRING); /* service */
/* Set the protocol sort function */
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (priv->store),
COL_PROTOCOL_NAME,
protocol_chooser_sort_func,
NULL, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (priv->store),
COL_PROTOCOL_NAME,
GTK_SORT_ASCENDING);
gtk_combo_box_set_model (GTK_COMBO_BOX (object),
GTK_TREE_MODEL (priv->store));
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (object), renderer, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (object), 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 (object), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (object), renderer,
"text", COL_LABEL,
NULL);
empathy_connection_managers_prepare_async (priv->cms,
protocol_chooser_cms_prepare_cb, protocol_chooser);
if (G_OBJECT_CLASS (empathy_protocol_chooser_parent_class)->constructed)
G_OBJECT_CLASS
(empathy_protocol_chooser_parent_class)->constructed (object);
}
static void
setup_treeview (GtkWidget *tree,
GtkWidget *preview)
{
GtkTreeStore *store;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeSelection *select;
store = gtk_tree_store_new (N_COLUMNS,
G_TYPE_STRING,
G_TYPE_STRING);
populate_model (store);
gtk_tree_view_set_model (GTK_TREE_VIEW (tree),
GTK_TREE_MODEL (store));
g_object_unref (store);
#if GTK_CHECK_VERSION(2,10,0)
g_object_set (tree, "show-expanders", FALSE, NULL);
#endif
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Name", renderer,
"text", NAME_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
gtk_tree_view_column_set_sort_column_id (column, NAME_COLUMN);
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (store),
NAME_COLUMN,
compare_theme,
NULL, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store),
NAME_COLUMN,
GTK_SORT_ASCENDING);
gtk_tree_view_set_row_separator_func (GTK_TREE_VIEW (tree),
separator_func,
GINT_TO_POINTER (ID_COLUMN),
NULL);
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 (tree_selection_changed_cb),
preview);
}
static void
gnc_sx_list_tree_model_adapter_init(GTypeInstance *instance, gpointer klass)
{
GncSxListTreeModelAdapter *adapter = GNC_SX_LIST_TREE_MODEL_ADAPTER(instance);
adapter->orig = gtk_tree_store_new(5, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
adapter->real = GTK_TREE_MODEL_SORT(gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(adapter->orig)));
// setup sorting
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(adapter->real), SXLTMA_COL_NAME, _name_comparator, adapter, NULL);
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(adapter->real), SXLTMA_COL_ENABLED, _enabled_comparator, adapter, NULL);
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(adapter->real), SXLTMA_COL_FREQUENCY, _freq_comparator, adapter, NULL);
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(adapter->real), SXLTMA_COL_LAST_OCCUR, _last_occur_comparator, adapter, NULL);
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(adapter->real), SXLTMA_COL_NEXT_OCCUR, _next_occur_comparator, adapter, NULL);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(adapter->real), SXLTMA_COL_NEXT_OCCUR, GTK_SORT_ASCENDING);
g_signal_connect(adapter->real, "row-changed", G_CALLBACK(gsltma_proxy_row_changed), adapter);
g_signal_connect(adapter->real, "row-deleted", G_CALLBACK(gsltma_proxy_row_deleted), adapter);
g_signal_connect(adapter->real, "row-has-child-toggled", G_CALLBACK(gsltma_proxy_row_has_child_toggled), adapter);
g_signal_connect(adapter->real, "row-inserted", G_CALLBACK(gsltma_proxy_row_inserted), adapter);
g_signal_connect(adapter->real, "rows-reordered", G_CALLBACK(gsltma_proxy_rows_reordered), adapter);
g_signal_connect(adapter->real, "sort-column-changed", G_CALLBACK(gsltma_proxy_sort_column_changed), adapter);
}
GtkWidget *create_room_list(GtkWidget *window)
{
GtkTreeStore *store;
GtkWidget *tree;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
assert(ROOM_COLUMNS == 3);
store = gtk_tree_store_new(ROOM_COLUMNS,
G_TYPE_POINTER,
G_TYPE_STRING,
G_TYPE_INT);
tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
g_object_unref(store);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store),
ROOM_COLUMN_NAME,
GTK_SORT_ASCENDING);
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(store),
ROOM_COLUMN_NAME,
room_sort_func,
NULL, NULL);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("#", renderer,
"text", ROOM_COLUMN_PLAYERS, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Room"),
renderer,
"text", ROOM_COLUMN_NAME, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
g_object_set_data(G_OBJECT(tree), "room_list_store", store);
g_object_set_data(G_OBJECT(window), "room_list_store", store);
gtk_widget_set_sensitive(tree, FALSE);
GTK_WIDGET_UNSET_FLAGS(tree, GTK_CAN_FOCUS);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
g_signal_connect(tree, "button-press-event",
G_CALLBACK(room_list_event), NULL);
room_list = tree;
return tree;
}
static void
gtk_app_chooser_widget_init (GtkAppChooserWidget *self)
{
GtkTreeSelection *selection;
GtkTreeModel *sort;
GtkGesture *gesture;
self->priv = gtk_app_chooser_widget_get_instance_private (self);
gtk_widget_set_has_surface (GTK_WIDGET (self), FALSE);
gtk_widget_init_template (GTK_WIDGET (self));
/* Various parts of the GtkTreeView code need custom code to setup, mostly
* because we lack signals to connect to, or properties to set.
*/
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (self->priv->program_list));
gtk_tree_selection_set_select_function (selection, gtk_app_chooser_selection_func,
self, NULL);
sort = gtk_tree_view_get_model (GTK_TREE_VIEW (self->priv->program_list));
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort),
COLUMN_NAME,
GTK_SORT_ASCENDING);
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (sort),
COLUMN_NAME,
gtk_app_chooser_sort_func,
self, NULL);
gtk_tree_view_set_search_column (GTK_TREE_VIEW (self->priv->program_list), COLUMN_NAME);
gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW (self->priv->program_list),
gtk_app_chooser_search_equal_func,
NULL, NULL);
gtk_tree_view_column_set_cell_data_func (self->priv->column,
self->priv->secondary_padding,
padding_cell_renderer_func,
NULL, NULL);
self->priv->monitor = g_app_info_monitor_get ();
g_signal_connect (self->priv->monitor, "changed",
G_CALLBACK (app_info_changed), self);
gesture = gtk_gesture_multi_press_new ();
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture), GDK_BUTTON_SECONDARY);
g_signal_connect (gesture, "pressed",
G_CALLBACK (gtk_app_chooser_row_pressed_cb), self);
gtk_widget_add_controller (self->priv->program_list, GTK_EVENT_CONTROLLER (gesture));
}
void Interface_resultados() {
int i;
GtkBuilder *buildResult=Interface_carregarXML("resultados.glade");
GtkWidget *window = GTK_WIDGET(gtk_builder_get_object (buildResult, "window"));
comboResultados = GTK_COMBO_BOX(gtk_builder_get_object (buildResult, "combobox"));
GtkListStore *listaCombo = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);
GtkTreeView *treeview = GTK_TREE_VIEW(gtk_builder_get_object (buildResult, "treeview"));
GtkTreeSortable *treeOrdenar = GTK_TREE_SORTABLE(gtk_builder_get_object(buildResult, "liststore"));
gtk_tree_sortable_set_sort_func(treeOrdenar, 0, sort_iter_compare_func, GINT_TO_POINTER(0), NULL);
gtk_tree_sortable_set_sort_func(treeOrdenar, 1, sort_iter_compare_func, GINT_TO_POINTER(1), NULL);
gtk_tree_sortable_set_sort_func(treeOrdenar, 2, sort_iter_compare_func, GINT_TO_POINTER(2), NULL);
gtk_tree_sortable_set_sort_func(treeOrdenar, 3, sort_iter_compare_func, GINT_TO_POINTER(3), NULL);
gtk_tree_sortable_set_sort_func(treeOrdenar, 4, sort_iter_compare_func, GINT_TO_POINTER(4), NULL);
addItemCombo(listaCombo, "Selecione", -1);
//Monta combo
for (i=0; listaResult[i].tabela[0] ;i++) {
if (Projeto_verificarExisteTabela(listaResult[i].tabela))
addItemCombo(listaCombo, listaResult[i].nome, i);
}
gtk_combo_box_set_model(comboResultados, GTK_TREE_MODEL(listaCombo));
GtkCellRenderer *cell_renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT(comboResultados), cell_renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT(comboResultados), cell_renderer, "text", 0, NULL);
gtk_combo_box_set_active(comboResultados,0);
g_signal_connect (comboResultados, "changed", G_CALLBACK (on_combobox_changed), treeview);
gtk_builder_connect_signals(buildResult, NULL);
gtk_widget_show(window);
g_object_unref(G_OBJECT(buildResult));
}
static GtkListStore* apply_window_create_data_store(void)
{
GtkListStore *store = gtk_list_store_new(N_TAG_EDIT_COLUMNS,
G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN,
G_TYPE_STRING,
G_TYPE_POINTER,
-1);
GtkTreeSortable *sortable = GTK_TREE_SORTABLE(store);
gtk_tree_sortable_set_sort_func(sortable, 0, tag_cmp_func,
NULL, NULL);
return store;
}
static GtkWidget*
gwy_module_browser_construct(GtkWidget *parent)
{
static const gchar *columns[] = {
N_("Module"), N_("Version"), N_("Author"),
};
GtkWidget *tree;
GtkListStore *store;
GtkTreeSelection *selection;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
gsize i;
store = gtk_list_store_new(MODEL_LAST,
G_TYPE_POINTER,
G_TYPE_POINTER,
G_TYPE_BOOLEAN);
gwy_module_foreach((GHFunc)gwy_module_browser_store_module, store);
_gwy_module_failure_foreach((GHFunc)gwy_module_browser_store_failure,
store);
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(store),
MODEL_NAME, compare_modules, NULL, NULL);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), MODEL_NAME,
GTK_SORT_ASCENDING);
tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree), TRUE);
g_object_unref(store);
for (i = 0; i < G_N_ELEMENTS(columns); i++) {
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_(columns[i]),
renderer, NULL);
gtk_tree_view_column_set_cell_data_func(column, renderer,
gwy_module_browser_render,
GUINT_TO_POINTER(i), NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
}
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
g_signal_connect(tree, "cursor-changed",
G_CALLBACK(update_module_info_cb), parent);
return tree;
}
