public PageAirportFacilities(AirportMVVM airport)
{
Airport = airport;
DataContext = Airport;
FacilityTypes =
Enum.GetValues(typeof(AirportFacility.FacilityType)).Cast<AirportFacility.FacilityType>().ToList();
if (!airport.Airport.Terminals.AirportTerminals.Exists(t => t.Type == Terminal.TerminalType.Cargo))
FacilityTypes.Remove(AirportFacility.FacilityType.Cargo);
InitializeComponent();
var view = (CollectionView)CollectionViewSource.GetDefaultView(lbFacilities.ItemsSource);
view.SortDescriptions.Clear();
var sortAirlineDescription = new SortDescription(
"Facility.Airline.Profile.Name",
ListSortDirection.Ascending);
view.SortDescriptions.Add(sortAirlineDescription);
var sortFacilityDescription = new SortDescription(
"Facility.Facility.Shortname",
ListSortDirection.Ascending);
view.SortDescriptions.Add(sortFacilityDescription);
}
public ContactViewModel(BusinessCoreService businessCoreService, ConversationViewModel conversation)
{
_businessCoreService = businessCoreService;
_conversation = conversation;
IsSelected = false;
CvsStaff = new CollectionViewSource { Source = _businessCoreService.GetContacts() };
GroupDescription gp = new PropertyGroupDescription("OrganizationId");
SortDescription sp = new SortDescription("OrganizationId", ListSortDirection.Ascending);
CvsStaff.GroupDescriptions.Add(gp);
CvsStaff.SortDescriptions.Add(sp);
CvsStaff.Filter += ApplyFilter;
var treeSource = _businessCoreService.GetOrganizationTreeNoChildren();
var data = new ObservableCollection<OrganizationTreeInfoViewModel>();
foreach (var item in treeSource)
{
data.Add(new OrganizationTreeInfoViewModel(item, _businessCoreService));
}
var result = GetOrganizationTree(data.Where(x => x.Info.ParentId == null).ToList(), data);
_organizationTreeSource = new ObservableCollection<OrganizationTreeInfoViewModel>(result);
OrganizationTreeCvsStaff = new CollectionViewSource { Source = _organizationTreeSource };
Subscription.DoSelectedTree(SelectedUsersCallback);
}
private void Sort(string sortBy, ListSortDirection direction)
{
try
{
ICollectionView dataView = CollectionViewSource.GetDefaultView(listView_log.DataContext);
dataView.SortDescriptions.Clear();
SortDescription sd = new SortDescription(sortBy, direction);
dataView.SortDescriptions.Add(sd);
if (_lastHeaderClicked2 != null)
{
if (String.Compare(sortBy, _lastHeaderClicked2) != 0)
{
SortDescription sd2 = new SortDescription(_lastHeaderClicked2, _lastDirection2);
dataView.SortDescriptions.Add(sd2);
}
}
dataView.Refresh();
Settings.Instance.ResColumnHead = sortBy;
Settings.Instance.ResSortDirection = direction;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message + "\r\n" + ex.StackTrace);
}
}
public static void Sort(ItemsControl listView, string sortBy, ListSortDirection direction)
{
listView.Items.SortDescriptions.Clear();
var sd = new SortDescription(sortBy, direction);
listView.Items.SortDescriptions.Add(sd);
listView.Items.Refresh();
}
private void SetupSyncObjectViewModelsView()
{
this.SyncObjectViewModelsView = new ListCollectionView( this._syncObjectVMs );
var displayNameSorting = new SortDescription( "Model.DisplayName", ListSortDirection.Ascending );
this.SyncObjectViewModelsView.SortDescriptions.Add( displayNameSorting );
this.SyncObjectViewModelsView.Filter = this.SyncObjectViewModelsView_Filter;
}
private void SortOrderCombo_OnSelectionChanged(object sender, SelectionChangedEventArgs e)
{
ComboBoxItem cbi = e.AddedItems[0] as ComboBoxItem;
if (cbi != null)
{
string newSortOrder;
if (cbi.Tag == null)
{
newSortOrder = "None";
}
else
{
newSortOrder = cbi.Tag.ToString();
}
SortDescription sortDesc = new SortDescription(newSortOrder, ListSortDirection.Ascending);
ICollectionView cv = CollectionViewSource.GetDefaultView(DataContext);
if (cv != null)
{
cv.SortDescriptions.Clear();
if (newSortOrder != "None")
cv.SortDescriptions.Add(sortDesc);
{
}
}
}
}
public NewUserRegistration()
{
InitializeComponent();
this.contactsCollection = new System.Windows.Data.CollectionViewSource();
this.contactsCollection.Source = ((NewUserRegistrationViewModel)this.DataContext).RegisteredUsers;
System.ComponentModel.SortDescription contactsSort = new System.ComponentModel.SortDescription("FirstLetter", System.ComponentModel.ListSortDirection.Ascending);
this.contactsCollection.SortDescriptions.Add(contactsSort);
BackgroundWorker worker = new BackgroundWorker();
DispatcherHelper.InvokeOnUiThread(() =>
{
NewUserRegistration.InitializeDictionaries();
RegionInfo region = RegionInfo.CurrentRegion;
this.CountryCodeListPicker.ItemsSource = NewUserRegistration.CountryNameToCode.Keys.ToArray();
if (NewUserRegistration.CountryNameToCode.ContainsKey(region.TwoLetterISORegionName))
{
this.CountryCodeListPicker.SelectedItem = (string)NewUserRegistration.CountryNameToCode[region.TwoLetterISORegionName];
}
else
{
this.CountryCodeListPicker.SelectedItem = (string)NewUserRegistration.CodeToCountry["US"];
}
},
true);
worker.RunWorkerAsync();
}
public NewUserRegistration()
{
InitializeComponent();
this.contactsCollection = new System.Windows.Data.CollectionViewSource();
this.contactsCollection.Source = ((NewUserRegistrationViewModel)this.DataContext).RegisteredUsers;
System.ComponentModel.SortDescription contactsSort = new System.ComponentModel.SortDescription("FirstLetter", System.ComponentModel.ListSortDirection.Ascending);
this.contactsCollection.SortDescriptions.Add(contactsSort);
BackgroundWorker worker = new BackgroundWorker();
DispatcherHelper.InvokeOnUiThread(() =>
{
NewUserRegistration.InitializeDictionaries();
RegionInfo region = RegionInfo.CurrentRegion;
this.CountryCodeListPicker.ItemsSource = NewUserRegistration.CountryNameToCode.Keys.ToArray();
if (NewUserRegistration.CountryNameToCode.ContainsKey(region.TwoLetterISORegionName))
{
this.CountryCodeListPicker.SelectedItem = (string)NewUserRegistration.CountryNameToCode[region.TwoLetterISORegionName];
}
else
{
this.CountryCodeListPicker.SelectedItem = (string)NewUserRegistration.CodeToCountry["US"];
}
},
true);
worker.RunWorkerAsync();
}
public static void RestoreSorting(DataGridSortDescription sortDescription, DataGrid grid, ICollectionView view)
{
if (sortDescription.SortDescription != null && sortDescription.SortDescription.Count == 0)
{
if (Core.Settings.Default.CacheListEnableAutomaticSorting)
{
if (Core.Settings.Default.CacheListSortOnColumnIndex >= 0 && Core.Settings.Default.CacheListSortOnColumnIndex < grid.Columns.Count)
{
SortDescription sd = new SortDescription(grid.Columns[Core.Settings.Default.CacheListSortOnColumnIndex].SortMemberPath, Core.Settings.Default.CacheListSortDirection == 0 ? ListSortDirection.Ascending : ListSortDirection.Descending);
sortDescription.SortDescription.Add(sd);
}
}
}
//restore the column sort order
if (sortDescription.SortDescription != null && sortDescription.SortDescription.Count > 0)
{
sortDescription.SortDescription.ToList().ForEach(x => view.SortDescriptions.Add(x));
view.Refresh();
}
//restore the sort directions. Arrows are nice :)
foreach (DataGridColumn c in grid.Columns)
{
if (sortDescription.SortDirection.ContainsKey(c))
{
c.SortDirection = sortDescription.SortDirection[c];
}
}
}
private void OrderByLastName(ListSortDirection dir)
{
ICollectionView dataView = CollectionViewSource.GetDefaultView(testListView.ItemsSource);
dataView.SortDescriptions.Clear();
SortDescription sd = new SortDescription("LastName", dir);
dataView.SortDescriptions.Add(sd);
dataView.Refresh();
}
private void SetNewSortOrder()
{
string newSortOrder = ((ComboBoxItem)sortOrderCombo.SelectedItem).Content.ToString();
SortDescription sortDesc = new SortDescription(newSortOrder, ListSortDirection.Ascending);
CollectionViewSource src = (CollectionViewSource)FindResource("processesView");
src.SortDescriptions.Clear();
src.SortDescriptions.Add(sortDesc);
}
/// <summary>
/// Converts a value.
/// </summary>
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
IList collection = value as System.Collections.IList;
ListCollectionView view = new ListCollectionView(collection);
SortDescription sort = new SortDescription(parameter.ToString(), ListSortDirection.Ascending);
view.SortDescriptions.Add(sort);
return view;
}
private void Sort(string sortBy, ListSortDirection direction)
{
ICollectionView dataView = CollectionViewSource.GetDefaultView(TrackList.ItemsSource);
dataView.SortDescriptions.Clear();
SortDescription sd = new SortDescription(sortBy, direction);
dataView.SortDescriptions.Add(sd);
dataView.Refresh();
}
public PageAirlineServices(AirlineMVVM airline)
{
this.Classes = new ObservableCollection<AirlineClassMVVM>();
foreach (AirlinerClass.ClassType type in Enum.GetValues(typeof(AirlinerClass.ClassType)))
{
if ((int)type <= GameObject.GetInstance().GameTime.Year)
{
AirlineClassMVVM rClass = new AirlineClassMVVM(type);
foreach (RouteFacility.FacilityType facilityType in Enum.GetValues(typeof(RouteFacility.FacilityType)))
{
if (GameObject.GetInstance().GameTime.Year >= (int)facilityType)
{
AirlineClassFacilityMVVM facility = new AirlineClassFacilityMVVM(facilityType);
facility.Facilities.Clear();
foreach (RouteFacility rFacility in AirlineHelpers.GetRouteFacilities(GameObject.GetInstance().HumanAirline, facilityType))
facility.Facilities.Add(rFacility);
facility.SelectedFacility = RouteFacilities.GetBasicFacility(facility.Type);//GetFacilities(rFacility.Type).OrderBy(f => f.ServiceLevel).First();
rClass.Facilities.Add(facility);
}
}
this.Classes.Add(rClass);
}
}
this.Airline = airline;
this.DataContext = this.Airline;
this.Loaded += PageAirlineServices_Loaded;
InitializeComponent();
CollectionView view = (CollectionView)CollectionViewSource.GetDefaultView(lvFacilities.ItemsSource);
view.GroupDescriptions.Clear();
view.SortDescriptions.Clear();
PropertyGroupDescription groupDescription = new PropertyGroupDescription("Type");
view.GroupDescriptions.Add(groupDescription);
SortDescription sortTypeDescription = new SortDescription("Type", ListSortDirection.Ascending);
view.SortDescriptions.Add(sortTypeDescription);
SortDescription sortFacilityDescription = new SortDescription("Facility.Name", ListSortDirection.Ascending);
view.SortDescriptions.Add(sortFacilityDescription);
for (int i = 120; i < 300; i += 15)
cbCancellationPolicy.Items.Add(i);
cbCancellationPolicy.SelectedItem = this.Airline.Airline.getAirlinePolicy("Cancellation Minutes").PolicyValue;
}
/// <summary>
/// Sort the data.
/// </summary>
private void SortList(string propertyName)
{
// Get the data to sort.
ICollectionView dataView = CollectionViewSource.GetDefaultView(this.ItemsSource);
// Specify the new sorting information.
dataView.SortDescriptions.Clear();
SortDescription description = new SortDescription(propertyName, sortDirection);
dataView.SortDescriptions.Add(description);
dataView.Refresh();
}
public void SortDescriptionCollectionAddNoHandlerTest()
{
SortDescriptionCollection sdc = new SortDescriptionCollection ();
SortDescription addedItem = new SortDescription ("A", ListSortDirection.Ascending);
sdc.Add (addedItem);
addedItem = sdc[0];
Assert.AreEqual ("A", addedItem.PropertyName, "ADDN_#1");
Assert.AreEqual (ListSortDirection.Ascending, addedItem.Direction, "ADDN_#2");
Assert.AreEqual (true, addedItem.IsSealed, "ADDN_#3");
}
public SearchUsersViewModel(BusinessCoreService businessCoreService)
{
_contacts = new ObservableCollection<UserInfo>(businessCoreService.GetContacts().ToList());
CvsStaff = new CollectionViewSource { Source = _contacts };
GroupDescription gp = new PropertyGroupDescription("OrganizationId");
SortDescription sp = new SortDescription("OrganizationId", ListSortDirection.Ascending);
CvsStaff.GroupDescriptions.Add(gp);
CvsStaff.SortDescriptions.Add(sp);
CvsStaff.Filter += ApplyFilter;
_businessCoreService = businessCoreService;
}
private void GridViewColumnHeader_Click(object sender, RoutedEventArgs e)
{
GridViewColumnHeader column = (sender as GridViewColumnHeader);
string sortBy = column.Tag.ToString();
uxItemList.Items.SortDescriptions.Clear();
var sortDescription = new System.ComponentModel.SortDescription(sortBy,
System.ComponentModel.ListSortDirection.Ascending);
uxItemList.Items.SortDescriptions.Add(sortDescription);
}
public void Sort(string sortBy, ListSortDirection direction)
{
ICollectionView dataView =
CollectionViewSource.GetDefaultView(this.ItemsSource);
if (dataView != null)
{
dataView.SortDescriptions.Clear();
SortDescription sd = new SortDescription(sortBy, direction);
dataView.SortDescriptions.Add(sd);
dataView.Refresh();
}
}
private void LogitemsViewHeaderClicked(object sender, RoutedEventArgs e)
{
var header = e.OriginalSource as GridViewColumnHeader;
if (null == header) { return; }
var source = (ListView)e.Source;
var nameOfHeader = header.Content.ToString();
var dataView = CollectionViewSource.GetDefaultView(source.ItemsSource);
dataView.SortDescriptions.Clear();
_direction = _direction == ListSortDirection.Ascending ? ListSortDirection.Descending : ListSortDirection.Ascending;
var description = new SortDescription(nameOfHeader, _direction);
dataView.SortDescriptions.Add(description);
dataView.Refresh();
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
IList collection;
if (value is ChildItemCollection<LayerModel, LayerModel>)
collection = ((ChildItemCollection<LayerModel, LayerModel>) value).ToList();
else
collection = (IList) value;
var view = new ListCollectionView(collection);
var sort = new SortDescription(parameter.ToString(), ListSortDirection.Ascending);
view.SortDescriptions.Add(sort);
return view;
}
public void SortDescriptionRemoveBlocked()
{
System.ComponentModel.SortDescription sort = new System.ComponentModel.SortDescription("Name", System.ComponentModel.ListSortDirection.Ascending);
this.LoadCities(() => this._collectionView.SortDescriptions.Add(sort));
this.ModifyData();
EnqueueCallback(() =>
{
ExceptionHelper.ExpectInvalidOperationException(() => this._collectionView.SortDescriptions.Remove(sort), DomainDataSourceResources.CannotLoadWhenCanLoadIsFalse_Sorting);
});
EnqueueTestComplete();
}
internal static Binding Build(object source, string path, string sortPropertyName, ListSortDirection sortDirection = ListSortDirection.Ascending)
{
var sortDescription = new SortDescription(sortPropertyName, sortDirection);
var collectionViewSource = new CollectionViewSource();
collectionViewSource.Source = source;
collectionViewSource.SortDescriptions.Add(sortDescription);
var binding = new Binding();
binding.Source = collectionViewSource;
binding.Path = new PropertyPath(path);
return binding;
}
public PageAirportFacilities(AirportMVVM airport)
{
this.Airport = airport;
this.DataContext = this.Airport;
this.FacilityTypes = Enum.GetValues(typeof(AirportFacility.FacilityType)).Cast<AirportFacility.FacilityType>().ToList();
InitializeComponent();
CollectionView view = (CollectionView)CollectionViewSource.GetDefaultView(lbFacilities.ItemsSource);
view.SortDescriptions.Clear();
SortDescription sortAirlineDescription = new SortDescription("Airline.Profile.Name", ListSortDirection.Ascending);
view.SortDescriptions.Add(sortAirlineDescription);
}
public void SortDescriptionCollectionAddTest()
{
SortDescriptionCollection sdc = new SortDescriptionCollection ();
SortDescription addedItem = new SortDescription ("NONE", ListSortDirection.Ascending);
((INotifyCollectionChanged)sdc).CollectionChanged += delegate (object sender, NotifyCollectionChangedEventArgs e) {
Assert.AreEqual (NotifyCollectionChangedAction.Add, e.Action, "ADD_#0");
addedItem = (SortDescription)e.NewItems [0];
Assert.AreEqual (true, addedItem.IsSealed, "ADD_#0b");
};
sdc.Add (new SortDescription ("A", ListSortDirection.Ascending));
Assert.AreEqual ("A", addedItem.PropertyName, "ADD_#1");
Assert.AreEqual (ListSortDirection.Ascending, addedItem.Direction, "ADD_#2");
Assert.AreEqual (true, addedItem.IsSealed, "ADD_#3");
}
public PageAirportDemand(AirportMVVM airport)
{
this.Airport = airport;
this.DataContext = this.Airport;
InitializeComponent();
CollectionView viewDemands = (CollectionView)CollectionViewSource.GetDefaultView(lvDemand.ItemsSource);
viewDemands.GroupDescriptions.Clear();
viewDemands.GroupDescriptions.Add(new PropertyGroupDescription("Type"));
SortDescription sortTypeDescription = new SortDescription("Type", ListSortDirection.Ascending);
viewDemands.SortDescriptions.Add(sortTypeDescription);
SortDescription sortPassengersDescription = new SortDescription("Passengers", ListSortDirection.Descending);
viewDemands.SortDescriptions.Add(sortPassengersDescription);
}
private void chName_Click(object sender, RoutedEventArgs e)
{
if (_dir == ListSortDirection.Ascending)
_dir = ListSortDirection.Descending;
else if (_dir == ListSortDirection.Descending)
_dir = null;
else if (_dir == null)
_dir = ListSortDirection.Ascending;
ICollectionView dataView = CollectionViewSource.GetDefaultView(lvKeyValue.ItemsSource);
dataView.SortDescriptions.Clear();
if (_dir.HasValue)
{
SortDescription sd = new SortDescription("Name", _dir.Value);
dataView.SortDescriptions.Add(sd);
dataView.Refresh();
}
}
public object Convert(object value, Type targetType, object parameter, CultureInfo language)
{
if (value is ObservableCollection<INode>)
{
var collection = value as ObservableCollection<INode>;
AutoRefreshCollectionViewSource view = new AutoRefreshCollectionViewSource();
view.Source = collection;
var sort = new SortDescription("Type", ListSortDirection.Ascending);
view.SortDescriptions.Add(sort);
sort = new SortDescription("Name", ListSortDirection.Ascending);
view.SortDescriptions.Add(sort);
return view.View;
}
return null;
}
public void SortDescriptionCollectionRemoveTest()
{
SortDescriptionCollection sdc = new SortDescriptionCollection ();
SortDescription removedItem = new SortDescription ("NONE", ListSortDirection.Ascending);
sdc.Add (new SortDescription ("A", ListSortDirection.Ascending));
((INotifyCollectionChanged)sdc).CollectionChanged += delegate (object sender, NotifyCollectionChangedEventArgs e) {
Assert.AreEqual (NotifyCollectionChangedAction.Remove, e.Action, "REM_#0");
removedItem = (SortDescription)e.OldItems [0];
Assert.AreEqual (true, removedItem.IsSealed, "REM_#0b");
};
sdc.RemoveAt (0);
Assert.AreEqual ("A", removedItem.PropertyName, "REM_#1");
Assert.AreEqual (ListSortDirection.Ascending, removedItem.Direction, "REM_#2");
Assert.AreEqual (true, removedItem.IsSealed, "REM_#3");
}
public void ConstructorTest()
{
string propertyName = "SampleProperty";
SortDescription sd = new SortDescription (propertyName, ListSortDirection.Ascending);
Assert.AreEqual (propertyName, sd.PropertyName, "CTOR_#1");
Assert.AreEqual (ListSortDirection.Ascending, sd.Direction, "CTOR_#2");
Assert.IsFalse (sd.IsSealed, "CTOR_#3");
sd = new SortDescription (propertyName, ListSortDirection.Descending);
Assert.AreEqual (ListSortDirection.Descending, sd.Direction, "CTOR_#3");
sd.Direction = ListSortDirection.Ascending;
Assert.AreEqual (ListSortDirection.Ascending, sd.Direction, "CTOR_#4");
sd.PropertyName = "NewProperty";
Assert.AreEqual("NewProperty", sd.PropertyName, "CTOR_#5");
}
protected override void OnItemsSourceChanged(IEnumerable oldValue, IEnumerable newValue)
{
base.OnItemsSourceChanged(oldValue, newValue);
if (this.ItemsSource != null)
{
var dataView = CollectionViewSource.GetDefaultView(this.ItemsSource);
if (dataView.SortDescriptions.Count == 0 && _lastSortList != null && _lastSortList.Count > 0)
{
foreach (var sortBy in _lastSortList)
{
var sd = new SortDescription(sortBy, _lastDirection);
dataView.SortDescriptions.Add(sd);
}
}
dataView.Refresh();
}
}
protected override void OnSorting(DataGridSortingEventArgs eventArgs)
{
string sortPropertyName = eventArgs.Column.SortMemberPath;
if (!string.IsNullOrEmpty(sortPropertyName))
{
var index = Items.SortDescriptions.Select(x => (SortDescription?)x).FirstOrDefault(x => x.Value.PropertyName == sortPropertyName);
if (index != null)
{
Items.SortDescriptions.Remove(index.Value);
}
if (!eventArgs.Column.SortDirection.HasValue)
{
index = new SortDescription { PropertyName = sortPropertyName, Direction = ListSortDirection.Descending };
Items.SortDescriptions.Add(index.Value);
}
else if (eventArgs.Column.SortDirection.Value == ListSortDirection.Descending)
{
index = new SortDescription { PropertyName = sortPropertyName, Direction = ListSortDirection.Ascending };
Items.SortDescriptions.Add(index.Value);
}
foreach (var col in Columns)
{
var item = Items.SortDescriptions.Select(x=>(SortDescription?)x).FirstOrDefault(y => col.SortMemberPath == y.Value.PropertyName);
if (item != null)
{
col.SortDirection = item.Value.Direction;
}
else
{
col.SortDirection = null;
}
}
Items.Refresh();
eventArgs.Handled = true;
}
}
private void FirstTimeLoadedHandler(object sender, RoutedEventArgs e)
{
Loaded -= FirstTimeLoadedHandler;
transcodeItemsCollectionView = (ListCollectionView)CollectionViewSource.GetDefaultView(ViewModel.TranscodingManager.TranscodeItems);
transcodeItemsCollectionView.IsLiveSorting = true;
transcodeItemsCollectionView.LiveSortingProperties.Add(nameof(TranscodeItem.TranscodeStatus));
var statusSortDescription = new SortDescription(nameof(TranscodeItem.TranscodeStatus), ListSortDirection.Ascending);
transcodeItemsCollectionView.SortDescriptions.Add(statusSortDescription);
transcodeItemsCollectionView.IsLiveGrouping = true;
transcodeItemsCollectionView.LiveGroupingProperties.Add(nameof(TranscodeItem.TranscodeStatus));
var statusGroupDescription = new PropertyGroupDescription(nameof(TranscodeItem.TranscodeStatus));
transcodeItemsCollectionView.GroupDescriptions.Add(statusGroupDescription);
foreach (var item in ViewModel.TranscodingManager.TranscodeItems)
{
PropertyChangedEventManager.AddHandler(item, TranscodeItemPropertyChanged, "");
}
CollectionChangedEventManager.AddHandler(ViewModel.TranscodingManager.TranscodeItems, TranscodeItemsCollectionChanged);
}
/// <summary>
/// called by base class Collection<T> when an item is set in list;
/// raises a CollectionChanged event to any listeners
/// </summary>
protected override void SetItem(int index, SortDescription item)
{
throw new NotSupportedException();
}
