private static void LookupWorldCharacter <T>(Dictionary <string, AlphaKeyGroup <T> > table, IEnumerable <T> items, Func <T, string> getKey)
{
var chars = new CharacterGroupings();
foreach (var c in chars.Where(ch => ch.Label.Length > 0).Select(ch => ch.Label[0].ToString().ToUpper()).Where(c => !table.ContainsKey(c) && c != "."))
{
table.Add(c, new AlphaKeyGroup <T>(c));
}
foreach (var item in items)
{
var key = getKey(item);
var lookupChar = chars.Lookup(key).ToUpper();
var index = lookupChar.Length > 1 ? (lookupChar.Any(CharEx.IsAlphabet) ? lookupChar.First(CharEx.IsAlphabet).ToString() : lookupChar) : lookupChar;
if (table.ContainsKey(index))
{
table[index].Add(item);
}
else
{
table.Add(index, new AlphaKeyGroup <T>(index)
{
item
});
}
}
}
/// <summary>
/// Create a list of AlphaGroup<T> with keys set by a SortedLocaleGrouping.
/// </summary>
/// <param name="items">The items to place in the groups.</param>
/// <param name="ci">The CultureInfo to group and sort by.</param>
/// <param name="getKey">A delegate to get the key from an item.</param>
/// <param name="sort">Will sort the data if true.</param>
/// <returns>An items source for a LongListSelector</returns>
public static List <AlphaKeyGroup <T> > CreateGroups(IEnumerable <T> items, CultureInfo ci, GetKeyDelegate getKey, bool sort)
{
CharacterGroupings slg = new CharacterGroupings();
List <AlphaKeyGroup <T> > list = CreateGroups(slg);
foreach (T item in items)
{
try
{
string index = "";
index = slg.Lookup(getKey(item));
if (string.IsNullOrEmpty(index) == false)
{
list.Find(a => a.Key == index).Add(item);
}
}
catch
{
}
}
if (sort)
{
foreach (AlphaKeyGroup <T> group in list)
{
group.Sort((c0, c1) => { return(ci.CompareInfo.Compare(getKey(c0), getKey(c1))); });
}
}
return(list);
}
/// <summary>
/// Groups and sorts into a list of alpha groups based on a string selector.
/// </summary>
/// <typeparam name="TSource">Type of the items in the list.</typeparam>
/// <param name="source">List to be grouped and sorted.</param>
/// <param name="selector">A selector that will provide a value that items to be sorted and grouped by.</param>
/// <returns>A list of JumpListGroups.</returns>
public static List <JumpListGroup <TSource> > ToAlphaGroups <TSource>(
this IEnumerable <TSource> source, Func <TSource, string> selector)
{
// Get the letters representing each group for current language using CharacterGroupings class
var characterGroupings = new CharacterGroupings();
// Create dictionary for the letters and replace '...' with proper globe icon
var keys = characterGroupings.Where(x => x.Label.Count() >= 1)
.Select(x => x.Label)
.ToDictionary(x => x);
keys["..."] = "\uD83C\uDF10";
// Create groups for each letters
var groupDictionary = keys.Select(x => new JumpListGroup <TSource>()
{
Key = x.Value
})
.ToDictionary(x => (string)x.Key);
// Sort and group items into the groups based on the value returned by the selector
var query = from item in source
orderby selector(item)
select item;
foreach (var item in query)
{
var sortValue = selector(item);
groupDictionary[keys[characterGroupings.Lookup(sortValue)]].Add(item);
}
return(groupDictionary.Select(x => x.Value).ToList());
}
public static List <JumpListGroup <TSource> > ToAlphaGroups <TSource>(
this IEnumerable <TSource> source, Func <TSource, string> selector)
{
var characterGroupings = new CharacterGroupings();
var keys = characterGroupings.Where(x => x.Label.Count() >= 1)
.Select(x => x.Label)
.ToDictionary(x => x);
keys["..."] = "\uD83C\uDF10";
var groupDictionary = keys.Select(x => new JumpListGroup <TSource>()
{
Key = x.Value
})
.ToDictionary(x => (string)x.Key);
var query = from item in source
orderby selector(item)
select item;
foreach (var item in query)
{
var sortValue = selector(item);
groupDictionary[keys[characterGroupings.Lookup(sortValue)]].Add(item);
}
return(groupDictionary.Select(x => x.Value).ToList());
}
public DataManager()
{
AlphaGroups = new ObservableCollection <AlphaKeyContent>();
CharacterGroupings cg = new CharacterGroupings();
foreach (var key in cg)
{
if (!string.IsNullOrEmpty(key.Label))
{
AlphaGroups.Add(new AlphaKeyContent {
Key = key.Label
});
}
}
var list = from f in DataList
group f by cg.Lookup(f.Name) into g
orderby g.Key
select g;
foreach (var group in list)
{
var collection = AlphaGroups.FirstOrDefault(f => group.Key.Equals(f.Key));
if (collection == null)
{
collection = AlphaGroups.Last();
}
foreach (var item in group)
{
collection.Add(item);
}
}
}
public static List <AlphaKeyGroup <T> > CreateGroups(IEnumerable <T> items, Func <T, string> keySelector, bool sort)
{
CharacterGroupings slg = new CharacterGroupings("EN");
List <AlphaKeyGroup <T> > list = CreateDefaultGroups(slg);
foreach (T item in items)
{
int index = 0;
{
string label = slg.Lookup(keySelector(item));
index = list.FindIndex(alphakeygroup => (alphakeygroup.Key.Equals(label, StringComparison.CurrentCulture)));
}
if (index >= 0 && index < list.Count)
{
list[index].InternalList.Add(item);
}
}
if (sort)
{
foreach (AlphaKeyGroup <T> group in list)
{
group.InternalList.Sort((c0, c1) => { return(keySelector(c0).CompareTo(keySelector(c0))); });
}
}
return(list);
}
public static List<ListGroup<T>> GroupList<T>(IEnumerable<T> listToGroup, GetNameDelegate<T> getName, bool sort)
{
string numberKey = "0 – 9";
string displayNumberKey = "#";
List<ListGroup<T>> groupedList = new List<ListGroup<T>>();
CharacterGroupings slg = new CharacterGroupings();
foreach (CharacterGrouping key in slg)
{
if (string.IsNullOrWhiteSpace(key.Label) == false){
string displayKey = key.Label;
if (displayKey.Equals(numberKey))
{
displayKey = displayNumberKey;
}
groupedList.Add(new ListGroup<T>(displayKey));
}
}
#if WINDOWS_APP //Duct tape for Windows 8
if (groupedList.Find(t => t.Key == "...") == null)
{
groupedList.Add(new ListGroup<T>("..."));
}
#endif //Duct tape ends
foreach (T item in listToGroup)
{
string itemName = GetTrimmedName(getName(item));
string groupLabel = slg.Lookup(itemName);
if (groupLabel.Equals(numberKey))
{
groupLabel = displayNumberKey;
}
if (!string.IsNullOrEmpty(groupLabel))
{
var groupToAddTo = groupedList.Find(t => t.Key == groupLabel);
#if WINDOWS_APP //Duct tape for Windows 8
if (groupToAddTo == null)
{
groupToAddTo = groupedList.Find(t => t.Key == "...");
}
#endif //Duct tape ends
groupToAddTo.Add(item);
}
}
if (sort)
{
foreach (ListGroup<T> group in groupedList)
{
group.Sort((c0, c1) => { return CultureInfo.InvariantCulture.CompareInfo.Compare(GetTrimmedName(getName(c0)), GetTrimmedName(getName(c1))); });
}
}
return groupedList;
}
/// <summary>
/// Create a list of AlphaGroup<T> with keys set by a SortedLocaleGrouping.
/// </summary>
/// <param name="items">The items to place in the groups.</param>
/// <param name="ci">The CultureInfo to group and sort by.</param>
/// <param name="getKey">A delegate to get the key from an item.</param>
/// <param name="sort">Will sort the data if true.</param>
/// <returns>An items source for a LongListSelector</returns>
public static IEnumerable <GroupedItem <T> > CreateGroupsByAlpha(IEnumerable <T> items)
{
var g = new CharacterGroupings("zh-CN");
var groups = from i in items group i by RemovePinYin(g.Lookup(i.Key));
var ordered = groups.OrderBy(z => z.Key, new StringHelper());
return(from p in ordered where !p.IsNullorEmpty() select new GroupedItem <T>(p));
}
/// <summary>
/// Get item index with indexer-specific logic for grouping.
/// </summary>
/// <param name="item">The item to be indexed.</param>
/// <returns>Item's index.</returns>
/// <seealso cref="GetIndex"/>
public string GetIndexForGroup(CommonViewItemModel item)
{
if (string.IsNullOrEmpty(item?.Title))
{
return(CommonSharedStrings.UnknownIndex);
}
// Lookup table
return(_slg.Lookup(item.Title[0].ToString()));
}
public List <MusicGroup> GroupMusicByFirstLetter(IEnumerable <MusicUi> source)
{
CharacterGroupings cgs = new CharacterGroupings();
var musicGroupList = source.GroupBy(mu => cgs.Lookup(mu.Title).Replace("拼音", "")).Select(g => new MusicGroup(g.Key, g)).ToList();
var cgsGroupList = cgs.Where(c => !c.Label.Contains("拼音") && musicGroupList.All(mg => mg.Name != c.Label))
.Select(c => new MusicGroup(c.Label)).ToList();
musicGroupList.AddRange(cgsGroupList);
return(musicGroupList.Where(mg => mg.Items.Any() || !string.IsNullOrWhiteSpace(mg.Name)).ToList());
}
private static Dictionary <string, JumpListGroup <TSource> > ToAlphaGroupsDictionary <TSource>(
IEnumerable <TSource> source, Func <TSource, string> selector)
{
// Get the letters representing each group for current language using CharacterGroupings class
var characterGroupings = new CharacterGroupings();
// Create dictionary for the letters and replace '...' with proper globe icon
var keys = characterGroupings.Where(x => x.Label.Count() >= 1)
.Select(x => x.Label)
.ToDictionary(x => x);
keys["..."] = "\uD83C\uDF10";
// Create groups for each letters
var groupDictionary = keys.Select(x => new JumpListGroup <TSource>()
{
Key = x.Value
})
.ToDictionary(x => (string)x.Key);
// Sort and group items into the groups based on the value returned by the selector
var query = from item in source
orderby selector(item)
select item;
foreach (var item in query)
{
try
{
var sortValue = selector(item);
string lookup = characterGroupings.Lookup(sortValue);
string key;
if (!keys.TryGetValue(lookup, out key))
{
key = "\uD83C\uDF10";
}
groupDictionary[key].Add(item);
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
}
return(groupDictionary);
}
public static List <AlphaKeyGroup <T> > CreateGroups(IEnumerable <T> items, Func <T, string> keySelector)
{
CharacterGroupings slg = new CharacterGroupings();
List <AlphaKeyGroup <T> > list = CreateAZGroups(); //CreateDefaultGroups(slg);
foreach (T item in items)
{
int index = 0;
string label = slg.Lookup(keySelector(item));
index = list.FindIndex(alphagroupkey => (alphagroupkey.Key.Equals(label, StringComparison.CurrentCulture)));
if (index > -1 && index < list.Count)
{
list[index].Add(item);
}
}
return(list);
}
/// <summary>
/// Create a list of AlphaGroup<T> with keys set by a SortedLocaleGrouping.
/// </summary>
/// <param name="items">The items to place in the groups.</param>
/// <param name="ci">The CultureInfo to group and sort by.</param>
/// <param name="getKey">A delegate to get the key from an item.</param>
/// <param name="sort">Will sort the data if true.</param>
/// <returns>An items source for a LongListSelector</returns>
public static OptimizedObservableCollection <AlphaKeyGroup <T> > CreateGroups(IEnumerable <T> items, CultureInfo ci,
GetKeyDelegate getKey,
bool sort)
{
var slg = new CharacterGroupings();
var list = CreateGroups(slg);
foreach (T item in items)
{
var lookUp = getKey(item);
if (string.IsNullOrEmpty(lookUp))
{
continue;
}
var index = slg.Lookup(lookUp);
var indexs = index.ToUpper();
try
{
list.Find(a => a.Key.Equals(indexs, StringComparison.CurrentCultureIgnoreCase)).Items.Add(item);
}
catch
{
list.FirstOrDefault().Items.Add(item);
}
if (sort)
{
foreach (AlphaKeyGroup <T> group in list)
{
group.OrderKey = getKey;
var asList = group.ToList();
asList.Sort((x, y) => string.Compare(getKey(x), getKey(y), StringComparison.Ordinal));
group.SwitchTo(asList);
}
}
}
return(new OptimizedObservableCollection <AlphaKeyGroup <T> >(list));
}
public static ObservableCollection <GroupedOC <T> > CreateGrouped <T>(IEnumerable <T> InitialItemsList, Func <T, string> selector)
{
ObservableCollection <GroupedOC <T> > GroupedItems = new ObservableCollection <GroupedOC <T> >();
//ObservableCollection<IGrouping<string, T>> GroupedItems2 = new ObservableCollection<IGrouping<string, T>>();
//ObservableCollection<GroupedOC<T>> GroupedItems2 = new ObservableCollection<GroupedOC<T>>;
var characterGroupings = new CharacterGroupings();
//System.Diagnostics.Stopwatch st = new System.Diagnostics.Stopwatch();
//st.Start();
//foreach (var q in InitialItemsList.GroupBy(s => characterGroupings.Lookup(selector(s))).Select(s => s).OrderBy(t => t.Key))
//{
// GroupedItems2.Add(q);
//}
//foreach (var c in characterGroupings)
//{
// bool found = false;
// foreach(var g in GroupedItems2)
// {
// if (g.Key == c.Label) found = true;
// }
// if (!found)
// {
// GroupedItems2.Add(new GroupedOC<T>(c.Label));
// }
//}
//st.Stop();
//st.Restart();
foreach (var c in characterGroupings)
{
GroupedItems.Add(new GroupedOC <T>(c.Label));
}
foreach (var item in InitialItemsList)
{
string a = characterGroupings.Lookup(selector(item));
GroupedItems.FirstOrDefault(e => e.Key.Equals(a)).Add(item);
}
//st.Stop();
return(GroupedItems);
}
/// <summary>
/// Groups and sorts into a list of alpha groups based on a string selector.
/// </summary>
/// <typeparam name="TSource">Type of the items in the list.</typeparam>
/// <param name="source">List to be grouped and sorted.</param>
/// <param name="selector">A selector that will provide a value that items to be sorted and grouped by.</param>
/// <returns>A list of JumpListGroups.</returns>
public static Dictionary <string, List <TSource> > ToAlphaGroups <TSource>(
this IEnumerable <TSource> source, Func <TSource, string> selector)
{
// Get the letters representing each group for current language using CharacterGroupings class
var characterGroupings = new CharacterGroupings();
// Create dictionary for the letters and replace '...' with proper globe icon
var keys = characterGroupings.Where(x => x.Label.Any())
.Select(x => x.Label)
.ToDictionary(x => x);
keys["..."] = "\uD83C\uDF10";
// Create groups for each letters
var groupDictionary = keys.ToDictionary(x => x.Key, v => new List <TSource>());
// Sort and group items into the groups based on the value returned by the selector
var query = from item in source
orderby selector(item)
select item;
foreach (var item in query)
{
var sortValue = selector(item);
var key = characterGroupings.Lookup(sortValue);
if (keys.ContainsKey(key))
{
groupDictionary[key].Add(item);
}
else
{
groupDictionary["..."].Add(item);
}
}
return(groupDictionary);
}
public void AssignGroup_Click(object sender, RoutedEventArgs e)
{
rootPage.NotifyUser("", NotifyType.StatusMessage);
if (ActiveGroupings == null)
{
rootPage.NotifyUser("Select a language first.", NotifyType.ErrorMessage);
return;
}
if (String.IsNullOrEmpty(CandidateText.Text))
{
rootPage.NotifyUser("Enter text to assign to a group.", NotifyType.ErrorMessage);
return;
}
string label = ActiveGroupings.Lookup(CandidateText.Text);
if (!groups.TryGetValue(label, out UIElement element))
{
label = GlobeString;
element = groups[GlobeString];
}
GroupingsGrid.SelectedItem = element;
GroupingResult.Text = $"Group \"{label}\"";
element.StartBringIntoView();
}
private void Load()
{
if (records == null)
{
records = TmpData.PasswordKeeper.Records;
}
CharacterGroupings groupings = new CharacterGroupings();
observablerecords = new RangedObservableCollection <PasswordRecordViewModelGroup>(records.Select(a => PasswordRecordViewModel.CreateFromRecord(a))
.OrderBy(a => a.DisplayName).GroupBy((a) => groupings.Lookup(a.DisplayName))
.Select(a => new PasswordRecordViewModelGroup(a.Key, ct(a))));
UpdateForVisualState(AdaptiveStates.CurrentState);
// Don't play a content transition for first item load.
// Sometimes, this content will be animated as part of the page transition.
DisableContentTransitions();
}
/// <summary>
/// Create a list of AlphaGroup with keys set by a SortedLocaleGrouping.
/// </summary>
/// <param name="items">The items to place in the groups.</param>
/// <param name="ci">The CultureInfo to group and sort by.</param>
/// <param name="getKey">A delegate to get the key from an item.</param>
/// <param name="sort">Will sort the data if true.</param>
/// <returns>An items source for a LongListSelector</returns>
public static OptimizedObservableCollection<AlphaKeyGroup> CreateGroups(IEnumerable<object> items, CultureInfo ci,
GetKeyDelegate getKey,
bool sort = true)
{
var slg = new CharacterGroupings();
var list = CreateGroups(slg);
foreach (var item in items)
{
var lookUp = getKey(item);
if (string.IsNullOrEmpty(lookUp))
continue;
var index = slg.Lookup(lookUp);
if (string.IsNullOrEmpty(index) == false)
{
list.Find(a => a.Key.EqualsIgnoreCase(index)).Items.Add(item);
}
}
var max = list.Select(p => p.Count).Max();
if (sort)
{
foreach (var group in list)
{
group.OrderKey = getKey;
var percent = group.Count > 1 ? Math.Log(group.Count, max) : Math.Log(2, max) / 2;
percent = Math.Max(.1, percent);
if (double.IsNaN(percent))
percent = 0.1;
if (group.Count == 0)
percent = 0;
group.GridLeftLength = new GridLength(percent, GridUnitType.Star);
group.GridRightLength = new GridLength(1 - percent, GridUnitType.Star);
var asList = group.ToList();
asList.Sort((x, y) => string.Compare(getKey(x), getKey(y), StringComparison.Ordinal));
group.SwitchTo(asList);
group.CollectionChanged += (sender, args) =>
{
max = list.Select(p => p.Count).Max();
foreach (var other in list)
{
percent = other.Count > 1 ? Math.Log(other.Count, max) : Math.Log(2, max) / 2;
percent = Math.Max(.1, percent);
if (double.IsNaN(percent))
percent = 0.1;
if (other.Count == 0)
percent = 0;
other.GridLeftLength = new GridLength(percent, GridUnitType.Star);
other.GridRightLength = new GridLength(1 - percent, GridUnitType.Star);
}
};
}
}
return new OptimizedObservableCollection<AlphaKeyGroup>(list);
}