static void
nemo_list_model_sort_file_entries (NemoListModel *model, GSequence *files, GtkTreePath *path)
{
GSequenceIter **old_order;
GtkTreeIter iter;
int *new_order;
int length;
int i;
FileEntry *file_entry;
gboolean has_iter;
length = g_sequence_get_length (files);
if (length <= 1) {
return;
}
/* generate old order of GSequenceIter's */
old_order = g_new (GSequenceIter *, length);
for (i = 0; i < length; ++i) {
GSequenceIter *ptr = g_sequence_get_iter_at_pos (files, i);
file_entry = g_sequence_get (ptr);
if (file_entry->files != NULL) {
gtk_tree_path_append_index (path, i);
nemo_list_model_sort_file_entries (model, file_entry->files, path);
gtk_tree_path_up (path);
}
old_order[i] = ptr;
}
/* sort */
g_sequence_sort (files, nemo_list_model_file_entry_compare_func, model);
/* generate new order */
new_order = g_new (int, length);
/* Note: new_order[newpos] = oldpos */
for (i = 0; i < length; ++i) {
new_order[g_sequence_iter_get_position (old_order[i])] = i;
}
/* Let the world know about our new order */
g_assert (new_order != NULL);
has_iter = FALSE;
if (gtk_tree_path_get_depth (path) != 0) {
gboolean get_iter_result;
has_iter = TRUE;
get_iter_result = gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &iter, path);
g_assert (get_iter_result);
}
gtk_tree_model_rows_reordered (GTK_TREE_MODEL (model),
path, has_iter ? &iter : NULL, new_order);
g_free (old_order);
g_free (new_order);
}
void
nemo_list_model_file_changed (NemoListModel *model, NemoFile *file,
NemoDirectory *directory)
{
FileEntry *parent_file_entry;
GtkTreeIter iter;
GtkTreePath *path, *parent_path;
GSequenceIter *ptr;
int pos_before, pos_after, length, i, old;
int *new_order;
gboolean has_iter;
GSequence *files;
ptr = lookup_file (model, file, directory);
if (!ptr) {
return;
}
pos_before = g_sequence_iter_get_position (ptr);
g_sequence_sort_changed (ptr, nemo_list_model_file_entry_compare_func, model);
pos_after = g_sequence_iter_get_position (ptr);
if (pos_before != pos_after) {
/* The file moved, we need to send rows_reordered */
parent_file_entry = ((FileEntry *)g_sequence_get (ptr))->parent;
if (parent_file_entry == NULL) {
has_iter = FALSE;
parent_path = gtk_tree_path_new ();
files = model->details->files;
} else {
has_iter = TRUE;
nemo_list_model_ptr_to_iter (model, parent_file_entry->ptr, &iter);
parent_path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter);
files = parent_file_entry->files;
}
length = g_sequence_get_length (files);
new_order = g_new (int, length);
/* Note: new_order[newpos] = oldpos */
for (i = 0, old = 0; i < length; ++i) {
if (i == pos_after) {
new_order[i] = pos_before;
} else {
if (old == pos_before)
old++;
new_order[i] = old++;
}
}
gtk_tree_model_rows_reordered (GTK_TREE_MODEL (model),
parent_path, has_iter ? &iter : NULL, new_order);
gtk_tree_path_free (parent_path);
g_free (new_order);
}
void ptk_file_list_sort ( PtkFileList* list )
{
GHashTable* old_order;
gint *new_order;
GtkTreePath *path;
GList* l;
int i;
if( list->n_files <=1 )
return;
old_order = g_hash_table_new( g_direct_hash, g_direct_equal );
/* save old order */
for( i = 0, l = list->files; l; l = l->next, ++i )
g_hash_table_insert( old_order, l, GINT_TO_POINTER(i) );
/* sort the list */
list->files = g_list_sort_with_data( list->files,
ptk_file_list_compare, list );
/* save new order */
new_order = g_new( int, list->n_files );
for( i = 0, l = list->files; l; l = l->next, ++i )
new_order[i] = GPOINTER_TO_INT( g_hash_table_lookup( old_order, l ) );
g_hash_table_destroy( old_order );
path = gtk_tree_path_new ();
gtk_tree_model_rows_reordered (GTK_TREE_MODEL (list),
path, NULL, new_order);
gtk_tree_path_free (path);
g_free( new_order );
}
void fm_folder_model_sort(FmFolderModel* model)
{
GHashTable* old_order;
gint *new_order;
GSequenceIter *items_it;
GtkTreePath *path;
/* if there is only one item */
if( model->items == NULL || g_sequence_get_length(model->items) <= 1 )
return;
old_order = g_hash_table_new(g_direct_hash, g_direct_equal);
/* save old order */
items_it = g_sequence_get_begin_iter(model->items);
while( !g_sequence_iter_is_end(items_it) )
{
int i = g_sequence_iter_get_position(items_it);
g_hash_table_insert( old_order, items_it, GINT_TO_POINTER(i) );
items_it = g_sequence_iter_next(items_it);
}
/* sort the list */
g_sequence_sort(model->items, fm_folder_model_compare, model);
/* save new order */
new_order = g_new( int, g_sequence_get_length(model->items) );
items_it = g_sequence_get_begin_iter(model->items);
while( !g_sequence_iter_is_end(items_it) )
{
int i = g_sequence_iter_get_position(items_it);
new_order[i] = (guint)g_hash_table_lookup(old_order, items_it);
items_it = g_sequence_iter_next(items_it);
}
g_hash_table_destroy(old_order);
path = gtk_tree_path_new();
gtk_tree_model_rows_reordered(GTK_TREE_MODEL(model),
path, NULL, new_order);
gtk_tree_path_free(path);
g_free(new_order);
}
/**
* thunar_column_model_exchange:
* @column_model : a #ThunarColumnModel.
* @iter1 : first #GtkTreeIter.
* @iter2 : second #GtkTreeIter.
*
* Exchanges the columns at @iter1 and @iter2
* in @column_model.
**/
void
thunar_column_model_exchange (ThunarColumnModel *column_model,
GtkTreeIter *iter1,
GtkTreeIter *iter2)
{
ThunarColumn column;
GtkTreePath *path;
gint new_order[THUNAR_N_VISIBLE_COLUMNS];
gint n;
_thunar_return_if_fail (THUNAR_IS_COLUMN_MODEL (column_model));
_thunar_return_if_fail (iter1->stamp == column_model->stamp);
_thunar_return_if_fail (iter2->stamp == column_model->stamp);
/* swap the columns */
column = column_model->order[GPOINTER_TO_INT (iter1->user_data)];
column_model->order[GPOINTER_TO_INT (iter1->user_data)] = column_model->order[GPOINTER_TO_INT (iter2->user_data)];
column_model->order[GPOINTER_TO_INT (iter2->user_data)] = column;
/* initialize the new order array */
for (n = 0; n < THUNAR_N_VISIBLE_COLUMNS; ++n)
new_order[n] = n;
/* perform the swapping on the new order array */
new_order[GPOINTER_TO_INT (iter1->user_data)] = GPOINTER_TO_INT (iter2->user_data);
new_order[GPOINTER_TO_INT (iter2->user_data)] = GPOINTER_TO_INT (iter1->user_data);
/* emit "rows-reordered" */
path = gtk_tree_path_new ();
gtk_tree_model_rows_reordered (GTK_TREE_MODEL (column_model), path, NULL, new_order);
gtk_tree_path_free (path);
/* emit "columns-changed" */
g_signal_emit (G_OBJECT (column_model), column_model_signals[COLUMNS_CHANGED], 0);
/* save the new column order */
thunar_column_model_save_column_order (column_model);
}
void
custom_list_resort (CustomList * custom_list)
{
GtkTreePath *path;
gint *neworder, i;
if (custom_list->num_rows < 2)
return;
/* resort */
g_qsort_with_data (custom_list->rows,
custom_list->num_rows,
sizeof (chanlistrow *),
(GCompareDataFunc) custom_list_qsort_compare_func,
custom_list);
/* let other objects know about the new order */
neworder = malloc (sizeof (gint) * custom_list->num_rows);
for (i = custom_list->num_rows - 1; i >= 0; i--)
{
/* Note that the API reference might be wrong about
* this, see bug number 124790 on bugs.gnome.org.
* Both will work, but one will give you 'jumpy'
* selections after row reordering. */
/* neworder[(custom_list->rows[i])->pos] = i; */
neworder[i] = (custom_list->rows[i])->pos;
(custom_list->rows[i])->pos = i;
}
path = gtk_tree_path_new ();
gtk_tree_model_rows_reordered (GTK_TREE_MODEL (custom_list), path, NULL,
neworder);
gtk_tree_path_free (path);
free (neworder);
}
static VALUE
rg_rows_reordered(VALUE self, VALUE rbpath, VALUE rbiter, VALUE rbnew_order)
{
GtkTreeModel *proxy = _SELF(self);
GtkTreePath *path = RVAL2GTKTREEPATH(rbpath);
GtkTreeIter *iter = RVAL2GTKTREEITER(rbiter);
gint columns = gtk_tree_model_get_n_columns(proxy);
long n;
gint *new_order = RVAL2GINTS(rbnew_order, n);
if (n != columns) {
g_free(new_order);
rb_raise(rb_eArgError,
"new order array must contain same number of elements as the number of columns in the store: %ld != %d",
n, columns);
}
gtk_tree_model_rows_reordered(proxy, path, iter, new_order);
g_free(new_order);
return self;
}
static void
update_columns (GtkTreeView *view, ViewColumnModel *view_model)
{
GList *old_columns = view_model->columns;
gint old_length, length;
GList *a, *b;
view_model->columns = gtk_tree_view_get_columns (view_model->view);
/* As the view tells us one change at a time, we can do this hack. */
length = g_list_length (view_model->columns);
old_length = g_list_length (old_columns);
if (length != old_length)
{
GtkTreePath *path;
gint i = 0;
/* where are they different */
for (a = old_columns, b = view_model->columns; a && b; a = a->next, b = b->next)
{
if (a->data != b->data)
break;
i++;
}
path = gtk_tree_path_new ();
gtk_tree_path_append_index (path, i);
if (length < old_length)
{
view_model->stamp++;
gtk_tree_model_row_deleted (GTK_TREE_MODEL (view_model), path);
}
else
{
GtkTreeIter iter;
iter.stamp = view_model->stamp;
iter.user_data = b;
gtk_tree_model_row_inserted (GTK_TREE_MODEL (view_model), path, &iter);
}
gtk_tree_path_free (path);
}
else
{
gint i;
gint m = 0, n = 1;
gint *new_order;
GtkTreePath *path;
new_order = g_new (int, length);
a = old_columns; b = view_model->columns;
while (a->data == b->data)
{
a = a->next;
b = b->next;
if (a == NULL)
return;
m++;
}
if (a->next->data == b->data)
{
b = b->next;
while (b->data != a->data)
{
b = b->next;
n++;
}
for (i = 0; i < m; i++)
new_order[i] = i;
for (i = m; i < m+n; i++)
new_order[i] = i+1;
new_order[i] = m;
for (i = m + n +1; i < length; i++)
new_order[i] = i;
}
else
{
a = a->next;
while (a->data != b->data)
{
a = a->next;
n++;
}
for (i = 0; i < m; i++)
new_order[i] = i;
new_order[m] = m+n;
for (i = m+1; i < m + n+ 1; i++)
new_order[i] = i - 1;
for (i = m + n + 1; i < length; i++)
new_order[i] = i;
}
path = gtk_tree_path_new ();
gtk_tree_model_rows_reordered (GTK_TREE_MODEL (view_model),
path,
NULL,
new_order);
gtk_tree_path_free (path);
g_free (new_order);
}
if (old_columns)
g_list_free (old_columns);
}
