public MainViewModel() { this.refreshCommand = ReactiveCommand.Create(PerformRefresh); IObservable <Func <Plane, bool> > filter = this.WhenAnyValue(vm => vm.SearhText) .Throttle(TimeSpan.FromMilliseconds(800)) .Select(BuildFilter); IObservable <SortExpressionComparer <Plane> > sort = this.WhenAnyValue(vm => vm.SortDescending) .Select(sd => { if (sd) { return(SortExpressionComparer <Plane> .Descending(l => l.Name)); } return(SortExpressionComparer <Plane> .Ascending(l => l.Name)); }); this.planes.Connect() .Filter(filter) .Sort(sort) .ObserveOn(RxApp.MainThreadScheduler) .Bind(out this.bindingData) .DisposeMany() .Subscribe(); }
private void CreateSuggestions(int topSuggestionsCount) { var suggestionLabelsFilter = this.WhenAnyValue(x => x.Labels).Select(_ => Unit.Default) .Merge(Observable.FromEventPattern(Labels, nameof(Labels.CollectionChanged)).Select(_ => Unit.Default)) .Select(_ => SuggestionLabelsFilter()); _sourceLabels .Connect() .Filter(suggestionLabelsFilter) .Sort(SortExpressionComparer <SuggestionLabelViewModel> .Descending(x => x.Count).ThenByAscending(x => x.Label)) .Top(topSuggestionsCount) .Transform(x => x.Label) .ObserveOn(RxApp.MainThreadScheduler) .Bind(_topSuggestions) .Subscribe(); _sourceLabels .Connect() .Filter(suggestionLabelsFilter) .Sort(SortExpressionComparer <SuggestionLabelViewModel> .Descending(x => x.Count).ThenByAscending(x => x.Label)) .Transform(x => x.Label) .ObserveOn(RxApp.MainThreadScheduler) .Bind(_suggestions) .Subscribe(); Func <SuggestionLabelViewModel, bool> SuggestionLabelsFilter() => suggestionLabel => !_labels.Contains(suggestionLabel.Label); }
public QueuesViewModel(IParameterViewStackService parameterViewStackService, IQueueService queueService) : base(parameterViewStackService) { _queueService = queueService; _queueService .Queue .Connect() .RefCount() .Transform(x => new QueuedItemViewModel(x)) .AutoRefresh(x => x.CurrentQueueTime) .Sort(SortExpressionComparer <QueuedItemViewModel> .Descending(x => x.CurrentQueueTime)) .ObserveOn(RxApp.MainThreadScheduler) .Bind(out _queue) .DisposeMany() .Subscribe() .DisposeWith(Subscriptions); Observable .Interval(TimeSpan.FromSeconds(5)) .Subscribe(_ => _queueService.GetQueue(Guid.Empty)) .DisposeWith(Subscriptions); InitializeData = ReactiveCommand.CreateFromObservable(ExecuteInitializeData); }
public RecentFilesViewModel(IRecentFileCollection recentFileCollection, ISchedulerProvider schedulerProvider) { _recentFileCollection = recentFileCollection; if (recentFileCollection == null) { throw new ArgumentNullException(nameof(recentFileCollection)); } if (schedulerProvider == null) { throw new ArgumentNullException(nameof(schedulerProvider)); } ReadOnlyObservableCollection <RecentFileProxy> data; var recentLoader = recentFileCollection.Items .Connect() .Transform(rf => new RecentFileProxy(rf, toOpen => { _fileOpenRequest.OnNext(new FileInfo(toOpen.Name)); }, recentFileCollection.Remove)) .Sort(SortExpressionComparer <RecentFileProxy> .Descending(proxy => proxy.Timestamp)) .ObserveOn(schedulerProvider.MainThread) .Bind(out data) .Subscribe(); Files = data; _cleanUp = Disposable.Create(() => { recentLoader.Dispose(); _fileOpenRequest.OnCompleted(); }); }
public QueryHistoryProvider() { _historySourceList = new SourceList <RawQueryHistory>(); var counter = _historySourceList.CountChanged.Subscribe(i => IsEmpty = i == 0); var limiter = _historySourceList.LimitSizeTo(100).Subscribe(); _historySourceList.AddRange(LoadFileData()); var sharedList = _historySourceList .Connect() .DeferUntilLoaded() .Sort(SortExpressionComparer <RawQueryHistory> .Descending(t => t.LastRunAt)) .ObserveOnDispatcher() .Bind(out _queryHistories) .Subscribe(); var disposable = _queryHistories .ObserveCollectionChanges() .Throttle(TimeSpan.FromSeconds(2)) .Subscribe(pattern => { SaveFileData(_queryHistories); }); _compositeDisposable = new CompositeDisposable(counter, limiter, sharedList, disposable); }
public PullRequestViewModel() { _cacheService = Locator.Current.GetService <ICacheService>(); _pullRequestData = new SourceList <LocalPullRequest>(); ItemTreshold = -1; OpenCount = "0 opened"; CloseCount = "0 closed"; _pullRequestData.Connect() .Sort(SortExpressionComparer <LocalPullRequest> .Descending(x => x.Date)) .ObserveOn(RxApp.MainThreadScheduler) .Do(x => Count()) .Bind(out _pullRequests) .DisposeMany().Subscribe(); ConfigureAddCommand(); ConfigureLoadCommand(); ConfigureLoadCacheCommand(); this.WhenAnyValue(x => x.Repository) .Where(x => x != null) .Select(x => Unit.Default) .InvokeCommand(LoadCacheCommand); }
public InfiniteScrollViewModel(IInventoryDataService inventoryDataService) { _inventoryDataService = inventoryDataService; _pagingSubject = new BehaviorSubject <IPageRequest>(new PageRequest(0, pageSize)); Func <InventoryItemViewModel, bool> Search(string searchTerm) => viewModel => { if (string.IsNullOrEmpty(searchTerm)) { return(true); } var lower = searchTerm.ToLower(); return(viewModel.Brand.ToLower().Contains(lower) || (viewModel.Coffee?.ToLower().Contains(lower) ?? false)); }; var searchChanged = this.WhenAnyValue(x => x.SearchText) .Throttle(TimeSpan.FromMilliseconds(800), RxApp.TaskpoolScheduler) .DistinctUntilChanged() .Select(Search); _inventoryDataService .ChangeSet .Transform(x => new InventoryItemViewModel { Id = x.Id, Brand = x.BrandName, Coffee = x.CoffeeName, Roast = x.Roast, Packaging = x.Packaging }) .AutoRefresh(x => x.Id) .DeferUntilLoaded() .Filter(searchChanged) .Sort(SortExpressionComparer <InventoryItemViewModel> .Descending(x => x.Roast)) .Page(_pagingSubject.AsObservable()) .ObserveOn(RxApp.MainThreadScheduler) .Bind(out _items) .DisposeMany() .Subscribe() .DisposeWith(Garbage); this.WhenAnyObservable(x => x.Refresh.IsExecuting) .StartWith(false) .DistinctUntilChanged() .ToProperty(this, nameof(IsRefreshing), out _isRefreshing, deferSubscription: true) .DisposeWith(Garbage); this.WhenAnyObservable(x => x.Load.IsExecuting) .ToProperty(this, nameof(IsLoading), out _isLoading, deferSubscription: true) .DisposeWith(Garbage); Refresh = ReactiveCommand.CreateFromObservable <EventArgs, Unit>(ExecuteRefresh); Load = ReactiveCommand.CreateFromObservable <int, Unit>(ExecuteLoad); _pagingSubject.DisposeWith(Garbage); }
public PlaybackHistoryViewModel( PlaybackHistory playbackHistory //IAudioPlaybackEngine audioPlaybackEngine //, IReadLibraryService readLibraryService ) { //this._audioPlayer = audioPlaybackEngine ?? throw new ArgumentNullException(nameof(audioPlaybackEngine)); //this._readLibraryService = readLibraryService ?? throw new ArgumentNullException(nameof(readLibraryService)); this._playbackHistory = playbackHistory ?? throw new ArgumentNullException(nameof(playbackHistory)); var sorter = SortExpressionComparer <PlaybackHistoryEntryViewModel> .Descending(pheVM => pheVM.PlaybackEndedDateTime); //var sorter2 = new SortExpressionComparer<PlaybackHistoryEntryViewModel>(); this._playbackHistory.Entries .Connect() .Transform(phe => new PlaybackHistoryEntryViewModel(phe)) .DisposeMany() .Sort( SortExpressionComparer <PlaybackHistoryEntryViewModel> .Descending(pheVM => pheVM.PlaybackEndedDateTime), SortOptions.UseBinarySearch) .Bind(out var boundEntries) .Subscribe() .DisposeWith(this._disposables); this.Entries = boundEntries; // .WhenAudioSourceLocationChanged // .ToObservableChangeSet(10) // .Transform(location => new PlaybackHistoryItemViewModel(location)) // .Bind(out this._items) // .DisposeMany() // .Subscribe() // .DisposeWith(this._disposables); }
public StartPageViewModel( IDatabaseInteractions databaseInteractions, IApplicationInteraction applicationInteraction, IRecentDatabaseFilesProvider recentDatabaseFilesProvider) { _databaseInteractions = databaseInteractions; _applicationInteraction = applicationInteraction; PathDefinitions = recentDatabaseFilesProvider; ShowStartPageOnOpen = Properties.Settings.Default.ShowStartPageOnOpen; var recentFilesTermFilter = this.WhenValueChanged(vm => vm.SearchTerm) .Throttle(TimeSpan.FromMilliseconds(150)) .Select(CreatePredicate); _cleanUp = PathDefinitions.RecentFiles .ToObservableChangeSet() .Filter(recentFilesTermFilter) .Sort( SortExpressionComparer <RecentDatabaseFileInfo> .Descending(p => p.FixedAt.HasValue) .ThenByDescending(p => p.FixedAt ?? p.LastOpenedAt) ) .ObserveOnDispatcher() .Bind(out _recentFilesFiltered) .Do(p => { NotifyOfPropertyChange(nameof(RecentFilesListIsEmpty)); NotifyOfPropertyChange(nameof(RecentFilesListEmptyMessage)); }) .Subscribe(); }
public void ResortOnInlineChanges() { var people = _generator.Take(10).ToList(); _source.AddRange(people); people[0].Age = -1; people[1].Age = -10; people[2].Age = -12; people[3].Age = -5; people[4].Age = -7; people[5].Age = -6; var comparer = SortExpressionComparer <Person> .Descending(p => p.Age) .ThenByAscending(p => p.Name); _changeComparer.OnNext(comparer); var expectedResult = people.OrderBy(p => p, comparer).ToArray(); var actualResult = _results.Data.Items.ToArray(); //actualResult.(expectedResult); actualResult.ShouldAllBeEquivalentTo(expectedResult); }
public void ResortOnInlineChanges() { var people = _generator.Take(10).ToList(); _source.AddRange(people); people[0].Age = -1; people[1].Age = -10; people[2].Age = -12; people[3].Age = -5; people[4].Age = -7; people[5].Age = -6; var comparer = SortExpressionComparer <Person> .Descending(p => p.Age) .ThenByAscending(p => p.Name); _changeComparer.OnNext(comparer); //Assert.AreEqual(10, _results.Data.Count, "Should be 99 people in the cache"); //Assert.AreEqual(2, _results.Messages.Count, "Should be 2 update messages"); ////Assert.AreEqual(toRemove, _results.Messages[1].First().Item.Current, "Incorrect item removed"); var expectedResult = people.OrderBy(p => p, comparer).ToArray(); var actualResult = _results.Data.Items.ToArray(); //actualResult.(expectedResult); CollectionAssert.AreEqual(expectedResult, actualResult); }
public HomeViewModel(ICacheService cacheService = null) { _cacheService = cacheService ?? Locator.Current.GetService <ICacheService>(); _repositoriesData = new SourceList <LocalRepository>(); ItemTreshold = -1; ConfigureAddCommand(); ConfigureLoadCommand(); var filter = this.WhenAnyValue(x => x.Search) .Throttle(TimeSpan.FromMilliseconds(500)) .Select(BuildFilter); _repositoriesData.Connect() .Filter(filter) .Sort(SortExpressionComparer <LocalRepository> .Descending(x => x.StarsCount)) .ObserveOn(RxApp.MainThreadScheduler) .Bind(out _repositories) .DisposeMany().Subscribe(); this.WhenAnyValue(x => x.Selected) .Where(x => x != null) .Do(x => _cacheService.SetCurrentRepository(x)) .Subscribe(); Observable.FromEventPattern( x => _cacheService.LanguageChanged += x, x => _cacheService.LanguageChanged -= x) .Do(x => _repositoriesData.Clear()) .Select(x => Unit.Default) .InvokeCommand(LoadCache); }
public SteamAccountPageViewModel() { IconKey = nameof(SteamAccountPageViewModel); this.WhenAnyValue(x => x.SteamUsers) .Subscribe(s => this.RaisePropertyChanged(nameof(IsUserEmpty))); LoginAccountCommand = ReactiveCommand.Create(LoginNewSteamAccount); RefreshCommand = ReactiveCommand.Create(Initialize); ShareManageCommand = ReactiveCommand.Create(OpenShareManageWindow); OpenBrowserCommand = ReactiveCommand.CreateFromTask <string>(Browser2.OpenAsync); //MenuItems = new ObservableCollection<MenuItemViewModel>() //{ // new MenuItemViewModel (nameof(AppResources.Refresh)) // { IconKey="RefreshDrawing" , Command = RefreshCommand}, // new MenuItemSeparator (), // new MenuItemViewModel(nameof(AppResources.UserChange_LoginNewAccount)) // { IconKey="SteamDrawing", Command=LoginAccountCommand }, // new MenuItemViewModel(nameof(AppResources.AccountChange_Title)){ // IconKey ="ChannelShareDrawing", Command = ShareManageCommand }, // //new MenuItemViewModel(nameof(AppResources.UserChange_RemarkReplaceName)){ // // IconKey ="EditDrawing", Command = ShareManageCommand }, //}; _SteamUsersSourceList = new SourceCache <SteamUser, long>(t => t.SteamId64); _SteamUsersSourceList .Connect() .ObserveOn(RxApp.MainThreadScheduler) .Sort(SortExpressionComparer <SteamUser> .Descending(x => x.LastLoginTime)) .Bind(out _SteamUsers) .Subscribe(); }
protected override IObservable <IChangeSet <GroupedData <DateTime, AudioItem> > > GetObservableChangeSet() { return(ItemsSource .Connect() .Sort(SortExpressionComparer <AudioItem> .Descending(x => x.CreatedDateUtc)) .GroupOn(x => x.CreatedDateUtc.Date) .Transform(CreateAudioItemGroup)); }
public DisplaySetup() { _windows.Connect() .Sort(SortExpressionComparer <ProcessWindow> .Descending(window => window.ZOrder)) .ObserveOnDispatcher() .Bind(out var rooc).Subscribe(); Windows = rooc; }
public SortDynamicDataViewModel() { this.WhenActivated((CompositeDisposable disposables) => { _searchResultSource = new SourceList <RssEntry>().DisposeWith(disposables); var sorter = this.WhenAnyValue(x => x.SelectedSortType) .Select( SelectedSortType => { switch (SelectedSortType) { case SortType.DateTimeAscending: return(SortExpressionComparer <RssEntry> .Ascending(x => x.Updated)); case SortType.DateTimeDescending: return(SortExpressionComparer <RssEntry> .Descending(x => x.Updated)); case SortType.TitleAscending: return(SortExpressionComparer <RssEntry> .Ascending(x => x.Title)); case SortType.TitleDescending: default: return(SortExpressionComparer <RssEntry> .Descending(x => x.Title)); } }); _searchResultSource .Connect() .SubscribeOn(RxApp.TaskpoolScheduler) .Sort(sorter) .ObserveOn(RxApp.MainThreadScheduler) .Bind(out var searchResultsBinding) .Subscribe() .DisposeWith(disposables); this.SearchResults = searchResultsBinding; Search = ReactiveCommand .CreateFromTask( async(ct) => { var worldNews = await RssDownloader.DownloadRss("https://www.reddit.com/r/worldnews/new/.rss", ct).ConfigureAwait(false); _searchResultSource .Edit( innerList => { innerList.Clear(); innerList.AddRange(worldNews); }); }) .DisposeWith(disposables); }); }
public HistoryViewModel(WalletViewModel walletViewModel, IObservable <Unit> updateTrigger) { _walletViewModel = walletViewModel; _updateTrigger = updateTrigger; _transactionSourceList = new SourceList <HistoryItemViewModelBase>(); _transactions = new ObservableCollectionExtended <HistoryItemViewModelBase>(); _unfilteredTransactions = new ObservableCollectionExtended <HistoryItemViewModelBase>(); this.WhenAnyValue(x => x.UnfilteredTransactions.Count) .Subscribe(x => IsTransactionHistoryEmpty = x <= 0); _transactionSourceList .Connect() .ObserveOn(RxApp.MainThreadScheduler) .Sort(SortExpressionComparer <HistoryItemViewModelBase> .Descending(x => x.OrderIndex)) .Bind(_unfilteredTransactions) .Bind(_transactions) .Subscribe(); // [Column] [View] [Header] [Width] [MinWidth] [MaxWidth] [CanUserSort] // Indicators IndicatorsColumnView - Auto 80 - false // Date DateColumnView Date / Time Auto 150 - true // Labels LabelsColumnView Labels * 75 - false // Incoming IncomingColumnView Incoming (BTC) Auto 130 150 true // Outgoing OutgoingColumnView Outgoing (BTC) Auto 130 150 true // Balance BalanceColumnView Balance (BTC) Auto 130 150 true Source = new HierarchicalTreeDataGridSource <HistoryItemViewModelBase>(_transactions) { Columns = { // Indicators new HierarchicalExpanderColumn <HistoryItemViewModelBase>( new TemplateColumn <HistoryItemViewModelBase>( null, new FuncDataTemplate <HistoryItemViewModelBase>((node,ns) => new IndicatorsColumnView(), true), options: new ColumnOptions <HistoryItemViewModelBase> { CanUserResizeColumn = false, CanUserSortColumn = true, CompareAscending = HistoryItemViewModelBase.SortAscending(x => x.IsCoinJoin), CompareDescending = HistoryItemViewModelBase.SortDescending(x => x.IsCoinJoin), MinWidth = new GridLength(80, GridUnitType.Pixel) }, width: new GridLength(0, GridUnitType.Auto)), x => x.Children, x => { if (x is CoinJoinsHistoryItemViewModel coinJoinsHistoryItemViewModel && coinJoinsHistoryItemViewModel.CoinJoinTransactions.Count > 1) { return(true); } return(false); },
public NearToMarketViewer(INearToMarketService nearToMarketService) { _cleanUp = nearToMarketService.Query(() => NearToMarketPercent) .Transform(trade => new TradeProxy(trade)) .Sort(SortExpressionComparer <TradeProxy> .Descending(t => t.Timestamp)) .ObserveOnDispatcher() .Bind(_data) .DisposeMany() .Subscribe(); }
public NearToMarketViewer(INearToMarketService nearToMarketService, ISchedulerProvider schedulerProvider, ILogger logger) { _cleanUp = nearToMarketService.Query(() => NearToMarketPercent) .Transform(trade => new TradeProxy(trade)) .Sort(SortExpressionComparer <TradeProxy> .Descending(t => t.Timestamp)) .ObserveOn(schedulerProvider.MainThread) .Bind(out _data) .DisposeMany() .Subscribe(_ => {}, ex => logger.Error(ex, "Error in near to market viewer")); }
public TimeLineViewModel(ITwitterService twitterService = null) { _twitterService = twitterService ?? Locator.Current.GetService <ITwitterService>(); _twitterService.Tweets.Connect() .Transform(t => new TweetViewModel { Tweet = t }) .Sort(SortExpressionComparer <TweetViewModel> .Descending(c => c.Tweet.CreatedAt)) .Bind(out timeLine) .DisposeMany().Subscribe(); }
public RecentTradesViewer(ITradeService tradeService, ISchedulerProvider schedulerProvider) { _cleanUp = tradeService.All.Connect() .SkipInitial() .ExpireAfter((trade) => TimeSpan.FromSeconds(30)) .Transform(trade => new TradeProxy(trade)) .Sort(SortExpressionComparer <TradeProxy> .Descending(t => t.Timestamp), SortOptimisations.ComparesImmutableValuesOnly) .ObserveOn(schedulerProvider.MainThread) .Bind(out _data) // update observable collection bindings .DisposeMany() //since TradeProxy is disposable dispose when no longer required .Subscribe(); }
public TransactionsViewModel(IEthereumHostProvider ethereumHostProvider, CurrentAccountTransactionsService currentAccountTransactionsService) { this.currentAccountTransactionsService = currentAccountTransactionsService; this.currentAccountTransactionsService.Transactions.Connect() .Transform(transaction => new TransactionViewModel(transaction)) .AutoRefresh() .Sort(SortExpressionComparer <TransactionViewModel> .Descending(t => t.Status).ThenByDescending(t => t.BlockNumber)) .ObserveOn(RxApp.MainThreadScheduler) .Bind(out _transactions) .DisposeMany() .Subscribe(); }
public TradesByTime([NotNull] IGroup <Trade, long, TimePeriod> group, ISchedulerProvider schedulerProvider) { Period = group?.Key ?? throw new ArgumentNullException(nameof(group)); _cleanUp = group.Cache.Connect() .Transform(trade => new TradeProxy(trade)) .Sort(SortExpressionComparer <TradeProxy> .Descending(p => p.Timestamp), SortOptimisations.ComparesImmutableValuesOnly) .ObserveOn(schedulerProvider.MainThread) .Bind(out _data) .DisposeMany() .Subscribe(); }
public void Reset() { var people = Enumerable.Range(1, 100).Select(i => new Person("P" + i, i)).OrderBy(x => Guid.NewGuid()).ToArray(); _cache.AddOrUpdate(people); _sortController.Change(SortExpressionComparer <Person> .Descending(p => p.Age)); _sortController.Reset(); var expectedResult = people.OrderBy(p => p, _comparer).Select(p => new KeyValuePair <string, Person>(p.Name, p)).ToList(); var actualResult = _results.Messages[2].SortedItems.ToList(); actualResult.ShouldAllBeEquivalentTo(expectedResult); }
public void Reset() { var people = Enumerable.Range(1, 100).Select(i => new Person("P" + i, i)).OrderBy(x => Guid.NewGuid()).ToArray(); _cache.AddOrUpdate(people); _comparerObservable.OnNext(SortExpressionComparer <Person> .Descending(p => p.Age)); _comparerObservable.OnNext(_comparer); var expectedResult = people.OrderBy(p => p, _comparer).Select(p => new KeyValuePair <string, Person>(p.Name, p)).ToList(); var actualResult = _results.Messages[2].SortedItems.ToList(); CollectionAssert.AreEquivalent(expectedResult, actualResult); }
private bool _disposedValue = false; // To detect redundant calls public LoadWalletViewModel(WalletManagerViewModel owner, LoadWalletType loadWalletType) : base(loadWalletType == LoadWalletType.Password ? "Test Password" : "Load Wallet") { Global = Locator.Current.GetService <Global>(); Owner = owner; Password = ""; LoadWalletType = loadWalletType; this.ValidateProperty(x => x.Password, ValidatePassword); RootList = new SourceList <WalletViewModelBase>(); RootList.Connect() .AutoRefresh(model => model.WalletState) .Filter(x => (!IsPasswordRequired || !x.Wallet.KeyManager.IsWatchOnly)) .Sort(SortExpressionComparer <WalletViewModelBase> .Descending(p => p.Wallet.KeyManager.GetLastAccessTime()), resort: ResortTrigger.AsObservable()) .ObserveOn(RxApp.MainThreadScheduler) .Bind(out _wallets) .DisposeMany() .Subscribe() .DisposeWith(Disposables); Observable.FromEventPattern <Wallet>(Global.WalletManager, nameof(Global.WalletManager.WalletAdded)) .ObserveOn(RxApp.MainThreadScheduler) .Select(x => x.EventArgs) .Subscribe(wallet => RootList.Add(new WalletViewModelBase(wallet))) .DisposeWith(Disposables); this.WhenAnyValue(x => x.SelectedWallet) .Where(x => x is null) .ObserveOn(RxApp.MainThreadScheduler) .Subscribe(_ => SelectedWallet = Wallets.FirstOrDefault()); Wallets .ToObservableChangeSet() .ToCollection() .Where(items => items.Any() && SelectedWallet is null) .Select(items => items.First()) .ObserveOn(RxApp.MainThreadScheduler) .Subscribe(x => SelectedWallet = x); LoadCommand = ReactiveCommand.Create(() => RxApp.MainThreadScheduler .Schedule(async() => await LoadWalletAsync()) .DisposeWith(Disposables), this.WhenAnyValue(x => x.SelectedWallet, x => x?.WalletState) .Select(x => x == WalletState.Uninitialized)); TestPasswordCommand = ReactiveCommand.Create(LoadKeyManager, this.WhenAnyValue(x => x.SelectedWallet).Select(x => x is { }));
public MixerVM([NotNull] MixPalette palette, List <MixtureItemVM> mixture = null) { var percentSubject = new Subject <double>(); OK = CreateCommand(() => DialogResult = true); PaletteName = palette.Name; Components = new ObservableCollection <MixComponent>(palette.Components); var percentObs = percentSubject.Delay(TimeSpan.FromMilliseconds(300)) .Throttle(TimeSpan.FromMilliseconds(300)) .ObserveOnDispatcher() .Select(_ => Unit.Default); percentObs.Subscribe(s => CalcPercent()); var mixtureSrc = new SourceList <MixtureItemVM>(); mixtureSrc.Connect() .Sort(SortExpressionComparer <MixtureItemVM> .Descending(i => i.Percent), resort: percentObs) .ObserveOnDispatcher() .Bind(out var mixtureData) .Subscribe(); Mixture = mixtureData; AddComponemt = CreateCommand <MixComponent>(c => { if (mixtureSrc.Items.Any(m => m.Component == c)) { return; } Components.Remove(c); var item = new MixtureItemVM { Component = c }; item.WhenAnyValue(v => v.Percent).Skip(1).Subscribe(s => percentSubject.OnNext(s)); mixtureSrc.Add(item); CalcPercent(); }); DeleteComponent = CreateCommand <MixtureItemVM>(c => { mixtureSrc.Remove(c); Components.Add(c.Component); CalcPercent(); }); if (mixture?.Any() == true) { mixture.ToObservable().InvokeCommand(AddComponemt); } }
public ExchangeAccountViewModel(ExchangeAccount acc) { Account = acc; Account.Deposits.Connect() .Sort(SortExpressionComparer <Transfer> .Descending(x => x.Timestamp)) .ObserveOnDispatcher() .Bind(out deposits) .Subscribe() .DisposeWith(disposables); Account.Withdrawals.Connect() .Sort(SortExpressionComparer <Transfer> .Descending(x => x.Timestamp)) .ObserveOnDispatcher() .Bind(out withdrawals) .Subscribe() .DisposeWith(disposables); Account.OpenOrders.Connect() .Sort(SortExpressionComparer <Order> .Descending(x => x.Created)) .ObserveOnDispatcher() .Bind(out openOrders) .Subscribe() .DisposeWith(disposables); Account.OrdersHistory.Connect() .Sort(SortExpressionComparer <Order> .Descending(x => x.Created)) .Filter(x => CancelledOrdersVisible || x.Status != OrderStatus.Cancelled) .ObserveOnDispatcher() .Bind(out ordersHistory) .Subscribe() .DisposeWith(disposables); Account.TradesHistory.Connect() .Sort(SortExpressionComparer <OrderTrade> .Descending(x => x.Timestamp)) .ObserveOnDispatcher() .Bind(out tradesHistory) .Subscribe() .DisposeWith(disposables); Account.BalanceManager.Balances.Connect() .Sort(SortExpressionComparer <Balance> .Ascending(x => x.Asset)) .ObserveOnDispatcher() .Bind(out balances) .Subscribe() .DisposeWith(disposables); this.WhenAnyValue(x => x.Account.BalanceManager.TotalBtc) .ToPropertyEx(this, vm => vm.TotalBtc); this.WhenAnyValue(x => x.Account.BalanceManager.TotalUsd) .ToPropertyEx(this, vm => vm.TotalUsd); }
public void ChangeSort() { var people = _generator.Take(100).ToArray(); _cache.AddOrUpdate(people); var desc = SortExpressionComparer <Person> .Descending(p => p.Age).ThenByAscending(p => p.Name); _comparerObservable.OnNext(desc); var expectedResult = people.OrderBy(p => p, desc).Select(p => new KeyValuePair <string, Person>(p.Name, p)).ToList(); var actualResult = _results.Messages[0].SortedItems.ToList(); CollectionAssert.AreEquivalent(expectedResult, actualResult); }
/// <summary> /// Initializes a new instance of the <see cref="TagViewModel"/> class. /// </summary> public TagViewModel() { IObservable <bool> isValidRepository = this.WhenAnyValue(x => x.RepositoryDetails).Select(details => details != null); this.refresh = ReactiveCommand.CreateFromObservable(this.RefreshImpl, isValidRepository); this.refresh.ToObservableChangeSet() .Sort(SortExpressionComparer <GitTag> .Descending(p => p.DateTime), SortOptions.UseBinarySearch) .ObserveOn(RxApp.MainThreadScheduler) .Bind(out this.tags) .Subscribe(); this.selectedGitTag = this.WhenAnyValue(x => x.SelectedGitObject).Select(x => x as GitTag).ToProperty(this, x => x.SelectedTag, out this.selectedGitTag); }