public void Resort() { var column = sort_column; sort_column = null; Sort(column); }
public void Load() { lock (this) { if (source == null) { return; } loaded = false; int i = 0; foreach (Column column in this) { if (column.Id != null) { column.Visible = Get <bool> (column.Id, "visible", column.Visible); column.Width = Get <double> (column.Id, "width", column.Width); column.OrderHint = Get <int> (column.Id, "order", i); } else { column.OrderHint = -1; } i++; } Columns.Sort((a, b) => a.OrderHint.CompareTo(b.OrderHint)); string sort_column_id = Get <string> ("sort", "column", null); if (sort_column_id != null) { ISortableColumn sort_column = null; foreach (Column column in this) { if (column.Id == sort_column_id) { sort_column = column as ISortableColumn; break; } } if (sort_column != null) { int sort_dir = Get <int> ("sort", "direction", 0); SortType sort_type = sort_dir == 0 ? SortType.None : sort_dir == 1 ? SortType.Ascending : SortType.Descending; sort_column.SortType = sort_type; base.SortColumn = sort_column; } } else { base.SortColumn = null; } loaded = true; } OnUpdated(); }
public virtual void SetModel(IListModel <T> value, double vpos) { if (model == value) { return; } if (model != null) { model.Cleared -= OnModelClearedHandler; model.Reloaded -= OnModelReloadedHandler; } model = value; if (model != null) { model.Cleared += OnModelClearedHandler; model.Reloaded += OnModelReloadedHandler; selection_proxy.Selection = model.Selection; IsEverReorderable = model.CanReorder; } if (ViewLayout != null) { ViewLayout.Model = Model; } ISortable sortable = model as ISortable; if (sortable != null && ColumnController != null) { ISortableColumn sort_column = ColumnController.SortColumn ?? ColumnController.DefaultSortColumn; if (sort_column != null) { if (sortable.Sort(sort_column)) { model.Reload(); } RecalculateColumnSizes(); RegenerateColumnCache(); InvalidateHeader(); IsReorderable = sortable.SortColumn == null || sortable.SortColumn.SortType == SortType.None; } } RefreshViewForModel(vpos); var handler = ModelChanged; if (handler != null) { handler(this, EventArgs.Empty); } }
protected virtual bool NeedsReloadWhenFieldChanged(Hyena.Query.QueryField field) { if (field == null) { return(true); } // If it's the artist or album name, then we care, since it affects the browser if (field == Banshee.Query.BansheeQuery.ArtistField || field == Banshee.Query.BansheeQuery.AlbumField) { return(true); } ISortableColumn sort_column = (TrackModel is DatabaseTrackListModel) ? (TrackModel as DatabaseTrackListModel).SortColumn : null; // If it's the field we're sorting by, then yes, we care if (sort_column != null && sort_column.Field == field) { return(true); } // Make sure the query isn't dependent on this field QueryNode query = (TrackModel is DatabaseTrackListModel) ? (TrackModel as DatabaseTrackListModel).Query : null; if (query != null) { if (query != last_query) { query_fields = new List <QueryField> (query.GetFields()); last_query = query; } if (query_fields.Contains(field)) { return(true); } } return(false); }
private IEnumerable <T> Sort(IEnumerable <T> elements, ISortableColumn column) { switch (column.SortType) { case SortType.Ascending: return(elements .OrderBy(elem => typeof(T).GetProperty(column.SortKey).GetValue(elem, null))); case SortType.Descending: return(elements .OrderByDescending(elem => typeof(T).GetProperty(column.SortKey).GetValue(elem, null))); case SortType.None: return(elements); default: Hyena.Log.Debug(String.Format("Unknown SortType {0}", column.SortType)); return(elements); } }
public bool Sort(ISortableColumn column) { lock (this) { if (forced_sort_query) { return(false); } // Don't sort by the same column and the same sort-type more than once if (sort_column != null && sort_column == column && column.SortType == last_sort_type) { return(false); } last_sort_type = column.SortType; sort_column = column; GenerateSortQueryPart(); cache.Clear(); } return(true); }
protected virtual void OnColumnLeftClicked(Column clickedColumn) { if (Model is ISortable && clickedColumn is ISortableColumn) { ISortableColumn sort_column = clickedColumn as ISortableColumn; ISortable sortable = Model as ISortable; // Change the sort-type with every click if (sort_column == ColumnController.SortColumn) { switch (sort_column.SortType) { case SortType.Ascending: sort_column.SortType = SortType.Descending; break; case SortType.Descending: sort_column.SortType = SortType.None; break; case SortType.None: sort_column.SortType = SortType.Ascending; break; } } // If we're switching from a different column, or we aren't reorderable, make sure sort type isn't None if ((sort_column != ColumnController.SortColumn || !IsEverReorderable) && sort_column.SortType == SortType.None) { sort_column.SortType = SortType.Ascending; } sortable.Sort(sort_column); ColumnController.SortColumn = sort_column; IsReorderable = sortable.SortColumn == null || sortable.SortColumn.SortType == SortType.None; Model.Reload(); CenterOnSelection(); RecalculateColumnSizes(); RegenerateColumnCache(); InvalidateHeader(); } }
private void RecalculateColumnSizes() { if (column_cache == null) { return; } ISortable sortable = Model as ISortable; sort_column_index = -1; int min_header_width = 0; for (int i = 0; i < column_cache.Length; i++) { if (sortable != null) { ColumnHeaderCellText column_cell = column_cache[i].Column.HeaderCell as ColumnHeaderCellText; if (column_cell != null) { ISortableColumn sort_column = column_cache[i].Column as ISortableColumn; column_cell.HasSort = sort_column != null && sortable.SortColumn == sort_column; if (column_cell.HasSort) { sort_column_index = i; } } } column_cache[i].Column.CalculateWidths(column_layout, HeaderVisible, HeaderHeight); column_cache[i].MaxWidth = column_cache[i].Column.MaxWidth; column_cache[i].MinWidth = column_cache[i].Column.MinWidth; min_header_width += column_cache[i].MinWidth; } if (column_cache.Length == 1) { column_cache[0].Column.Width = 1.0; } else if (min_header_width >= header_interaction_alloc.Width) { header_width = min_header_width; resizable = false; for (int i = 0; i < column_cache.Length; i++) { column_cache[i].Column.Width = (double)column_cache[i].MinWidth / (double)header_width; } } else { header_width = header_interaction_alloc.Width; resizable = true; if (elastic_columns == null) { elastic_columns = new List <int> (column_cache.Length); } elastic_columns.Clear(); for (int i = 0; i < column_cache.Length; i++) { elastic_columns.Add(i); column_cache[i].ElasticWidth = 0.0; column_cache[i].ElasticPercent = column_cache[i].Column.Width * header_width; } double remaining_width = RecalculateColumnSizes(header_width, header_width); while (Math.Round(remaining_width) != 0.0 && elastic_columns.Count > 0) { double total_elastic_width = 0.0; foreach (int i in elastic_columns) { total_elastic_width += column_cache[i].ElasticWidth; } remaining_width = RecalculateColumnSizes(remaining_width, total_elastic_width); } for (int i = 0; i < column_cache.Length; i++) { column_cache[i].Column.Width = column_cache[i].ElasticWidth / (double)header_width; } } double tmp_width = 0.0; double tmp_max = 0.0; foreach (var col in column_cache) { tmp_width += col.ElasticWidth; tmp_max += col.MaxWidth == Int32.MaxValue ? col.MinWidth : col.MaxWidth; } list_width = tmp_width; max_width = tmp_max; }
public bool Sort(ISortableColumn column) { lock (this) { if (forced_sort_query) { return false; } // Don't sort by the same column and the same sort-type more than once if (sort_column != null && sort_column == column && column.SortType == last_sort_type) { return false; } last_sort_type = column.SortType; sort_column = column; GenerateSortQueryPart (); cache.Clear (); } return true; }
public void Resort() { var column = sort_column; sort_column = null; Sort (column); }
public void Load() { lock (this) { if (source == null) { return; } loaded = false; foreach (Column column in this) { if (column.Id != null) { string @namespace = MakeNamespace(column.Id); column.Visible = ConfigurationClient.Get <bool> (@namespace, "visible", column.Visible); column.Width = ConfigurationClient.Get <double> (@namespace, "width", column.Width); } } // Create a copy so we can read the original index List <Column> columns = new List <Column> (Columns); Columns.Sort(delegate(Column a, Column b) { int a_order = a.Id == null ? -1 : ConfigurationClient.Get <int> ( MakeNamespace(a.Id), "order", columns.IndexOf(a)); int b_order = b.Id == null ? -1 : ConfigurationClient.Get <int> ( MakeNamespace(b.Id), "order", columns.IndexOf(b)); return(a_order.CompareTo(b_order)); }); string sort_ns = String.Format("{0}.{1}.{2}", root_namespace, unique_source_id, "sort"); string sort_column_id = ConfigurationClient.Get <string> (sort_ns, "column", null); if (sort_column_id != null) { ISortableColumn sort_column = null; foreach (Column column in this) { if (column.Id == sort_column_id) { sort_column = column as ISortableColumn; break; } } if (sort_column != null) { int sort_dir = ConfigurationClient.Get <int> (sort_ns, "direction", 0); SortType sort_type = sort_dir == 0 ? SortType.None : sort_dir == 1 ? SortType.Ascending : SortType.Descending; sort_column.SortType = sort_type; base.SortColumn = sort_column; } } else { base.SortColumn = null; } loaded = true; } OnUpdated(); }
public bool Sort(ISortableColumn column) { this.column = column; Reload(); return(true); }