/*
* Set an GtkTreeModel visible filter on this price. This filter will be
* called for each price that the tree is about to show, and the
* price will be passed to the callback function.
*/
void
gnc_tree_view_price_set_filter (GncTreeViewPrice *view,
gnc_tree_view_price_ns_filter_func ns_func,
gnc_tree_view_price_cm_filter_func cm_func,
gnc_tree_view_price_pc_filter_func pc_func,
gpointer data,
GDestroyNotify destroy)
{
GtkTreeModel *f_model, *s_model;
filter_user_data *fd = data;
ENTER("view %p, ns func %p, cm func %p, pc func %p, data %p, destroy %p",
view, ns_func, cm_func, pc_func, data, destroy);
g_return_if_fail(GNC_IS_TREE_VIEW_PRICE(view));
g_return_if_fail((ns_func != NULL) || (cm_func != NULL));
fd = g_malloc(sizeof(filter_user_data));
fd->user_ns_fn = ns_func;
fd->user_cm_fn = cm_func;
fd->user_pc_fn = pc_func;
fd->user_data = data;
fd->user_destroy = destroy;
s_model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
f_model = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(s_model));
gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (f_model),
gnc_tree_view_price_filter_helper,
fd,
gnc_tree_view_price_filter_destroy);
/* Whack any existing levels. The top two levels have been created
* before this routine can be called. Unfortunately, if the just
* applied filter filters out all the nodes in the tree, the gtk
* code throws a critical error. This occurs when there are no
* prices in the price database. Once the very first price has been
* added this error message goes away. */
gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (f_model));
LEAVE(" ");
}
static void
selection_changed_cb (GtkButton * button, gpointer vdata)
{
int i;
struct filter_data * data = vdata;
// If the button isn't active, we are not interested in it.
if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button))) return;
for (i = 0; i < MAX_FILTERS_ON_TOOLBAR; i++) {
if (GTK_WIDGET (button) == data->filters[i].widget) {
data->active_activity_type = data->filters[i].type;
switch (data->active_activity_type) {
case ACTIVITY_FILTER_ALL:
gtk_header_bar_set_subtitle(GTK_HEADER_BAR (data->header_bar), _("All"));
break;
case ACTIVITY_FILTER_DOWNLOADING:
gtk_header_bar_set_subtitle(GTK_HEADER_BAR (data->header_bar), _("Downloading"));
break;
case ACTIVITY_FILTER_SEEDING:
gtk_header_bar_set_subtitle(GTK_HEADER_BAR (data->header_bar), _("Seeding"));
break;
case ACTIVITY_FILTER_ACTIVE:
gtk_header_bar_set_subtitle(GTK_HEADER_BAR (data->header_bar), _("Active"));
break;
default:
break;
}
}
}
/* refilter */
gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (data->filter_model));
}
static void
tasks_category_add_cb (GtkWidget *widget, GUI *appGUI)
{
GtkTreeIter iter;
const gchar *category_name;
gchar *item;
gint i;
category_name = gtk_entry_get_text (GTK_ENTRY (appGUI->opt->tasks_category_entry));
if (!strlen (category_name)) return;
i = 0;
while (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (appGUI->opt->tasks_category_store), &iter, NULL, i++)) {
gtk_tree_model_get (GTK_TREE_MODEL (appGUI->opt->tasks_category_store), &iter, TC_COLUMN_NAME, &item, -1);
if (!strcmp (category_name, item)) {
g_free (item);
return;
}
g_free (item);
}
gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (appGUI->opt->tasks_category_store), &iter, NULL, 0);
gtk_list_store_append (appGUI->opt->tasks_category_store, &iter);
gtk_list_store_set (appGUI->opt->tasks_category_store, &iter,
TC_COLUMN_NAME, category_name,
TC_COLUMN_CALENDAR, TRUE,
TC_COLUMN_TASKS, TRUE, -1);
gtk_entry_set_text (GTK_ENTRY (appGUI->opt->tasks_category_entry), "");
gtk_widget_set_sensitive (appGUI->opt->tasks_category_add_button, FALSE);
utl_gui_create_category_combobox (GTK_COMBO_BOX (appGUI->tsk->cf_combobox), appGUI->opt->tasks_category_store, FALSE);
gtk_combo_box_set_active (GTK_COMBO_BOX (appGUI->tsk->cf_combobox), 0);
apply_task_attributes (appGUI);
gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (appGUI->tsk->tasks_filter));
update_tasks_number (appGUI);
}
static void
update_connection_row (NMConnectionList *self,
GtkTreeIter *iter,
NMRemoteConnection *connection)
{
NMSettingConnection *s_con;
char *last_used, *id;
s_con = nm_connection_get_setting_connection (NM_CONNECTION (connection));
g_assert (s_con);
last_used = format_last_used (nm_setting_connection_get_timestamp (s_con));
id = g_markup_escape_text (nm_setting_connection_get_id (s_con), -1);
gtk_tree_store_set (GTK_TREE_STORE (self->model), iter,
COL_ID, id,
COL_LAST_USED, last_used,
COL_TIMESTAMP, nm_setting_connection_get_timestamp (s_con),
COL_CONNECTION, connection,
-1);
g_free (last_used);
g_free (id);
gtk_tree_model_filter_refilter (self->filter);
}
static void
panel_addto_search_entry_changed (GtkWidget *entry,
PanelAddtoDialog *dialog)
{
GtkTreeModel *model;
char *new_text;
GtkTreeIter iter;
GtkTreePath *path;
new_text = g_strdup (gtk_entry_get_text (GTK_ENTRY (dialog->search_entry)));
g_strchomp (new_text);
if (dialog->search_text &&
g_utf8_collate (new_text, dialog->search_text) == 0) {
g_free (new_text);
return;
}
if (dialog->search_text)
g_free (dialog->search_text);
dialog->search_text = new_text;
model = gtk_tree_view_get_model (GTK_TREE_VIEW (dialog->tree_view));
gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (model));
path = gtk_tree_path_new_first ();
if (gtk_tree_model_get_iter (model, &iter, path)) {
GtkTreeSelection *selection;
gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (dialog->tree_view),
path, NULL, FALSE, 0, 0);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->tree_view));
gtk_tree_selection_select_path (selection, path);
}
gtk_tree_path_free (path);
}
static void
bluetooth_filter_widget_set_property (GObject *object, guint prop_id,
const GValue *value, GParamSpec *pspec)
{
BluetoothFilterWidgetPrivate *priv = BLUETOOTH_FILTER_WIDGET_GET_PRIVATE(object);
switch (prop_id) {
case PROP_SHOW_DEVICE_TYPE:
priv->show_device_type = g_value_get_boolean (value);
g_object_set (G_OBJECT (priv->device_type_label), "visible", priv->show_device_type, NULL);
g_object_set (G_OBJECT (priv->device_type), "visible", priv->show_device_type, NULL);
break;
case PROP_SHOW_DEVICE_CATEGORY:
priv->show_device_category = g_value_get_boolean (value);
g_object_set (G_OBJECT (priv->device_category_label), "visible", priv->show_device_category, NULL);
g_object_set (G_OBJECT (priv->device_category), "visible", priv->show_device_category, NULL);
break;
case PROP_DEVICE_TYPE_FILTER:
priv->device_type_filter = g_value_get_int (value);
set_combobox_from_filter (BLUETOOTH_FILTER_WIDGET (object));
break;
case PROP_DEVICE_CATEGORY_FILTER:
priv->device_category_filter = g_value_get_enum (value);
gtk_combo_box_set_active (GTK_COMBO_BOX(priv->device_category), priv->device_category_filter);
break;
case PROP_DEVICE_SERVICE_FILTER:
g_free (priv->device_service_filter);
priv->device_service_filter = g_value_dup_string (value);
if (priv->filter)
gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (priv->filter));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
}
}
gint
birthdays_list_dbclick_cb (GtkWidget * widget, GdkEventButton * event, gpointer user_data)
{
GtkTreeIter iter;
GtkTreeModel *model, *contacts_model;
GtkTreePath *sort_path, *filter_path, *path;
gint id, id_c;
GUI *appGUI = (GUI *) user_data;
contacts_model = GTK_TREE_MODEL (appGUI->cnt->contacts_list_store);
if (((event->type == GDK_2BUTTON_PRESS) && (event->button == 1)) == FALSE)
return FALSE;
if (gtk_tree_selection_get_selected (appGUI->cnt->birthdays_list_selection, &model, &iter)) {
if (strlen (gtk_entry_get_text (GTK_ENTRY (appGUI->cnt->contacts_find_entry)))) {
gtk_entry_set_text (GTK_ENTRY (appGUI->cnt->contacts_find_entry), "");
gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (appGUI->cnt->contacts_filter));
}
gtk_tree_model_get (model, &iter, B_COLUMN_ID, &id, -1);
gtk_widget_destroy (appGUI->cnt->birthdays_window);
contacts_selection_activate (FALSE, appGUI);
if (gtk_tree_model_get_iter_first (contacts_model, &iter) == TRUE) {
sort_path = gtk_tree_model_get_path (contacts_model, &iter);
while (sort_path != NULL) {
gtk_tree_view_set_cursor (GTK_TREE_VIEW (appGUI->cnt->contacts_list), sort_path, NULL, FALSE);
filter_path = gtk_tree_model_sort_convert_path_to_child_path (GTK_TREE_MODEL_SORT (appGUI->cnt->contacts_sort), sort_path);
if (filter_path != NULL) {
path = gtk_tree_model_filter_convert_path_to_child_path (GTK_TREE_MODEL_FILTER (appGUI->cnt->contacts_filter), filter_path);
if (path != NULL) {
gtk_tree_model_get_iter (contacts_model, &iter, path);
gtk_tree_model_get (contacts_model, &iter, COLUMN_ID, &id_c, -1);
if (id == id_c) {
contacts_selection_activate (TRUE, appGUI);
gtk_tree_view_set_cursor (GTK_TREE_VIEW (appGUI->cnt->contacts_list), sort_path, NULL, FALSE);
show_contacts_desc_panel (TRUE, appGUI);
gtk_tree_path_free (path);
gtk_tree_path_free (filter_path);
g_signal_emit_by_name (G_OBJECT (appGUI->cnt->contacts_list_selection), "changed");
break;
}
gtk_tree_path_free (path);
}
gtk_tree_path_free (filter_path);
}
gtk_tree_path_next (sort_path);
if (gtk_tree_model_get_iter (contacts_model, &iter, sort_path) == FALSE) break;
}
gtk_tree_path_free (sort_path);
}
}
return TRUE;
}
gint
key_press_cb (GtkWidget *widget, GdkEventKey *event, gpointer data) {
gint page;
page = gtk_notebook_get_current_page (GTK_NOTEBOOK(notebook));
/************************************************************************/
/*** CALENDAR PAGE ***/
/************************************************************************/
if(page == PAGE_CALENDAR) {
if (!config.day_notes_visible) {
switch (event->keyval) {
case GDK_Left:
calendar_btn_prev_day();
return TRUE;
case GDK_Right:
calendar_btn_next_day();
return TRUE;
case GDK_Up:
calendar_btn_prev_week();
return TRUE;
case GDK_Down:
calendar_btn_next_week();
return TRUE;
case GDK_Home:
calendar_btn_prev_year();
return TRUE;
case GDK_End:
calendar_btn_next_year();
return TRUE;
case GDK_Return:
if (calendar_only == FALSE) {
gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(notes_button),
!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(notes_button)));
}
return TRUE;
case GDK_space:
set_today (TRUE);
return TRUE;
case GDK_Delete:
if (calendar_only == FALSE) {
calendar_clear_text_cb (NULL, NULL);
}
return TRUE;
case GDK_g:
calendar_create_jumpto_window ();
return TRUE;
case GDK_f:
calendar_create_fullyear_window ();
return TRUE;
}
}
switch (event->keyval) {
case GDK_Escape:
if (calendar_only == FALSE) {
gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(notes_button), FALSE);
}
return TRUE;
case GDK_Left:
if (event->state & GDK_MOD1_MASK) { /* ALT + Left */
calendar_btn_prev_day();
return TRUE;
}
return FALSE;
case GDK_Right:
if (event->state & GDK_MOD1_MASK) { /* ALT + Right */
calendar_btn_next_day();
return TRUE;
}
return FALSE;
case GDK_Up:
if (event->state & GDK_MOD1_MASK) { /* ALT + Up */
calendar_btn_prev_week();
return TRUE;
}
return FALSE;
case GDK_Down:
if (event->state & GDK_MOD1_MASK) { /* ALT + Down */
calendar_btn_next_week();
return TRUE;
}
return FALSE;
}
}
/************************************************************************/
/*** TASKS PAGE ***/
/************************************************************************/
if(page == PAGE_TASKS) {
switch (event->keyval) {
case GDK_Escape:
if(tasks_panel_status == TRUE) {
show_tasks_desc_panel(FALSE);
}
return TRUE;
case GDK_Return:
if (event->state & GDK_CONTROL_MASK) { /* CTRL + Enter */
if (gtk_tree_selection_get_selected (tasks_list_selection, NULL, NULL)) {
tasks_add_edit_dialog_show (TRUE);
return TRUE;
}
}
if(tasks_panel_status == FALSE) {
show_tasks_desc_panel(TRUE);
}
return TRUE;
case GDK_h:
if (event->state & GDK_CONTROL_MASK) { /* CTRL + h */
config.hide_completed = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(ct_hide_items_checkbutton));
config.hide_completed = !config.hide_completed;
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(ct_hide_items_checkbutton), config.hide_completed);
gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(tasks_filter));
}
return TRUE;
case GDK_Delete:
tasks_remove_dialog_show(tasks_list, tasks_list_store);
return TRUE;
case GDK_Insert:
tasks_add_edit_dialog_show (FALSE);
return TRUE;
case GDK_space:
return TRUE;
case GDK_Left:
if (filter_index > 0) {
filter_index--;
gtk_combo_box_set_active(GTK_COMBO_BOX(cf_combobox), filter_index);
}
return TRUE;
case GDK_Right:
if (filter_index < get_combobox_items(GTK_COMBO_BOX(cf_combobox))-1) {
filter_index++;
gtk_combo_box_set_active(GTK_COMBO_BOX(cf_combobox), filter_index);
}
return TRUE;
}
}
/************************************************************************/
/*** CONTACTS PAGE ***/
/************************************************************************/
if(page == PAGE_CONTACTS) {
switch (event->keyval) {
case GDK_Escape:
if (gtk_widget_is_focus(contacts_find_entry) == FALSE) {
if(contacts_panel_status == TRUE) {
show_contacts_desc_panel(FALSE);
}
} else {
if (strlen(gtk_entry_get_text(GTK_ENTRY(contacts_find_entry)))) {
gtk_entry_set_text(GTK_ENTRY(contacts_find_entry), "");
}
}
return TRUE;
case GDK_Return:
if (event->state & GDK_CONTROL_MASK) { /* CTRL + Enter */
if (gtk_tree_selection_get_selected (contacts_list_selection, NULL, NULL)) {
contacts_add_edit_dialog_show (TRUE);
return TRUE;
}
}
if(contacts_panel_status == FALSE) {
show_contacts_desc_panel(TRUE);
return TRUE;
} else if (gtk_widget_is_focus(contacts_find_entry) == FALSE) {
gui_scrolled_window_move_position(contacts_panel_scrolledwindow, SW_MOVE_DOWN);
return TRUE;
}
return FALSE;
case GDK_BackSpace:
if(contacts_panel_status == TRUE && gtk_widget_is_focus(contacts_find_entry) == FALSE) {
gui_scrolled_window_move_position(contacts_panel_scrolledwindow, SW_MOVE_UP);
return TRUE;
}
return FALSE;
case GDK_Delete:
if(gtk_widget_is_focus(contacts_find_entry) == FALSE) {
contacts_remove_dialog_show(contacts_list, contacts_list_store);
return TRUE;
}
return FALSE;
case GDK_Insert:
if(gtk_widget_is_focus(contacts_find_entry) == FALSE) {
contacts_add_edit_dialog_show (FALSE);
return TRUE;
}
return FALSE;
case GDK_1:
if (event->state & GDK_MOD1_MASK) { /* ALT + 1 */
gtk_combo_box_set_active(GTK_COMBO_BOX(contacts_find_combobox), CONTACTS_FF_FIRST_NAME);
return TRUE;
}
return FALSE;
case GDK_2:
if (event->state & GDK_MOD1_MASK) { /* ALT + 2 */
gtk_combo_box_set_active(GTK_COMBO_BOX(contacts_find_combobox), CONTACTS_FF_LAST_NAME);
return TRUE;
}
return FALSE;
case GDK_3:
if (event->state & GDK_MOD1_MASK) { /* ALT + 3 */
gtk_combo_box_set_active(GTK_COMBO_BOX(contacts_find_combobox), CONTACTS_FF_ALL_FIELDS);
return TRUE;
}
return FALSE;
case GDK_l:
if (event->state & GDK_CONTROL_MASK) { /* CTRL + l */
gtk_widget_grab_focus(GTK_WIDGET(contacts_find_entry));
return TRUE;
}
return FALSE;
}
}
/************************************************************************/
/*** OPTIONS PAGE ***/
/************************************************************************/
if(page == PAGE_OPTIONS) {
if (!(event->state & GDK_CONTROL_MASK)) { /* CTRL + Page_Up */
switch (event->keyval) {
case GDK_Page_Down:
options_switch_buttons(FALSE);
return TRUE;
case GDK_Page_Up:
options_switch_buttons(TRUE);
return TRUE;
}
}
}
/************************************************************************/
/*** ABOUT PAGE ***/
/************************************************************************/
if(page == PAGE_ABOUT) {
if (!(event->state & GDK_CONTROL_MASK)) { /* CTRL + Page_Up */
switch (event->keyval) {
case GDK_Page_Down:
about_switch_buttons(FALSE);
return TRUE;
case GDK_Page_Up:
about_switch_buttons(TRUE);
return TRUE;
}
}
}
/************************************************************************/
/*** GLOBAL SHORTCUTS ***/
/************************************************************************/
switch (event->keyval) {
case GDK_q:
if (event->state & GDK_CONTROL_MASK) { /* CTRL + Q */
gui_window_close_cb(NULL, NULL);
}
return FALSE;
case GDK_Page_Up:
if (event->state & GDK_CONTROL_MASK) { /* CTRL + Page_Up */
current_tab--;
current_tab = current_tab < 0 ? number_of_tabs-1:current_tab;
gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), current_tab);
return TRUE;
} else if (page == PAGE_CALENDAR) {
if (config.day_notes_visible) {
if (event->state & GDK_MOD1_MASK) { /* ALT + Page_Up */
calendar_btn_prev_month();
return TRUE;
}
} else {
calendar_btn_prev_month();
return TRUE;
}
}
return FALSE;
case GDK_Page_Down:
if (event->state & GDK_CONTROL_MASK) { /* CTRL + Page_Down */
current_tab++;
current_tab = current_tab == number_of_tabs ? 0:current_tab;
gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), current_tab);
return TRUE;
} else if (page == PAGE_CALENDAR) {
if (config.day_notes_visible) {
if (event->state & GDK_MOD1_MASK) { /* ALT + Page_Down */
calendar_btn_next_month();
return TRUE;
}
} else {
calendar_btn_next_month();
return TRUE;
}
}
return FALSE;
case GDK_F1:
gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), PAGE_CALENDAR);
return TRUE;
case GDK_F2:
gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), PAGE_TASKS);
return TRUE;
case GDK_F3:
gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), PAGE_CONTACTS);
return TRUE;
case GDK_F4:
gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), PAGE_OPTIONS);
return TRUE;
case GDK_F5:
gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), PAGE_ABOUT);
return TRUE;
}
return FALSE;
}
static void remmina_main_quick_search_on_changed(GtkEditable *editable, RemminaMain *remminamain)
{
gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(remminamain->priv->file_model_filter));
gtk_tree_view_expand_all(GTK_TREE_VIEW(remminamain->priv->file_list));
}
static VALUE
rg_refilter(VALUE self)
{
gtk_tree_model_filter_refilter(_SELF(self));
return self;
}
static void
on_presentity_added (RosterViewGtk* self,
G_GNUC_UNUSED Ekiga::ClusterPtr cluster,
Ekiga::HeapPtr heap,
Ekiga::PresentityPtr presentity)
{
GtkTreeIter heap_iter;
std::set<std::string> groups = presentity->get_groups ();
GtkTreeSelection* selection = gtk_tree_view_get_selection (self->priv->tree_view);
GtkTreeModelFilter* filtered_model = GTK_TREE_MODEL_FILTER (gtk_tree_view_get_model (self->priv->tree_view));
GtkTreeIter group_iter;
GtkTreeIter iter;
GtkTreeIter filtered_iter;
bool active = false;
bool away = false;
guint timeout = 0;
std::string status;
gchar *old_presence = NULL;
gboolean should_emit = FALSE;
roster_view_gtk_find_iter_for_heap (self, heap, &heap_iter);
active = presentity->get_presence () != "offline";
away = presentity->get_presence () == "away";
if (groups.empty ())
groups.insert (_("Unsorted"));
for (std::set<std::string>::const_iterator group = groups.begin ();
group != groups.end ();
group++) {
roster_view_gtk_find_iter_for_group (self, heap, &heap_iter,
*group, &group_iter);
roster_view_gtk_find_iter_for_presentity (self, &group_iter, presentity, &iter);
if (gtk_tree_model_filter_convert_child_iter_to_iter (filtered_model, &filtered_iter, &iter))
if (gtk_tree_selection_iter_is_selected (selection, &filtered_iter))
should_emit = TRUE;
// Find out what our presence was
gtk_tree_model_get (GTK_TREE_MODEL (self->priv->store), &iter,
COLUMN_PRESENCE, &old_presence, -1);
if (old_presence && presentity->get_presence () != old_presence
&& presentity->get_presence () != "unknown" && presentity->get_presence () != "offline"
&& (!g_strcmp0 (old_presence, "unknown") || !g_strcmp0 (old_presence, "offline"))) {
StatusIconInfo *info = new StatusIconInfo ();
info->model = GTK_TREE_MODEL (self->priv->store);
info->iter = gtk_tree_iter_copy (&iter);
info->cpt = 0;
timeout = g_timeout_add_seconds_full (G_PRIORITY_DEFAULT, 1, roster_view_gtk_icon_blink_cb,
(gpointer) info, (GDestroyNotify) status_icon_info_delete);
gtk_tree_store_set (self->priv->store, &iter,
COLUMN_TIMEOUT, timeout, -1);
}
else {
std::string icon = "avatar-default";
if (!old_presence) {
gtk_tree_store_set (self->priv->store, &iter,
COLUMN_PRESENCE_ICON, icon.c_str (),
-1);
}
else if (old_presence != presentity->get_presence ()) {
if (presentity->get_presence () != "unknown")
icon = "user-" + presentity->get_presence ();
gtk_tree_store_set (self->priv->store, &iter,
COLUMN_PRESENCE_ICON, icon.c_str (),
-1);
}
}
status = presentity->get_status ();
if (status.empty ()) {
if (presentity->get_presence () == "away")
status = _("Away");
else if (presentity->get_presence () == "available")
status = _("Available");
else if (presentity->get_presence () == "offline")
status = _("Offline");
else if (presentity->get_presence () == "busy")
status = _("Busy");
}
gtk_tree_store_set (self->priv->store, &iter,
COLUMN_TYPE, TYPE_PRESENTITY,
COLUMN_OFFLINE, active,
COLUMN_HEAP, heap.get (),
COLUMN_PRESENTITY, presentity.get (),
COLUMN_NAME, presentity->get_name ().c_str (),
COLUMN_STATUS, status.c_str (),
COLUMN_PRESENCE, presentity->get_presence ().c_str (),
COLUMN_ACTIVE, (!active || away) ? "gray" : "black", -1);
gtk_tree_model_get (GTK_TREE_MODEL (self->priv->store), &iter,
COLUMN_TIMEOUT, &timeout,
-1);
g_free (old_presence);
}
GtkTreeModel* model = gtk_tree_view_get_model (self->priv->tree_view);
gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (model));
roster_view_gtk_update_groups (self, &heap_iter);
if (should_emit)
g_signal_emit (self, signals[SELECTION_CHANGED_SIGNAL], 0);
}
/**
* @brief Callback for 'changed' event of search entry used to reinit file filter
* @return false
*/
gboolean PrefabSelector::callbackRefilter (PrefabSelector *self)
{
gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(self->_fileFiltered));
return false;
}
static void
bluetooth_chooser_set_property (GObject *object, guint prop_id,
const GValue *value, GParamSpec *pspec)
{
BluetoothChooser *self = BLUETOOTH_CHOOSER (object);
BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE (self);
switch (prop_id) {
case PROP_DEVICE_SELECTED: {
const char *address;
char *selected;
GtkTreeIter iter;
gboolean cont;
address = g_value_get_string (value);
if (address == NULL) {
gtk_tree_selection_unselect_all (priv->selection);
return;
}
selected = bluetooth_chooser_get_selected_device (self);
if (g_strcmp0 (selected, address) == 0) {
g_free (selected);
return;
}
g_free (selected);
cont = gtk_tree_model_get_iter_first (priv->filter, &iter);
while (cont == TRUE) {
char *iaddress;
gtk_tree_model_get (priv->filter, &iter,
BLUETOOTH_COLUMN_ADDRESS, &iaddress, -1);
if (g_strcmp0 (iaddress, address) == 0) {
gtk_tree_selection_select_iter (priv->selection, &iter);
g_free (iaddress);
return;
}
g_free (iaddress);
cont = gtk_tree_model_iter_next (priv->filter, &iter);
}
break;
}
case PROP_SHOW_PAIRING:
priv->show_paired = g_value_get_boolean (value);
if (priv->bonded_cell != NULL)
g_object_set (G_OBJECT (priv->bonded_cell), "visible", priv->show_paired, NULL);
break;
case PROP_SHOW_CONNECTED:
priv->show_connected = g_value_get_boolean (value);
if (priv->connected_cell != NULL)
g_object_set (G_OBJECT (priv->connected_cell), "visible", priv->show_connected, NULL);
break;
case PROP_SHOW_SEARCHING:
priv->show_searching = g_value_get_boolean (value);
g_object_set (G_OBJECT (priv->search_hbox), "visible", priv->show_searching, NULL);
break;
case PROP_SHOW_DEVICE_TYPE:
priv->show_device_type = g_value_get_boolean (value);
if (priv->internal_filter) {
if (priv->show_device_type || priv->show_device_category)
g_object_set (G_OBJECT (priv->filters_vbox), "visible", TRUE, NULL);
else
g_object_set (G_OBJECT (priv->filters_vbox), "visible", FALSE, NULL);
}
break;
case PROP_SHOW_DEVICE_TYPE_COLUMN: {
GtkTreeViewColumn *column;
column = gtk_tree_view_get_column (GTK_TREE_VIEW (priv->treeview), TREEVIEW_COLUMN_TYPE);
gtk_tree_view_column_set_visible (column,
g_value_get_boolean (value));
column = gtk_tree_view_get_column (GTK_TREE_VIEW (priv->treeview), TREEVIEW_COLUMN_DEVICE);
if (g_value_get_boolean (value))
gtk_tree_view_column_set_title (column, _("Device"));
else
gtk_tree_view_column_set_title (column, _("Devices"));
break;
}
case PROP_SHOW_DEVICE_CATEGORY:
priv->show_device_category = g_value_get_boolean (value);
if (priv->internal_filter) {
if (priv->show_device_type || priv->show_device_category)
g_object_set (G_OBJECT (priv->filters_vbox), "visible", TRUE, NULL);
else
g_object_set (G_OBJECT (priv->filters_vbox), "visible", FALSE, NULL);
}
break;
case PROP_DEVICE_TYPE_FILTER:
priv->device_type_filter = g_value_get_int (value);
g_object_notify (object, "device-type-filter");
break;
case PROP_DEVICE_CATEGORY_FILTER:
priv->device_category_filter = g_value_get_enum (value);
g_object_notify (object, "device-category-filter");
break;
case PROP_DEVICE_SERVICE_FILTER:
g_free (priv->device_service_filter);
priv->device_service_filter = g_value_dup_string (value);
if (priv->filter)
gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (priv->filter));
break;
case PROP_INTERNAL_FILTER:
priv->internal_filter = g_value_get_boolean (value);
g_object_set (G_OBJECT (priv->filters_vbox), "visible", priv->internal_filter, NULL);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
}
}
void remmina_ftp_client_set_show_hidden(RemminaFTPClient *client, gboolean show_hidden)
{
client->priv->file_list_show_hidden = show_hidden;
gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(client->priv->file_list_filter));
}
static void
update_timezone (CcDateTimePanel *self)
{
CcDateTimePanelPrivate *priv = self->priv;
GtkWidget *widget;
gchar **split;
GtkTreeIter iter;
GtkTreeModel *model;
/* tz.c updates the local timezone, which means the spin buttons can be
* updated with the current time of the new location */
split = g_strsplit (priv->current_location->zone, "/", 2);
/* remove underscores */
g_strdelimit (split[1], "_", ' ');
/* update region combo */
widget = (GtkWidget *) gtk_builder_get_object (priv->builder,
"region_combobox");
model = gtk_combo_box_get_model (GTK_COMBO_BOX (widget));
gtk_tree_model_get_iter_first (model, &iter);
do
{
gchar *string;
gtk_tree_model_get (model, &iter, CITY_COL_CITY, &string, -1);
if (!g_strcmp0 (string, split[0]))
{
g_free (string);
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (widget), &iter);
break;
}
g_free (string);
}
while (gtk_tree_model_iter_next (model, &iter));
/* update city combo */
widget = (GtkWidget *) gtk_builder_get_object (priv->builder,
"city_combobox");
model = gtk_combo_box_get_model (GTK_COMBO_BOX (widget));
gtk_tree_model_filter_refilter ((GtkTreeModelFilter *) gtk_builder_get_object (priv->builder, "city-modelfilter"));
gtk_tree_model_get_iter_first (model, &iter);
do
{
gchar *string;
gtk_tree_model_get (model, &iter, CITY_COL_CITY, &string, -1);
if (!g_strcmp0 (string, split[1]))
{
g_free (string);
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (widget), &iter);
break;
}
g_free (string);
}
while (gtk_tree_model_iter_next (model, &iter));
g_strfreev (split);
}
void _fcitx_main_window_filtertext_changed(GtkEditable* editable, gpointer user_data)
{
FcitxMainWindow* self = user_data;
gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(self->filtermodel));
}
void _fcitx_main_window_checkbox_changed(GtkToggleButton* button, gpointer user_data)
{
FcitxMainWindow* self = user_data;
gtk_cell_renderer_toggle_set_activatable(GTK_CELL_RENDERER_TOGGLE(self->togglecell), gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(self->advancecheckbox)));
gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(self->filtermodel));
}
void onEntrySearchTextChanged(GtkEditable *editable, gpointer data)
{
GtkTreeModel *model = (GtkTreeModel *) data;
globalFilterString = gtk_editable_get_chars(editable,0,-1);
gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(model));
}
static gboolean
hildon_find_toolbar_history_append (HildonFindToolbar *self,
gpointer data)
{
HildonFindToolbarPrivate *priv = HILDON_FIND_TOOLBAR_GET_PRIVATE (self);
g_assert (priv);
gchar *string;
gint column = 0;
GtkTreeModel *model = NULL;
GtkListStore *list = NULL;
GtkTreeIter iter;
gboolean self_create = FALSE;
g_object_get (self, "prefix", &string, NULL);
if (*string == '\0')
{
/* empty prefix, ignore */
g_free (string);
return TRUE;
}
/* If list store is set, get it */
model = hildon_find_toolbar_get_list_model(priv);
if(model != NULL)
{
list = GTK_LIST_STORE (model);
g_object_get(self, "column", &column, NULL);
if (column < 0)
{
/* Column number is -1 if "column" property hasn't been set but
"list" property is. */
g_free (string);
return TRUE;
}
/* Latest string is always the first one in list. If the string
already exists, remove it so there are no duplicates in list. */
if (hildon_find_toolbar_find_string (self, &iter, column, string))
gtk_list_store_remove (list, &iter);
}
else
{
/* No list store set. Create our own. */
list = gtk_list_store_new (1, G_TYPE_STRING);
model = GTK_TREE_MODEL (list);
self_create = TRUE;
}
/* Add the string to first in list */
gtk_list_store_append (list, &iter);
gtk_list_store_set (list, &iter, column, string, -1);
if(self_create)
{
/* Add the created list to ComboBoxEntry */
hildon_find_toolbar_apply_filter (self, model);
/* ComboBoxEntry keeps the only needed reference to this list */
g_object_unref (list);
/* Set the column only after ComboBoxEntry's model is set
in hildon_find_toolbar_apply_filter() */
g_object_set (self, "column", 0, NULL);
}
else
{
/* Refilter to get the oldest entry hidden from history */
gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER(
gtk_combo_box_get_model (GTK_COMBO_BOX(priv->entry_combo_box))));
}
g_free (string);
return FALSE;
}
void _fcitx_main_window_checkbox_changed(GtkToggleButton* button, gpointer user_data)
{
FcitxMainWindow* self = user_data;
gtk_tree_view_column_set_visible(self->checkboxcolumn, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(self->advancecheckbox)));
gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(self->filtermodel));
}
void _fcitx_im_dialog_filtertext_changed(GtkEditable* editable, gpointer user_data)
{
FcitxImDialog* self = user_data;
gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(self->filtermodel));
}
void history_search(void)
{
if (history_filter != NULL)
gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(history_filter));
}
void _fcitx_im_dialog_onlycurlangcheckbox_toggled(GtkToggleButton* button, gpointer user_data)
{
FcitxImDialog* self = user_data;
gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(self->filtermodel));
}
void _fcitx_main_window_add_addon_page(FcitxMainWindow* self)
{
/* load addon */
FcitxAddon* addon;
utarray_new(self->addons, &addonicd);
FcitxAddonsLoad(self->addons);
GtkWidget* vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
/* advance check box */
self->advancecheckbox = gtk_check_button_new_with_label(_("Advance"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(self->advancecheckbox), FALSE);
g_signal_connect(G_OBJECT(self->advancecheckbox), "toggled", G_CALLBACK(_fcitx_main_window_checkbox_changed), self);
/* filter entry */
self->filterentry = gtk_entry_new();
gtk_entry_set_icon_from_stock (GTK_ENTRY (self->filterentry),
GTK_ENTRY_ICON_SECONDARY,
GTK_STOCK_CLEAR);
g_object_set(G_OBJECT(self->filterentry), "margin", 5, NULL);
#if GTK_CHECK_VERSION(3,2,0)
gtk_entry_set_placeholder_text(GTK_ENTRY (self->filterentry), _("Search Addon"));
#endif
g_signal_connect(G_OBJECT(self->filterentry), "icon-press", G_CALLBACK (icon_press_cb), NULL);
gtk_box_pack_start(GTK_BOX(vbox), self->filterentry, FALSE, TRUE, 5);
/* list view */
self->addonstore = gtk_list_store_new(N_COLUMNS, G_TYPE_POINTER);
for (addon = (FcitxAddon *) utarray_front(self->addons);
addon != NULL;
addon = (FcitxAddon *) utarray_next(self->addons, addon)) {
GtkTreeIter iter;
gtk_list_store_append(self->addonstore, &iter);
gtk_list_store_set(self->addonstore, &iter, LIST_ADDON, addon, -1);
}
self->filtermodel = gtk_tree_model_filter_new(GTK_TREE_MODEL(self->addonstore), NULL);
gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(self->filtermodel),
(GtkTreeModelFilterVisibleFunc) _filter_addon_func,
self,
NULL);
self->addonview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(self->filtermodel));
/* add column check box */
self->togglecell = gtk_cell_renderer_toggle_new();
gtk_cell_renderer_toggle_set_activatable(GTK_CELL_RENDERER_TOGGLE(self->togglecell), FALSE);
self->checkboxcolumn = gtk_tree_view_column_new_with_attributes("Enable", self->togglecell, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(self->addonview), self->checkboxcolumn);
gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(self->checkboxcolumn),
self->togglecell,
_fcitx_main_window_enabled_data_func,
NULL,
NULL);
gtk_cell_renderer_toggle_set_activatable(GTK_CELL_RENDERER_TOGGLE(self->togglecell), FALSE);
/* add column text */
GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes("Name", renderer, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(self->addonview), column);
gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(column),
renderer,
_fcitx_main_window_name_data_func,
NULL,
NULL);
/* add addon list to vbox */
GtkWidget* swin = gtk_scrolled_window_new(NULL, NULL);
g_object_set(swin, "hscrollbar-policy", GTK_POLICY_NEVER, NULL);
g_object_set(self->addonview, "headers-visible", FALSE, NULL);
gtk_container_add(GTK_CONTAINER(swin), self->addonview);
gtk_box_pack_start(GTK_BOX(vbox), swin, TRUE, TRUE, 0);
g_object_set(G_OBJECT(swin), "margin-left", 5, "margin-right", 5, "shadow-type", GTK_SHADOW_IN, NULL);
g_signal_connect(G_OBJECT(self->togglecell), "toggled",
G_CALLBACK(_fcitx_main_window_toggled_cb), GTK_TREE_MODEL(self->addonstore));
gtk_box_pack_start(GTK_BOX(vbox), self->advancecheckbox, FALSE, TRUE, 0);
g_object_set(G_OBJECT(self->advancecheckbox), "margin-left", 5, "margin-right", 5, NULL);
/* configure button */
GtkWidget* hbuttonbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start(GTK_BOX(vbox), hbuttonbox, FALSE, TRUE, 0);
g_object_set(G_OBJECT(hbuttonbox), "margin", 5, NULL);
self->button = gtk_button_new_with_label(_("Configure"));
gtk_widget_set_sensitive(self->button, FALSE);
gtk_button_set_image(GTK_BUTTON(self->button), gtk_image_new_from_stock(GTK_STOCK_PREFERENCES, GTK_ICON_SIZE_BUTTON));
gtk_box_pack_start(GTK_BOX(hbuttonbox), self->button, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(self->button), "clicked", G_CALLBACK(_fcitx_main_window_configure_button_clicked), self);
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(self->addonview));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
g_signal_connect(G_OBJECT(selection), "changed",
G_CALLBACK(_fcitx_main_window_addon_selection_changed), self);
g_signal_connect(G_OBJECT(self->filterentry), "changed", G_CALLBACK(_fcitx_main_window_filtertext_changed), self);
gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(self->filtermodel));
_fcitx_main_window_add_page(self, _("Addon"), vbox, GTK_STOCK_ADD);
}
PrefabSelector::PrefabSelector () :
_widget(gtk_vbox_new(FALSE, 2)), _store(gtk_tree_store_new(PREFAB_STORE_SIZE, G_TYPE_STRING, G_TYPE_STRING,
GDK_TYPE_PIXBUF, G_TYPE_STRING)),
_fileFiltered(gtk_tree_model_filter_new(GTK_TREE_MODEL(_store), NULL)), _fileSorted(
GTK_TREE_MODEL(gtk_tree_model_sort_new_with_model(_fileFiltered))), _view(
GTK_TREE_VIEW(gtk_tree_view_new_with_model(_fileSorted)))
{
std::string fullpath = GlobalRegistry().get(RKEY_APP_PATH) + "prefabs/";
_selectedSelectionStrategy = PREFAB_SELECT_EXTEND;
GtkWidget* scr = gtk_scrolled_window_new(0, 0);
gtk_box_pack_start(GTK_BOX(_widget), scr, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scr), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scr), GTK_SHADOW_IN);
{
gtk_tree_view_set_enable_search(_view, TRUE);
gtk_tree_view_set_search_column(_view, PREFAB_SHORTNAME);
gtk_tree_view_set_headers_visible(_view, TRUE);
gtk_tree_view_set_headers_clickable(_view, TRUE);
#if GTK_CHECK_VERSION(2,10,0)
gtk_tree_view_set_grid_lines(_view, GTK_TREE_VIEW_GRID_LINES_HORIZONTAL);
#endif
g_signal_connect(G_OBJECT(_view), "button_press_event", G_CALLBACK(callbackButtonPress), this);
{
GtkTreeViewColumn* column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Prefab"));
gtk_tree_view_column_set_expand(column, FALSE);
gtk_tree_view_column_set_sort_indicator(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, PREFAB_SHORTNAME);
gtk_tree_view_append_column(_view, column);
GtkCellRenderer* imageRenderer = gtk_cell_renderer_pixbuf_new();
gtk_cell_renderer_set_fixed_size(imageRenderer, 128, -1);
gtk_tree_view_column_pack_start(column, imageRenderer, false);
gtk_tree_view_column_add_attribute(column, imageRenderer, "pixbuf", PREFAB_IMAGE);
GtkCellRenderer* nameRenderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_end(column, nameRenderer, false);
gtk_tree_view_column_add_attribute(column, nameRenderer, "markup", PREFAB_DESCRIPTION);
}
gtk_container_add(GTK_CONTAINER(scr), GTK_WIDGET(_view));
g_object_unref(G_OBJECT(_store));
}
GtkWidget* hboxFooter = gtk_hbox_new(TRUE, 0);
gtk_box_pack_start(GTK_BOX(_widget), hboxFooter, FALSE, TRUE, 0);
{
// options
GtkWidget* vboxOptions = gtk_vbox_new(FALSE, 3);
gtk_box_pack_start(GTK_BOX(hboxFooter), vboxOptions, FALSE, TRUE, 0);
GtkRadioButton* radioExtendSelection =
GTK_RADIO_BUTTON(gtk_radio_button_new_with_label(NULL, _("Extend current selection")));
gtk_widget_ref(GTK_WIDGET(radioExtendSelection));
gtk_box_pack_start(GTK_BOX(vboxOptions), GTK_WIDGET(radioExtendSelection), TRUE, TRUE, 0);
g_object_set_data(G_OBJECT(radioExtendSelection), "handler", gint_to_pointer(
g_signal_connect(radioExtendSelection,
"toggled", G_CALLBACK(callbackSelectionOptionToggleExtend), this)));
GtkRadioButton
* radioUnselect =
GTK_RADIO_BUTTON(gtk_radio_button_new_with_label_from_widget(radioExtendSelection, _("Deselect before insert")));
gtk_widget_ref(GTK_WIDGET(radioUnselect));
gtk_box_pack_start(GTK_BOX(vboxOptions), GTK_WIDGET(radioUnselect), TRUE, TRUE, 0);
g_object_set_data(G_OBJECT(radioUnselect), "handler", gint_to_pointer(
g_signal_connect(G_OBJECT(radioUnselect),
"toggled", G_CALLBACK(callbackSelectionOptionToggleUnselect), this)));
GtkRadioButton
* radioReplace =
GTK_RADIO_BUTTON(gtk_radio_button_new_with_label_from_widget(radioUnselect, _("Replace current selection")));
gtk_widget_ref(GTK_WIDGET(radioReplace));
gtk_box_pack_start(GTK_BOX(vboxOptions), GTK_WIDGET(radioReplace), TRUE, TRUE, 0);
g_object_set_data(G_OBJECT(radioReplace), "handler", gint_to_pointer(
g_signal_connect(G_OBJECT(radioReplace),
"toggled", G_CALLBACK(callbackSelectionOptionToggleReplace), this)));
}
{
//search entry, connect to file filter
GtkWidget* vboxSearch = gtk_vbox_new(FALSE, 3);
gtk_box_pack_start(GTK_BOX(hboxFooter), vboxSearch, FALSE, TRUE, 3);
GtkWidget *searchEntry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(vboxSearch), searchEntry, FALSE, TRUE, 3);
gtk_widget_show(searchEntry);
gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(_fileFiltered),
(GtkTreeModelFilterVisibleFunc) callbackFilterFiles, this, NULL);
g_signal_connect(G_OBJECT(searchEntry), "changed", G_CALLBACK(callbackRefilter), NULL);
_filterEntry = GTK_ENTRY(searchEntry);
#if GTK_CHECK_VERSION(2,10,0)
gtk_tree_view_set_search_entry(_view, _filterEntry);
#endif
}
/* fill prefab store with data */
Directory_forEach(fullpath, LoadPrefabDirectoryFunctor(fullpath, "", NULL, _store));
Directory_forEach(fullpath, MatchFileExtension<LoadPrefabFileFunctor> ("map", LoadPrefabFileFunctor("", NULL, _store)));
gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(_fileFiltered));
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(_fileSorted), PREFAB_SHORTNAME, GTK_SORT_ASCENDING);
}
