public void Init()
{
Contacts = new MvxObservableCollection <Category>();
Contacts.Add(new Category("Title of first category"));
for (int i = 0; i < 4; i++)
{
Contacts[0].Add(new Contact(string.Format("My Contact {0}", i + 1),
"*****@*****.**",
"+48 123 123 123"));
}
Contacts.Add(new Category("Title of second category"));
for (int i = 4; i < 8; i++)
{
Contacts[1].Add(new Contact(string.Format("My Contact {0}", i + 1),
"*****@*****.**",
"+48 123 123 123"));
}
Contacts.Add(new Category("Title of third category"));
for (int i = 8; i < 11; i++)
{
Contacts[2].Add(new Contact(string.Format("My Contact {0}", i + 1),
"*****@*****.**",
"+48 123 123 123"));
}
}
public override Task Initialize()
{
var isAll = true;
AlbumSource = new MvxObservableCollection <Image>();
foreach (Image image in ImageHolder.Current.ImageList)
{
//add visible images or NotAvailable.png
if (image.IsVisible)
{
AlbumSource.Add(image);
}
else
{
AlbumSource.Add(new Image()
{
ClockImageName = notAvailable,
ProfileImageName = notAvailable
});
isAll = false;
}
}
//add bonus images if all images are visible
if (isAll)
{
foreach (Image bonus in ImageHolder.Current.BonusImage)
{
AlbumSource.Add(bonus);
}
}
return(base.Initialize());
}
public HomeViewModel()
{
Vehiculos = new MvxObservableCollection <Vehiculo>();
Vehiculos.Add(new Vehiculo {
Marca = "VW", Modelo = "Jetta", Year = "2000"
});
Vehiculos.Add(new Vehiculo {
Marca = "Nissan", Modelo = "Datsun", Year = "2001"
});
SendDataCommand = new MvxCommand(ExecuteSendDataCommand);
}
private void AddSections()
{
Sections.Add(new SectionViewModel {
NameStatus = FilterEnum.All
});
Sections.Add(new SectionViewModel {
NameStatus = FilterEnum.Opened
});
Sections.Add(new SectionViewModel {
NameStatus = FilterEnum.Closed
});
}
public HomeViewModel(IMvxNavigationService navigationService, IMvxMessenger messenger) : base(navigationService, messenger)
{
TitleText = _titleText;
RightToolbarButtonCommand = new MvxAsyncCommand(async() => await _navigationService.Navigate <ViewPagerViewModel>());
Wallets = new MvxObservableCollection <Wallet>();
Wallets.Add(new Wallet("П", "20%", "2177.2"));
Wallets.Add(new Wallet("Р", "16%", "1693.76"));
Wallets.Add(new Wallet("И", "3%", "317.58"));
Wallets.Add(new Wallet("И", "61%", "6457.46"));
IsRefreshLayoutRefreshing = false;
LookDescriptionCommand = new MvxAsyncCommand(async() => await _navigationService.Navigate <WalletDescriptionViewModel>());
UpdateDataCommand = new MvxAsyncCommand(UpdateData);
CashValuta = _valuta_UAH;
TotalCash = "10586";
}
private async Task <bool> LoadGrades()
{
log.Debug("PrepayViewModel: Loading grades.");
var pump = fcsService.FCSConfig.Pumps
.Where(_pump => _pump.PumpID == PumpId.ToString())
.Single();
SupportedGrades = new MvxObservableCollection <Grade>();
foreach (var pumpGrade in pump.Grades)
{
try
{
var grade = fcsService.FCSConfig.FuelPrice.Grades
.Where(_grade => _grade.Type == pumpGrade.Type)
.Single();
SupportedGrades.Add(grade);
}
catch { }
}
if (SupportedGrades.Count <= 0)
{
return(false);
}
else
{
SelectedGrade = SupportedGrades[0];
return(true);
}
}
public void AddRangeSuppressesChangesTest()
{
var collection = new MvxObservableCollection <string>();
var invokeCount = 0;
collection.CollectionChanged += (s, e) =>
{
invokeCount++;
};
collection.Add("Foo");
Assert.Equal(1, invokeCount);
Assert.Contains("Foo", collection);
var newItems = new[] { "Bar", "Baz", "Herp", "Derp" };
collection.AddRange(newItems);
Assert.Equal(2, invokeCount);
foreach (var item in newItems)
{
Assert.Contains(item, collection);
}
}
private void AddToCollection <T>(MvxObservableCollection <T> listToAdd, IEnumerable <T> addFrom)
{
foreach (var a in addFrom)
{
listToAdd.Add(a);
}
}
protected override void InitializeCollection(int count)
{
for (int i = 0; i < count; i++)
{
_backingCollection.Add(CreateListItem());
}
}
public override void Prepare(ExcersizeLogWrapper parameter)
{
excersizeLogWrapper = parameter;
if (parameter.LoggedExcersizeTemp.ExcersizeID == null)
{
CurrentLoggedExcersize = new LoggedExcersize();
}
CurrentLoggedExcersize = parameter.LoggedExcersizeTemp;
CurrentLoggedExcersize.ExcersizeID = parameter.ExcersizeTemplate.ID;
CurrentLoggedExcersize.ExcersizeName = parameter.ExcersizeTemplate.Name;
if (parameter.LogComplete)
{
CurrentLoggedExcersize.Sets = parameter.LoggedExcersizeTemp.Sets;
LoggingSets = new MvxObservableCollection <LoggingSet>(parameter.LoggedExcersizeTemp.Sets);
}
else
{
CurrentLoggedExcersize.Sets = new List <LoggingSet>();
CurrentTemplate = parameter.ExcersizeTemplate;
int setsToLog = int.Parse(parameter.ExcersizeTemplate.Sets);
LoggingSets = new MvxObservableCollection <LoggingSet>();
for (int i = 0; i < setsToLog; i++)
{
LoggingSet toAdd = new LoggingSet();
LoggingSets.Add(toAdd);
}
}
}
public MediaMetadataViewModel(
MediaMetadata metadata,
ReadOnlyObservableCollection <string> allTags,
ReadOnlyObservableCollection <string> allCharacterTags,
ReadOnlyObservableCollection <string> allCharacterNames)
{
_metadata = metadata;
((INotifyCollectionChanged)_metadata.Tags).CollectionChanged += TagsChanged;
Tags = new MvxObservableCollection <MediaTagViewModel>();
foreach (MediaTag tag in _metadata.Tags)
{
Tags.Add(new MediaTagViewModel(tag, TagDeleted));
}
((INotifyCollectionChanged)_metadata.Characters).CollectionChanged += CharactersChanged;
Characters = new MvxObservableCollection <MediaCharacterViewModel>();
foreach (MediaCharacter character in _metadata.Characters)
{
Characters.Add(new MediaCharacterViewModel(character, CharacterDeleted, allCharacterTags));
}
AllTags = allTags;
_allCharacterTags = allCharacterTags;
AllCharacterNames = allCharacterNames;
NewTag = string.Empty;
NewCharacterName = string.Empty;
}
public GameViewModel(IMvxNavigationService navigationService, FakeDAL dal, GameBuild game)
{
this.navigationService = navigationService;
this.dal = dal;
this.game = game;
this.Name = game.Name;
builds = new MvxObservableCollection <BuildViewModel>(dal.Get <Build>()
.Where(x => x.Game.id == game.id)
.Select(Create));
Builds = builds;
ViewBuildCommand = new MvxAsyncCommand <BuildViewModel>(async b => await navigationService.Navigate(b));
NewBuildCommand = new MvxAsyncCommand(async() =>
{
Busy = true;
await RaisePropertyChanged("Busy");
var bvm = await Task.Run(() =>
{
var build = new Build {
Name = "New Build", Game = game
};
dal.Save(build);
return(Create(build));
});
builds.Add(bvm);
Busy = false;
await RaisePropertyChanged("Busy");
await navigationService.Navigate(bvm);
});
}
public MainViewModel()
{
Items = new MvxObservableCollection <ItemViewModel>();
for (int i = 0; i < 11; i++)
{
Items.Add(new ItemViewModel($"Title {i}"));
}
}
public MainViewModel()
{
Photos = new MvxObservableCollection <Photo>();
Photos.Add(new Photo
{
Url = "http://www.koty.pl/wp-content/uploads/2013/07/shutterstock_208765051-e1502744473499.jpg"
});
}
public WalletImportViewModel(ITonService tonService, IProtoService protoService, ICacheService cacheService, ISettingsService settingsService, IEventAggregator aggregator)
: base(tonService, protoService, cacheService, settingsService, aggregator)
{
Items = new MvxObservableCollection <WalletWordViewModel>();
for (int i = 0; i < 12; i++)
{
Items.Add(new WalletWordViewModel {
Index = i + 1
});
Items.Add(new WalletWordViewModel {
Index = i + 13
});
}
TooBadCommand = new RelayCommand(TooBadExecute);
SendCommand = new RelayCommand(SendExecute);
}
private async void LoadCharacters()
{
var result = await _charactersService.GetCharactersAsync();
for (int i = 0; i < result.Count; i++)
{
_characteritems.Add(new Character {
CharacterName = result[i].CharacterName, CharacterEnabled = result[i].CharacterEnabled, DrawName = result[i].DrawName
});
}
}
private void InitData()
{
var alert = new Alert();
alert.Title = "Test swipes";
var alertItem = new AlertItemViewModel(alert);
AlertItems = new MvxObservableCollection <AlertItemViewModel>();
AlertItems.Add(alertItem);
}
public static void AddRangeWithoutDuplicates <T>(this MvxObservableCollection <T> collection,
IEnumerable <T> elements)
{
foreach (var element in elements)
{
if (!collection.Contains(element))
{
collection.Add(element);
}
}
}
public async Task FillFriendsList()
{
Messenger.Publish(new ProgressBarActivator(this, true));
FriendsList = new MvxObservableCollection <UserProfileModel>();
var userFriends = await _profileService.GetUserFriends();
foreach (var friendModel in userFriends)
{
FriendsList.Add(new UserProfileModel(friendModel, _resourceService));
}
Messenger.Publish(new ProgressBarActivator(this, false));
}
public NewExcersizeViewModel(IMvxNavigationService navigationService)
{
_navigationService = navigationService;
RepNumbers = new MvxObservableCollection <string>();
for (int i = 1; i <= 20; i++)
{
RepNumbers.Add(i.ToString());
}
SaveExcersizeCommand = new MvxCommand(async() =>
{
if (string.IsNullOrWhiteSpace(Name) && string.IsNullOrWhiteSpace(Machine) && string.IsNullOrWhiteSpace(RepRangeLow) && string.IsNullOrWhiteSpace(RepRangeHigh) && string.IsNullOrWhiteSpace(Sets))
{
await Application.Current.MainPage.DisplayAlert("Insufficient Data", "Insufficient Data", "OK");
return;
}
int repLowInt;
bool parsedLow = int.TryParse(RepRangeLow, out repLowInt);
int repHighInt;
bool parsedHigh = int.TryParse(RepRangeHigh, out repHighInt);
if (parsedHigh && parsedLow)
{
if (repLowInt > repHighInt)
{
await Application.Current.MainPage.DisplayAlert("Rep Range Problem", "Low rep range is higher than high rep range.", "OK");
return;
}
}
Excersize excersize = new Excersize();
excersize.ID = Guid.NewGuid().ToString();
excersize.Name = Name;
excersize.Description = Description;
excersize.Machine = Machine;
excersize.RepRange = RepRangeLow + "-" + RepRangeHigh;
excersize.Sets = Sets;
await App.ExcersizeDatabase.SaveItemAsync(excersize);
if (ReturnData)
{
await _navigationService.Close(this, excersize);
}
else
{
await _navigationService.Close(this);
}
});
}
public override async Task Initialize()
{
await base.Initialize();
_posterThemes = new MvxObservableCollection <PosterTheme>();
List <PosterTheme> items = await _dataService.GetPosterThemesAsync();
foreach (PosterTheme theme in items)
{
_posterThemes.Add(theme);
}
}
public async Task FillGamesVault()
{
Messenger.Publish(new ProgressBarActivator(this, true));
GamesList = new MvxObservableCollection <GameWithImageRowModel>();
var gamesInVault = await _profileService.GetGamesInVault(_userId);
foreach (var game in gamesInVault)
{
GamesList.Add(new GameWithImageRowModel(game));
}
Messenger.Publish(new ProgressBarActivator(this, false));
}
public RoadCore(Canvas _canvas, UserControl _first, UserControl _second, ISimulationService _simulationService, int _length)
{
canvas = _canvas;
first = _first;
second = _second;
simulationService = _simulationService;
road = new Road(StationCore.GetModelBy(first), StationCore.GetModelBy(second), _length);
view = new RoadView();
pickService = new DefaultPickService(simulationService, false);
Activate();
Roads.Add(this);
}
private async Task LoadDocuments()
{
Files = new MvxObservableCollection <File>();
var listfiles = await _networkService.QueryAllFilesAsync(App.User.api_token, EventId);
if (listfiles != null && listfiles.Count > 0)
{
foreach (var f in listfiles)
{
Files.Add(f);
}
await this.RaisePropertyChanged("Files");
}
}
public MvxObservableCollection <Log> GetLogHistory(string path)
{
var logs = new MvxObservableCollection <Log>();
var logDirs = Directory.GetDirectories(path);
var name = Path.GetFileName(path);
foreach (var dir in logDirs)
{
var log = this.CollectLogInfo(dir, name);
logs.Add(log);
}
return(new MvxObservableCollection <Log>(logs.OrderByDescending(l => l.StartTime)));
}
private async Task AddPlaylist()
{
var config = new PromptConfig();
config.Message = GetText("EnterNewName");
var result = await _userDialogs.PromptAsync(config);
if (result.Ok && !string.IsNullOrEmpty(result.Value))
{
Playlists.Add(new Playlist()
{
Title = result.Value
});
await _playlistService.SavePlaylists(Playlists);
}
}
public void LoadProject(Project project)
{
if (project.Owner.CompanyName == null || project.Owner.CompanyName == string.Empty)
{
OwnerName = project.Owner.Name;
OwnerType = string.Empty;
Owner = OwnerName;
}
else
{
OwnerName = project.Owner.CompanyName;
OwnerType = "Company";
Owner = OwnerType + " " + OwnerName;
}
mInvitesStatic.Clear();
Invites.Clear();
TimesClickShowMore = 0;
this.ProjectName = project.Title;
this.Description = project.Description;
this.CanEdit = mCacheService.ProjectHeadingItem.ProjectHeading.UserIsCreator;
foreach (var item in project.Invites)
{
mInvitesStatic.Add(item);
}
if (mInvitesStatic.Count > 3)
{
for (int i = 0; i < 3; i++)
{
Invites.Add(mInvitesStatic[i]);
}
IsShowMoreButton = true;
}
else
{
foreach (var item in mInvitesStatic)
{
Invites.Add(item);
}
IsShowMoreButton = false;
}
}
public ExcelFile(string filePath)
{
ExcelSheets = new MvxObservableCollection <ExcelSheet>();
//For image
excelFileSpire = new Spire.Xls.Workbook();
excelFileSpire.LoadFromFile(filePath);
//For PDF
excelFileInterop = new Application();
excelBook = excelFileInterop.Workbooks.Open(filePath);
for (int idx = 0; idx < excelFileSpire.Worksheets.Count; idx++)
{
ExcelSheets.Add(new ExcelSheet(excelFileSpire.Worksheets[idx], excelBook.Sheets[idx + 1]));
}
}
private async Task AddPlaylist()
{
var config = new PromptConfig();
config.Message = GetText("EnterNewName");
var result = await _userDialogs.PromptAsync(config);
if (result.Ok && !string.IsNullOrEmpty(result.Value))
{
var playlist = new Playlist()
{
Title = result.Value
};
Playlists.Add(playlist);
await _mediaManager.Library.AddOrUpdate <IPlaylist>(playlist);
}
}
public void EventShouldNotBeRaised()
{
Setup();
var events = new List <NotifyCollectionChangedEventArgs>();
var items = new MvxObservableCollection <int[]>(new[] { new[] { 1, 2 }, new[] { 3 } });
var sut = new FlatObservableCollection <int>(items);
sut.CollectionChanged += (_, args) => events.Add(args);
sut.Dispose();
items.Add(new[] { 1 });
items.Remove(new[] { 1 });
Assert.AreEqual(0, events.Count);
}
