public FlipCardController(UITableView tableView, ObservableSortedList <Verse> verses, List <Verse> versesForReview)
{
table = tableView;
data = verses;
reviewableVerses = versesForReview;
position = 0;
}
public void EventAddMany()
{ //****************************************
var MySeed = Environment.TickCount;
var MyRandom = new Random(MySeed);
var MyRecords = new ObservableSortedList <int, int>(1024);
var EventCount = 0;
//****************************************
MyRecords.CollectionChanged += (sender, e) => { if (e.Action == NotifyCollectionChangedAction.Add)
{
EventCount++;
}
};
for (var Index = 0; Index < 1024; Index++)
{
MyRecords.Add(MyRandom.Next(), MyRandom.Next());
}
//****************************************
Assert.AreEqual(1024, MyRecords.Count, "Item count does not match");
Assert.AreEqual(1024, EventCount, "Event Count does not match");
}
public VersesTableViewController() : base("Verses")
{
Current = this;
Verses = new ObservableSortedList <Verse> (AppDelegate.Current.Database.GetVerses());
DataSource = Verses;
}
public ProjectViewModel(BaseViewModel parent)
: base(parent)
{
_First = new Services.ObservableSortedList <ProjectItemViewModel>(
new ProjectItemViewModel[] { },
new Comparers.ProjectItemComparer()
);
_SearchCommand = new Commands.DelegateCommand(PerformSearch);
_AddCommand = new Commands.DelegateCommand(PerformAddFile);
_AddReferenceCommand = new Commands.DelegateCommand(PerformAddReference);
_AddBlueprintsCommand = new Commands.DelegateCommand(PerformAddBlueprints);
_AddExistingCommand = new Commands.DelegateCommand(PerformAddExistingFile);
_AddFolderCommand = new Commands.DelegateCommand(PerformAddFolder);
_AddCollectionCommand = new Commands.DelegateCommand(PerformAddCollection);
_RemoveReferenceCommand = new Commands.DelegateCommand(PerformRemoveReference);
_OpenProjectCommand = new Commands.DelegateCommand(PerformOpenProject);
_NewProjectCommand = new Commands.DelegateCommand(PerformNewProject);
_CloseProjectCommand = new Commands.DelegateCommand(PerformCloseProject);
_ViewCodeCommand = new Commands.DelegateCommand(PerformViewCode);
_RenameCommand = new Commands.DelegateCommand(PerformRename);
_DeleteCommand = new Commands.DelegateCommand(PerformDelete);
}
public void EventClear()
{ //****************************************
var MyRecords = new ObservableSortedList <int, int>();
NotifyCollectionChangedEventArgs MyEventArgs = null, MyKeyEventArgs = null, MyValueEventArgs = null;
//****************************************
MyRecords[10] = 42;
MyRecords.CollectionChanged += (sender, e) => MyEventArgs = e;
MyRecords.Keys.CollectionChanged += (sender, e) => MyKeyEventArgs = e;
MyRecords.Values.CollectionChanged += (sender, e) => MyValueEventArgs = e;
MyRecords.Clear();
//****************************************
Assert.AreEqual(0, MyRecords.Count, "Items not cleared");
Assert.IsNotNull(MyEventArgs, "No Event Raised");
Assert.AreEqual(NotifyCollectionChangedAction.Reset, MyEventArgs.Action);
Assert.IsNotNull(MyKeyEventArgs, "No Key Event Raised");
Assert.AreEqual(NotifyCollectionChangedAction.Reset, MyKeyEventArgs.Action);
Assert.IsNotNull(MyValueEventArgs, "No Value Event Raised");
Assert.AreEqual(NotifyCollectionChangedAction.Reset, MyEventArgs.Action);
}
public FlipCardController(UITableView tableView, ObservableSortedList<Verse> verses, List<Verse> versesForReview)
{
table = tableView;
data = verses;
reviewableVerses = versesForReview;
position = 0;
}
public void AddCollide()
{ //****************************************
var MySeed = Environment.TickCount;
var MyRandom = new Random(MySeed);
var MyRecords = new ObservableSortedList <CollideStruct, int>();
var MyDictionary = new Dictionary <CollideStruct, int>(64);
//****************************************
for (var Index = 0; Index < 64; Index++)
{
CollideStruct Key;
int Value;
do
{
Key = new CollideStruct(MyRandom.Next());
} while (MyDictionary.ContainsKey(Key));
Value = MyRandom.Next();
MyDictionary.Add(Key, Value);
MyRecords.Add(Key, Value);
}
//****************************************
Assert.AreEqual(64, MyRecords.Count, "Count incorrect. Bad Seed was {0}", MySeed);
CollectionAssert.AreEquivalent(MyDictionary, MyRecords, "Collections don't match. Bad Seed was {0}", MySeed);
Thread.Sleep(1);
}
public MemorizationViewController()
: base("Memorization")
{
verses = VersesTableViewController.Current.Verses;
verses.CollectionChanged += delegate(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e) {
if (tableView != null) {
var newItems = e.NewItems;
var oldItems = e.OldItems;
if (newItems != null) {
foreach (Verse verse in newItems) {
if (verse.Category == categoryToFilter)
{
filteredVerses.Add (verse);
Console.WriteLine(verse.Title);
}
}
}
if (oldItems != null) {
foreach (Verse verse in oldItems) {
if (filteredVerses.Any (item => item.Id == verse.Id))
{
filteredVerses.Remove (verse);
Console.WriteLine (verse.Title);
}
}
}
}
};
}
public void GetIndexOutOfRange()
{ //****************************************
var MyRecords = new ObservableSortedList <int, int>();
//****************************************
MyRecords[10] = 42;
//****************************************
try
{
var Pair = ((IList <KeyValuePair <int, int> >)MyRecords)[1];
Assert.Fail("Key found");
}
catch (ArgumentOutOfRangeException)
{
}
try
{
var Pair = ((IList <KeyValuePair <int, int> >)MyRecords)[-1];
Assert.Fail("Key found");
}
catch (ArgumentOutOfRangeException)
{
}
}
public ProjectViewModel(BaseViewModel parent)
: base(parent)
{
_First = new Services.ObservableSortedList<ProjectItemViewModel>(
new ProjectItemViewModel[] { },
new Comparers.ProjectItemComparer()
);
_SearchCommand = new Commands.DelegateCommand(PerformSearch);
_AddCommand = new Commands.DelegateCommand(PerformAddFile);
_AddReferenceCommand = new Commands.DelegateCommand(PerformAddReference);
_AddBlueprintsCommand = new Commands.DelegateCommand(PerformAddBlueprints);
_AddExistingCommand = new Commands.DelegateCommand(PerformAddExistingFile);
_AddFolderCommand = new Commands.DelegateCommand(PerformAddFolder);
_AddCollectionCommand = new Commands.DelegateCommand(PerformAddCollection);
_RemoveReferenceCommand = new Commands.DelegateCommand(PerformRemoveReference);
_OpenProjectCommand = new Commands.DelegateCommand(PerformOpenProject);
_NewProjectCommand = new Commands.DelegateCommand(PerformNewProject);
_CloseProjectCommand = new Commands.DelegateCommand(PerformCloseProject);
_ViewCodeCommand = new Commands.DelegateCommand(PerformViewCode);
_RenameCommand = new Commands.DelegateCommand(PerformRename);
_DeleteCommand = new Commands.DelegateCommand(PerformDelete);
}
public void PrePopulate()
{ //****************************************
var MySeed = Environment.TickCount;
var MyRandom = new Random(MySeed);
var MyDictionary = new Dictionary <int, int>(1024);
var MySortedList = new SortedList <int, int>(1024);
//****************************************
while (MyDictionary.Count < 1024)
{
MyDictionary[MyRandom.Next()] = MyRandom.Next();
}
foreach (var MyPair in MyDictionary)
{
MySortedList.Add(MyPair.Key, MyPair.Value);
}
var MyRecords = new ObservableSortedList <int, int>(MyDictionary);
//****************************************
Assert.AreEqual(1024, MyRecords.Count, "Count incorrect. Bad Seed was {0}", MySeed);
CollectionAssert.AreEqual(MySortedList, MyRecords, "Collections don't match. Bad Seed was {0}", MySeed);
Thread.Sleep(1);
}
public MemorizationViewController() : base("Memorization")
{
verses = VersesTableViewController.Current.Verses;
verses.CollectionChanged += delegate(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e) {
if (tableView != null)
{
var newItems = e.NewItems;
var oldItems = e.OldItems;
if (newItems != null)
{
foreach (Verse verse in newItems)
{
if (verse.Category == categoryToFilter)
{
filteredVerses.Add(verse);
Console.WriteLine(verse.Title);
}
}
}
if (oldItems != null)
{
foreach (Verse verse in oldItems)
{
if (filteredVerses.Any(item => item.Id == verse.Id))
{
filteredVerses.Remove(verse);
Console.WriteLine(verse.Title);
}
}
}
}
};
}
public void EventReplace()
{ //****************************************
var MySeed = Environment.TickCount;
var MyRandom = new Random(MySeed);
var MyRecords = new ObservableSortedList <int, int>(1);
NotifyCollectionChangedEventArgs MyEventArgs = null, MyKeyEventArgs = null, MyValueEventArgs = null;
//****************************************
MyRecords.Add(42, 10);
MyRecords.CollectionChanged += (sender, e) => MyEventArgs = e;
MyRecords.Keys.CollectionChanged += (sender, e) => MyKeyEventArgs = e;
MyRecords.Values.CollectionChanged += (sender, e) => MyValueEventArgs = e;
MyRecords[42] = 84;
//****************************************
Assert.AreEqual(1, MyRecords.Count, "Item count does not match");
Assert.IsNotNull(MyEventArgs, "No Event Raised");
Assert.AreEqual(NotifyCollectionChangedAction.Replace, MyEventArgs.Action);
Assert.IsNotNull(MyEventArgs.OldItems, "No Old Items");
Assert.AreEqual(0, MyEventArgs.OldStartingIndex, "Starting Index incorrect");
Assert.AreEqual(1, MyEventArgs.OldItems.Count, "Old Items Count incorrect");
Assert.AreEqual(new KeyValuePair <int, int>(42, 10), MyEventArgs.OldItems[0], "Old Items Value incorrect");
Assert.IsNotNull(MyEventArgs.NewItems, "No New Items");
Assert.AreEqual(0, MyEventArgs.NewStartingIndex, "Starting Index incorrect");
Assert.AreEqual(1, MyEventArgs.NewItems.Count, "New Items Count incorrect");
Assert.AreEqual(new KeyValuePair <int, int>(42, 84), MyEventArgs.NewItems[0], "New Items Value incorrect");
}
public void EventReplaceUnchanged()
{ //****************************************
var MyRecords = new ObservableSortedList <int, int>();
NotifyCollectionChangedEventArgs MyEventArgs = null, MyKeyEventArgs = null, MyValueEventArgs = null;
//****************************************
MyRecords[9] = 1;
MyRecords[12] = 2;
MyRecords[10] = 3;
MyRecords[11] = 4;
MyRecords.CollectionChanged += (sender, e) => MyEventArgs = e;
MyRecords.Keys.CollectionChanged += (sender, e) => MyKeyEventArgs = e;
MyRecords.Values.CollectionChanged += (sender, e) => MyValueEventArgs = e;
MyRecords[10] = 3;
//****************************************
Assert.AreEqual(3, MyRecords[10]);
Assert.IsNull(MyEventArgs, "Event Raised");
Assert.IsNull(MyKeyEventArgs, "Event Raised");
Assert.IsNull(MyValueEventArgs, "Event Raised");
}
public void AddRangeDuplicateInDictionary()
{ //****************************************
var MyRecords = new ObservableSortedList <int, int>(64);
//****************************************
MyRecords[9] = 1;
MyRecords[10] = 2;
MyRecords[11] = 3;
MyRecords[12] = 4;
try
{
MyRecords.AddRange(new[] { new KeyValuePair <int, int>(1, 1), new KeyValuePair <int, int>(2, 2), new KeyValuePair <int, int>(3, 3), new KeyValuePair <int, int>(9, 4) });
Assert.Fail("Range succeeded");
}
catch (ArgumentException)
{
}
//****************************************
Assert.AreEqual(4, MyRecords.Count, "Items were added");
}
/// <summary>
/// Handle changes to the collection of tags in the underlying model
/// </summary>
/// <param name="sender">collection of sorted tags</param>
/// <param name="e">event details</param>
private void OnTagCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
ObservableSortedList <TagModelKey, string, SimpleTagButtonModel> sortedTags = sender as ObservableSortedList <TagModelKey, string, SimpleTagButtonModel>;
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
int newitemIndex = e.NewStartingIndex;
foreach (SimpleTagButtonModel t in e.NewItems)
{
tagsPanel.Children.Insert(newitemIndex++, createTagButton(t));
}
break;
case NotifyCollectionChangedAction.Remove:
foreach (SimpleTagButtonModel t in e.OldItems)
{
tagsPanel.Children.RemoveAt(e.OldStartingIndex);
}
break;
case NotifyCollectionChangedAction.Reset:
tagsPanel.Children.Clear();
foreach (SimpleTagButtonModel t in Tags.Values)
{
tagsPanel.Children.Add(createTagButton(t));
}
break;
}
}
public MenuItem(string title, double weight)
: base(weight)
{
Title = title;
Children = new ObservableSortedList<MenuItemBase>();
IsHidden = false;
IsEnabled = true;
}
public VersesTableViewController()
: base("Verses")
{
Current = this;
Verses = new ObservableSortedList<Verse> (AppDelegate.Current.Database.GetVerses ());
DataSource = Verses;
}
public ObservableSortedList <PollResponseGroup <UserModel> > GetGroupedPollResponses()
{
ObservableSortedList <PollResponseGroup <UserModel> > groupedResponses = new ObservableSortedList <PollResponseGroup <UserModel> >();
Dictionary <string, PollResponseGroup <UserModel> > responseToGroup = new Dictionary <string, PollResponseGroup <UserModel> >();
this.LoadPollResponses();
if (this.PollOptions != null)
{
foreach (string option in this.PollOptions)
{
PollResponseGroup <UserModel> group = new PollResponseGroup <UserModel>(option);
responseToGroup.Add(option, group);
groupedResponses.Add(group);
}
}
if (this.IsCalendarMessage)
{
PollResponseGroup <UserModel> acceptGroup = new PollResponseGroup <UserModel>(Strings.CalendarAcceptMessage);
responseToGroup.Add(Strings.CalendarAcceptMessage, acceptGroup);
groupedResponses.Add(acceptGroup);
PollResponseGroup <UserModel> declineGroup = new PollResponseGroup <UserModel>(Strings.CalendarDeclineMessage);
responseToGroup.Add(Strings.CalendarDeclineMessage, declineGroup);
groupedResponses.Add(declineGroup);
}
foreach (KeyValuePair <string, int> response in this.Responses)
{
PollResponseGroup <UserModel> group = null;
string key = response.Key;
if (this.IsCalendarMessage)
{
if (string.Compare(response.Key, MessageModel.CalendarAcceptStringNonLocalized, StringComparison.OrdinalIgnoreCase) == 0)
{
key = Strings.CalendarAcceptMessage;
}
if (string.Compare(response.Key, MessageModel.CalendarDeclineStringNonLocalized, StringComparison.OrdinalIgnoreCase) == 0)
{
key = Strings.CalendarDeclineMessage;
}
}
if (!responseToGroup.TryGetValue(key, out group))
{
group = new PollResponseGroup <UserModel>(response.Key);
groupedResponses.Add(group);
responseToGroup.Add(response.Key, group);
}
group.Add(DataSync.Instance.GetUser(response.Value));
}
return(groupedResponses);
}
public TimelineModel()
{
TimestampTextModel.TimestampTextModelComparer comparer = new TimestampTextModel.TimestampTextModelComparer();
Chords = new ObservableSortedList<TimestampTextModel>(comparer);
Chords.CollectionChanged += TimelineItemsChanged;
Lyrics = new ObservableSortedList<TimestampTextModel>(comparer);
Lyrics.CollectionChanged += TimelineItemsChanged;
_zoom = 2.0d;
}
/// <summary>
/// Creates a ConversationMessagesViewModel
/// </summary>
/// <param name="phone"></param>
public ConversationMessagesViewModel(
IServiceProxy serviceProxy,
IUserSettings userSettings,
Guid conversationId,
UserModel recipient,
bool?isGroup)
{
this.serviceProxy = serviceProxy;
this.userSettings = userSettings;
this.messages = new ObservableSortedList <MessageModel>();
this.conversationId = conversationId;
this.recipient = recipient;
this.isGroup = isGroup;
this.listOfQuestions = new ObservableCollection <StringBuilder>();
this.listOfAppointments = new ObservableCollection <AppointmentDateTime>();
this.listOfTaskItems = new ObservableCollection <StringBuilder>();
this.contactDetails.YapperName = recipient.Name;
this.contactDetails.YapperPhone = recipient.PhoneNumber;
this.contactDetails.UserId = recipient.Id;
this.contactDetails.Search();
if (this.IsGroup)
{
this.groupDetails.SetGroup(DataSync.Instance.GetGroup(this.recipient.Id));
}
string[] questions = new string[] { "Yes", "No", "Pass" };
foreach (string s in questions)
{
this.listOfQuestions.Add(new StringBuilder(s));
}
AppointmentDateTime [] appts = new AppointmentDateTime[] { new AppointmentDateTime(DateTime.Now.Ticks), new AppointmentDateTime(DateTime.Now.Ticks), new AppointmentDateTime(DateTime.Now.Ticks) };
foreach (AppointmentDateTime s in appts)
{
this.listOfAppointments.Add(s);
}
// Register the view to handle push notification when the app is running
Messenger.Default.Register <NewMessageSavedEvent>(this, this.HandleNewMessageSavedEvent);
Messenger.Default.Register <NewMessageEvent>(this, this.HandleNewMessageEvent);
Messenger.Default.Register <ExistingMessageEvent>(this, this.HandleExistingMessageEvent);
Messenger.Default.Register <DeleteEvent>(this, this.HandleDeleteEvent);
lock (DataSync.Instance)
{
Messenger.Default.Register <SyncEvent>(this, this.HandleSyncCompleteEvent);
DataSync.Instance.Sync();
this.IsSyncing = !DataSync.Instance.IsSyncComplete;
}
this.IsCurrentyViewing = true;
}
public void Search()
{
var contacts = new Contacts();
contacts.SearchCompleted += (s, args) =>
{
ObservableSortedList <ContactGroup <ContactItem> > tempItems = new ObservableSortedList <ContactGroup <ContactItem> >();
var groups = new Dictionary <char, ContactGroup <ContactItem> >();
foreach (var contact in args.Results)
{
if (!contact.PhoneNumbers.Any(number => number.Kind == PhoneNumberKind.Mobile))
{
continue;
}
if (IsContactRegisteredUser(contact))
{
continue;
}
char firstLetter = char.ToLower(contact.DisplayName[0]);
// show # for numbers
if (firstLetter >= '0' && firstLetter <= '9')
{
firstLetter = '#';
}
// create group for letter if it doesn't exist
if (!groups.ContainsKey(firstLetter))
{
var group = new ContactGroup <ContactItem>(firstLetter);
tempItems.Add(group);
groups[firstLetter] = group;
}
// create a contact for item and add it to the relevant group
var contactItem = new ContactItem(contact);
groups[firstLetter].Add(contactItem);
}
this.items = tempItems;
Deployment.Current.Dispatcher.BeginInvoke(() => { this.NotifyPropertyChanged("Items"); });
IsInitialized = true;
NotifyPropertyChanged("IsContactsEmpty");
NotifyPropertyChanged("IsContactsNotEmpty");
NotifyPropertyChanged("IsLoading");
};
// get all contacts
contacts.SearchAsync(null, FilterKind.None, null);
}
public ClassViewModel(BaseViewModel parent) : base(parent)
{
_First = new Services.ObservableSortedList <ClassItemViewModel>(
new ClassItemViewModel[] { },
new Comparers.ClassItemComparer()
);
_SearchCommand = new Commands.DelegateCommand(PerformSearch);
StartTree();
}
public BlueprintViewModel(BaseViewModel parent) : base(parent)
{
_First = new Services.ObservableSortedList <GridItemViewModel>(
new GridItemViewModel[] { },
new Comparers.GridItemComparer()
);
_SearchCommand = new Commands.DelegateCommand(PerformSearch);
_InsertNameCommand = new Commands.DelegateCommand(PerformInsertName);
_EditProgramCommand = new Commands.DelegateCommand(PerformEditProgram);
_RenameBlockCommand = new Commands.DelegateCommand(PerformRenameBlock);
}
public ClassViewModel(BaseViewModel parent)
: base(parent)
{
_First = new Services.ObservableSortedList<ClassItemViewModel>(
new ClassItemViewModel[] { },
new Comparers.ClassItemComparer()
);
_SearchCommand = new Commands.DelegateCommand(PerformSearch);
StartTree();
}
public void IndexOfMissingValue()
{ //****************************************
var MyRecords = new ObservableSortedList <int, int>();
//****************************************
MyRecords[10] = 42;
//****************************************
Assert.AreEqual(-1, MyRecords.IndexOf(new KeyValuePair <int, int>(10, 30)));
}
public void GetIndex()
{ //****************************************
var MyRecords = new ObservableSortedList <int, int>();
//****************************************
MyRecords[10] = 42;
//****************************************
Assert.AreEqual(new KeyValuePair <int, int>(10, 42), ((IList <KeyValuePair <int, int> >)MyRecords)[0]);
}
public void IndexOfKeyCollideMissing()
{ //****************************************
var MyRecords = new ObservableSortedList <CollideStruct, int>();
//****************************************
MyRecords[new CollideStruct(10)] = 42;
//****************************************
Assert.AreEqual(-1, MyRecords.IndexOfKey(new CollideStruct(11)));
}
public void GetKey()
{ //****************************************
var MyRecords = new ObservableSortedList <int, int>();
//****************************************
MyRecords[10] = 42;
//****************************************
Assert.AreEqual(42, MyRecords[10]);
}
public void IndexOfKeyMissing()
{ //****************************************
var MyRecords = new ObservableSortedList <int, int>();
//****************************************
MyRecords[10] = 42;
//****************************************
Assert.AreEqual(-1, MyRecords.IndexOfKey(11));
}
public virtual void Initialize(ItemsControl todoList, IItemManager <T> itemManager, ObservableSortedList <T> list)
{
this.interactionListControl = todoList;
this.interactionList = list;
this.itemManager = itemManager;
// when the ItemsControl has been rendered, we can locate the ScrollViewer
// that is within its template.
this.interactionListControl.InvokeOnNextLayoutUpdated(() => LocateScrollViewer());
this.IsEnabled = false;
}
public void SetBlueprint(ObservableSortedList <GridItemViewModel> grid)
{
First.Clear();
if (grid != null)
{
if (grid.Count > 0)
{
SetBlueprint(grid[0]);
grid[0].IsExpanded = true;
First.Add(grid[0]);
}
}
}
public RunningSearch(LoadedAssembly[] assemblies, string searchTerm, int searchMode, Language language)
{
this.dispatcher = Dispatcher.CurrentDispatcher;
this.assemblies = assemblies;
this.searchTerm = searchTerm.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
this.language = language;
this.searchMode = searchMode;
this.Results = new ObservableSortedList <SearchResult>(comparer: new NearOriginalMatch(searchTerm));
this.Results.Add(new SearchResult {
Name = "Searching..."
});
}
public BlueprintViewModel(BaseViewModel parent)
: base(parent)
{
_First = new Services.ObservableSortedList<GridItemViewModel>(
new GridItemViewModel[] { },
new Comparers.GridItemComparer()
);
_SearchCommand = new Commands.DelegateCommand(PerformSearch);
_InsertNameCommand = new Commands.DelegateCommand(PerformInsertName);
_EditProgramCommand = new Commands.DelegateCommand(PerformEditProgram);
_RenameBlockCommand = new Commands.DelegateCommand(PerformRenameBlock);
}
public void RemoveAt()
{ //****************************************
var MySeed = Environment.TickCount;
var MyRandom = new Random(MySeed);
var MyDictionary = new SortedList <int, int>(1024);
//****************************************
for (var Index = 0; Index < 1024; Index++)
{
int Key, Value;
do
{
Key = MyRandom.Next();
} while (MyDictionary.ContainsKey(Key));
Value = MyRandom.Next();
MyDictionary.Add(Key, Value);
}
var MyRecords = new ObservableSortedList <int, int>(MyDictionary);
//****************************************
for (var Index = 0; Index < 512; Index++)
{
var InnerIndex = MyRandom.Next(MyRecords.Count);
var Key = MyRecords.Keys[InnerIndex];
MyRecords.RemoveAt(InnerIndex);
Assert.IsTrue(MyDictionary.Remove(Key));
}
//****************************************
Assert.AreEqual(512, MyRecords.Count, "Count incorrect. Bad Seed was {0}", MySeed);
CollectionAssert.AreEquivalent(MyDictionary, MyRecords, "Collections don't match. Bad Seed was {0}", MySeed);
foreach (var MyPair in MyDictionary)
{
Assert.IsTrue(MyRecords.TryGetValue(MyPair.Key, out var Value));
Assert.AreEqual(MyPair.Value, Value);
}
Thread.Sleep(1);
}
public ProjectItemViewModel(ProjectItem item, ProjectItemViewModel parent) : base(parent)
{
_Model = item;
_Children = new Services.ObservableSortedList <ProjectItemViewModel>(
(from child in _Model.Children select new ProjectItemViewModel(child, this)).ToList <ProjectItemViewModel>(),
new Comparers.ProjectItemComparer()
);
_Grid = new Services.ObservableSortedList <GridItemViewModel>(
new GridItemViewModel[] { },
new Comparers.GridItemComparer()
);
}
public ProjectItemViewModel(ProjectItem item, ProjectItemViewModel parent)
: base(parent)
{
_Model = item;
_Children = new Services.ObservableSortedList<ProjectItemViewModel>(
(from child in _Model.Children select new ProjectItemViewModel(child, this)).ToList<ProjectItemViewModel>(),
new Comparers.ProjectItemComparer()
);
_Grid = new Services.ObservableSortedList<GridItemViewModel>(
new GridItemViewModel[] { },
new Comparers.GridItemComparer()
);
}
private bool incidentCreated; //a bool to check if the incident has been created. An incident can only be created once.
#endregion
/// <summary>
/// Constructor
/// </summary>
/// <param name="gazetterDatabase">Object that enables connection to the database to retrieve gazetteer related information</param>
/// <param name="incidentDatabase">Object that enables connection to the database to retrieve information for a single incident.</param>
public NewIncidentViewModel()
{
//Set default values for properties that are bound to text box controls
County = "Northamptonshire";
//instantiates the incident type list
matchingAddresses = new ObservableCollection <Address>();
//the ObservableSortedList Contains() method only checks if the reference types are the same.
//Thus, these two lists must share the same reference to stop duplicate entries when adding/removing
fullList = BuildIncidentTypes();
filteredIncidentTypes = new ObservableSortedList <IncidentType>(fullList);
incidentCreated = false;
}
public MemorizationQueueSource(MemorizationTableViewController tableView, ObservableSortedList<Verse> verses)
{
data = verses;
tableViewController = tableView;
selectedVerses = new List<Verse> ();
selected = new bool[data.Count];
for (int i = 0; i < data.Count; i++) {
selected [i] = false;
}
if (data.Count == 0) {
sectionIsEmpty = true;
}
}
public void Replace()
{ //****************************************
var MyRecords = new ObservableSortedList <int, int>();
//****************************************
MyRecords.Add(9, 1);
MyRecords.Add(12, 2);
MyRecords.Add(10, 3);
MyRecords.Add(11, 4);
MyRecords[10] = 84;
//****************************************
Assert.AreEqual(84, MyRecords[10]);
}
public static ObservableSortedList<ContactGroup<UserModel>> GroupUsers(IList<UserModel> users)
{
ObservableSortedList<ContactGroup<UserModel>> groups = new ObservableSortedList<ContactGroup<UserModel>>();
var groupsDict = new Dictionary<char, ContactGroup<UserModel>>();
foreach (UserModel user in users)
{
if (user.UserType == UserType.Group)
{
if (!user.Name.Contains("(G)"))
{
user.Name += " (G)";
}
}
char firstLetter = char.ToLower(user.Name[0]);
// show # for numbers
if (firstLetter >= '0' && firstLetter <= '9')
{
firstLetter = '#';
}
// create group for letter if it doesn't exist
if (!groupsDict.ContainsKey(firstLetter))
{
var group = new ContactGroup<UserModel>(firstLetter);
groups.Add(group);
groupsDict[firstLetter] = group;
}
// create a contact for item and add it to the relevant
groupsDict[firstLetter].Add(user);
}
return groups;
}
public void SetBlueprint(ObservableSortedList<GridItemViewModel> grid)
{
First.Clear();
if (grid != null)
{
if (grid.Count > 0)
{
SetBlueprint(grid[0]);
grid[0].IsExpanded = true;
First.Add(grid[0]);
}
}
}
public void Search()
{
var contacts = new Contacts();
contacts.SearchCompleted += (s, args) =>
{
ObservableSortedList<ContactGroup<ContactItem>> tempItems = new ObservableSortedList<ContactGroup<ContactItem>>();
var groups = new Dictionary<char, ContactGroup<ContactItem>>();
foreach (var contact in args.Results)
{
if (!contact.PhoneNumbers.Any(number => number.Kind == PhoneNumberKind.Mobile))
{
continue;
}
if (IsContactRegisteredUser(contact))
{
continue;
}
char firstLetter = char.ToLower(contact.DisplayName[0]);
// show # for numbers
if (firstLetter >= '0' && firstLetter <= '9')
{
firstLetter = '#';
}
// create group for letter if it doesn't exist
if (!groups.ContainsKey(firstLetter))
{
var group = new ContactGroup<ContactItem>(firstLetter);
tempItems.Add(group);
groups[firstLetter] = group;
}
// create a contact for item and add it to the relevant group
var contactItem = new ContactItem(contact);
groups[firstLetter].Add(contactItem);
}
this.items = tempItems;
Deployment.Current.Dispatcher.BeginInvoke(() => { this.NotifyPropertyChanged("Items"); });
IsInitialized = true;
NotifyPropertyChanged("IsContactsEmpty");
NotifyPropertyChanged("IsContactsNotEmpty");
NotifyPropertyChanged("IsLoading");
};
// get all contacts
contacts.SearchAsync(null, FilterKind.None, null);
}
public ItemSlotCat(string slotName)
{
ItemsList = new ObservableSortedList<PoeItem>();
SlotName = slotName;
}
void FilterData(Category category)
{
filteredVerses = new ObservableSortedList<Verse> (from verse in verses
where verse.Category == category
select verse);
}
/// <summary>
/// Creates a ConversationMessagesViewModel
/// </summary>
/// <param name="phone"></param>
public ConversationMessagesViewModel(
IServiceProxy serviceProxy,
IUserSettings userSettings,
Guid conversationId,
UserModel recipient,
bool? isGroup)
{
this.serviceProxy = serviceProxy;
this.userSettings = userSettings;
this.messages = new ObservableSortedList<MessageModel>();
this.conversationId = conversationId;
this.recipient = recipient;
this.isGroup = isGroup;
this.listOfQuestions = new ObservableCollection<StringBuilder>();
this.listOfAppointments = new ObservableCollection<AppointmentDateTime>();
this.listOfTaskItems = new ObservableCollection<StringBuilder>();
this.contactDetails.YapperName = recipient.Name;
this.contactDetails.YapperPhone = recipient.PhoneNumber;
this.contactDetails.UserId = recipient.Id;
this.contactDetails.Search();
if (this.IsGroup)
{
this.groupDetails.SetGroup(DataSync.Instance.GetGroup(this.recipient.Id));
}
string[] questions = new string[] { "Yes", "No", "Pass" };
foreach (string s in questions)
{
this.listOfQuestions.Add(new StringBuilder(s));
}
AppointmentDateTime [] appts = new AppointmentDateTime[] { new AppointmentDateTime(DateTime.Now.Ticks), new AppointmentDateTime(DateTime.Now.Ticks), new AppointmentDateTime(DateTime.Now.Ticks) };
foreach (AppointmentDateTime s in appts)
{
this.listOfAppointments.Add(s);
}
// Register the view to handle push notification when the app is running
Messenger.Default.Register<NewMessageSavedEvent>(this, this.HandleNewMessageSavedEvent);
Messenger.Default.Register<NewMessageEvent>(this, this.HandleNewMessageEvent);
Messenger.Default.Register<ExistingMessageEvent>(this, this.HandleExistingMessageEvent);
Messenger.Default.Register<DeleteEvent>(this, this.HandleDeleteEvent);
lock (DataSync.Instance)
{
Messenger.Default.Register<SyncEvent>(this, this.HandleSyncCompleteEvent);
DataSync.Instance.Sync();
this.IsSyncing = !DataSync.Instance.IsSyncComplete;
}
this.IsCurrentyViewing = true;
}
/// <summary>
/// Read the registered users from the local data base.
/// </summary>
public void ReadRegisteredUsersFromDB()
{
List<UserModel> dbUserList = DataSync.Instance.GetUsers();
if (dbUserList.Count == 0)
{
return;
}
if (this.RegisteredUsers == null)
{
this.RegisteredUsers = new ObservableSortedList<ContactGroup<UserModel>>();
}
var groups = new Dictionary<char, ContactGroup<UserModel>>();
foreach (UserModel user in dbUserList)
{
if (!this.userIdUserMap.ContainsKey(user.Id))
{
this.userIdUserMap.Add(user.Id, user);
}
if (this.Contains(user))
{
continue;
}
if (user.UserType == UserType.Group)
{
if (!user.Name.Contains("(G)"))
{
user.Name += " (G)";
}
}
this.userPhoneNumbers.Add(user.PhoneNumber);
char firstLetter = char.ToLower(user.Name[0]);
// show # for numbers
if (firstLetter >= '0' && firstLetter <= '9')
{
firstLetter = '#';
}
// create group for letter if it doesn't exist
if (!groups.ContainsKey(firstLetter))
{
var group = new ContactGroup<UserModel>(firstLetter);
this.RegisteredUsers.Add(group);
groups[firstLetter] = group;
}
// create a contact for item and add it to the relevant
groups[firstLetter].Add(user);
}
this.isLoading = false;
}
void IXmlClassifyProcess.AfterXmlDeclassify()
{
// Some people have strange broken styles in their settings, probably added due to some bug in an earlier version of the program.
Styles.RemoveWhere(style => style.Layers == null || style.Layers.Count == 0);
foreach (var style in Styles)
{
if (style.Name == null)
style.Name = "<unknown>";
if (style.Author == null)
style.Author = "<unknown>";
}
// Added in v019
if (SavedByVersion < 19 && GameInstalls != null)
GameInstallations = GameInstalls;
#pragma warning disable 0618 // ActiveInstallation should only be used for loading/saving the setting, which is what the code below does.
if (SavedByVersion < 19 && SelectedGamePath != null)
ActiveInstallation = GameInstallations.Where(gi => gi.Path.EqualsNoCase(SelectedGamePath)).FirstOrDefault() ?? GameInstallations.FirstOrDefault();
#pragma warning restore 0618
if (SavedByVersion < 19 && SelectedStyleNameAndAuthor != null)
// This is a fairly approximate match but this way at least some users will see the right style still selected. The old property was too lossy to allow for reliable matching.
ActiveStyle = Styles.FirstOrDefault(s => SelectedStyleNameAndAuthor.Contains(s.Name) && SelectedStyleNameAndAuthor.Contains(s.Author));
GameInstalls = null;
SelectedGamePath = null;
SelectedStyleNameAndAuthor = null;
}
public VersesTableSource(UINavigationController navigationController, ObservableSortedList<Verse> verses)
{
data = verses;
navigator = navigationController;
}
public MoveActionSheetDelegate(MemorizationTableViewController tableView, ObservableSortedList<Verse> verses, List<Verse> selectedCells)
{
tableViewController = tableView;
data = verses;
selected = selectedCells;
}
