private void UpdateIsCurrentPageBookmarked()
{
if (_bookmarks != null)
{
IsCurrentPageBookmarked = _bookmarks.Any(bookmark => bookmark.PageNumber == CurrentPageNumber);
}
}
public VideoViewModel(IRegionProvider RegionProvider,
IEnumerable <IImageWriterItem> ImageWriters,
Settings Settings,
LanguageManager LanguageManager,
FullScreenSourceProvider FullScreenProvider,
IIconSet Icons,
// ReSharper disable SuggestBaseTypeForParameter
ScreenSourceProvider ScreenSourceProvider,
WindowSourceProvider WindowSourceProvider,
RegionSourceProvider RegionSourceProvider,
NoVideoSourceProvider NoVideoSourceProvider,
DeskDuplSourceProvider DeskDuplSourceProvider,
FFmpegWriterProvider FFmpegWriterProvider,
SharpAviWriterProvider SharpAviWriterProvider,
GifWriterProvider GifWriterProvider,
StreamingWriterProvider StreamingWriterProvider,
DiscardWriterProvider DiscardWriterProvider
// ReSharper restore SuggestBaseTypeForParameter
) : base(Settings, LanguageManager)
{
this.NoVideoSourceProvider = NoVideoSourceProvider;
AvailableVideoWriters = new ReadOnlyObservableCollection <IVideoWriterItem>(_videoWriters);
AvailableImageWriters = new ReadOnlyObservableCollection <IImageWriterItem>(_imageWriters);
_regionProvider = RegionProvider;
_fullScreenProvider = FullScreenProvider;
VideoSources.Add(new VideoSourceModel(NoVideoSourceProvider, nameof(Loc.OnlyAudio), NoVideoDescription, Icons.Video));
VideoSources.Add(new VideoSourceModel(FullScreenProvider, nameof(Loc.FullScreen), FullScreenDescription, Icons.MultipleMonitor));
VideoSources.Add(new VideoSourceModel(ScreenSourceProvider, nameof(Loc.Screen), ScreenDescription, Icons.Screen));
VideoSources.Add(new VideoSourceModel(WindowSourceProvider, nameof(Loc.Window), WindowDescription, Icons.Window));
VideoSources.Add(new VideoSourceModel(RegionSourceProvider, nameof(Loc.Region), RegionDescription, Icons.Region));
if (Windows8OrAbove)
{
VideoSources.Add(new VideoSourceModel(DeskDuplSourceProvider, "Desktop Duplication", DeskDuplDescription, Icons.Game));
}
VideoWriterProviders.Add(FFmpegWriterProvider);
VideoWriterProviders.Add(GifWriterProvider);
VideoWriterProviders.Add(SharpAviWriterProvider);
VideoWriterProviders.Add(StreamingWriterProvider);
VideoWriterProviders.Add(DiscardWriterProvider);
foreach (var imageWriter in ImageWriters)
{
_imageWriters.Add(imageWriter);
}
SetDefaultSource();
if (!AvailableImageWriters.Any(M => M.Active))
{
AvailableImageWriters[0].Active = true;
}
SelectedVideoWriterKind = FFmpegWriterProvider;
}
private void AddTracks(List<ITrack> tracks, ReadOnlyObservableCollection<object> group)
{
if (group.Any())
if (group[0] is ITrack)
tracks.AddRange(group.Cast<ITrack>());
else
foreach (CollectionViewGroup item in group)
AddTracks(tracks, item.Items);
}
public static ReadOnlyObservableCollection <IPatch> GetPatches(bool forceReload = false)
{
if (forceReload || !Patches.Any())
{
LoadPatches();
}
return(Patches);
}
public void Load(Guid id)
{
if (_nodes.Any())
{
return;
}
IsLoading = true;
_dataObjectService.Load(id, () => IsLoading = false);
}
public BookmarksViewModel(History history)
{
_selectedItems = new ObservableCollection <HistoryViewItem>();
SelectedItems = new ReadOnlyObservableCollection <HistoryViewItem>(_selectedItems);
DeleteBookmarksCommand = new Command(
p => DeleteBookmarks(),
p => SelectedItems.Any(item => item.HistoryEvent is BookmarkHistoryEvent)
);
DeleteBranchesCommand = new Command(
p => DeleteBranches(),
p => SelectedItems.Any(item => !(item.HistoryEvent.Children.Count != 0 || item.HistoryEvent == _history.CurrentEvent || item.HistoryEvent is RootHistoryEvent))
);
_history = history;
Items = new ObservableCollection <HistoryViewItem>();
RefreshHistoryViewItems();
}
public static bool ExcludeField(IField field, ReadOnlyObservableCollection <IFilter> fieldFilters)
{
if (field == null)
{
throw new ArgumentNullException(nameof(field));
}
if (fieldFilters == null)
{
throw new ArgumentNullException(nameof(fieldFilters));
}
return(fieldFilters.Count > 0 && fieldFilters.Any(m => m.Exclude(field)));
}
public MediaItemsViewModel(MediaDownloadSource source)
{
source
.Connect()
.Transform(ms => new MediaViewItem(ms.Media))
.ObserveOn(RxApp.MainThreadScheduler)
.Bind(out items)
.DisposeMany()
.Subscribe();
CanDownload = this
.WhenAnyValue(x => x.MediaItems.Count)
.Select(count => count > 0 && items.Any(x => x.IsDownloadable()));
}
private async Task LoadMessages(Type viewModel)
{
if (viewModel.Name != "MainPageViewModel")
{
return;
}
if (_messageCollection.Any())
{
return;
}
var messages = await _mailKitApiManager.GetAllMessagesAsync();
Messages.AddRange(ConvertToViewModel(messages));
}
public VideoViewModel(IRegionProvider RegionProvider,
IEnumerable <IImageWriterItem> ImageWriters,
IEnumerable <IVideoWriterProvider> VideoWriterProviders,
IEnumerable <IVideoSourceProvider> VideoSourceProviders,
Settings Settings,
LanguageManager LanguageManager) : base(Settings, LanguageManager)
{
AvailableVideoWriterKinds = new ReadOnlyObservableCollection <IVideoWriterProvider>(_videoWriterKinds);
AvailableVideoWriters = new ReadOnlyObservableCollection <IVideoWriterItem>(_videoWriters);
AvailableVideoSourceKinds = new ReadOnlyObservableCollection <IVideoSourceProvider>(_videoSourceKinds);
AvailableVideoSources = new ReadOnlyObservableCollection <IVideoItem>(_videoSources);
AvailableImageWriters = new ReadOnlyObservableCollection <IImageWriterItem>(_imageWriters);
_regionProvider = RegionProvider;
foreach (var imageWriter in ImageWriters)
{
_imageWriters.Add(imageWriter);
}
foreach (var videoWriterProvider in VideoWriterProviders)
{
_videoWriterKinds.Add(videoWriterProvider);
}
foreach (var videoSourceProvider in VideoSourceProviders)
{
_videoSourceKinds.Add(videoSourceProvider);
}
if (!AvailableImageWriters.Any(M => M.Active))
{
AvailableImageWriters[0].Active = true;
}
if (AvailableVideoWriterKinds.Count > 0)
{
SelectedVideoWriterKind = AvailableVideoWriterKinds[0];
}
if (AvailableVideoSourceKinds.Count > 0)
{
SelectedVideoSourceKind = AvailableVideoSourceKinds[0];
}
}
// this helper sets properties and raises events in the same order as System.Controls.Validation
private static void UpdateErrorsAndHasErrors(
DependencyObject dependencyObject,
IEnumerable <ValidationError> removedErrors,
IEnumerable <ValidationError> addedErrors,
ReadOnlyObservableCollection <ValidationError> errors)
{
if (errors.Any())
{
SetErrors(dependencyObject, errors);
SetHasError(dependencyObject, true);
}
else
{
SetHasError(dependencyObject, false);
SetErrors(dependencyObject, ErrorCollection.EmptyValidationErrors);
}
// ReSharper disable PossibleMultipleEnumeration
var removed = removedErrors.Except(addedErrors).AsReadOnly();
var added = addedErrors.Except(removedErrors).AsReadOnly();
if (added.Count == 0 && removed.Count == 0)
{
return;
}
dependencyObject.UpdateParent(removed, added);
(dependencyObject as UIElement)?.RaiseEvent(new ErrorsChangedEventArgs(removed, added));
(dependencyObject as ContentElement)?.RaiseEvent(new ErrorsChangedEventArgs(removed, added));
foreach (var error in removed)
{
(dependencyObject as UIElement)?.RaiseEvent(new ScopeValidationErrorEventArgs(error, ValidationErrorEventAction.Removed));
(dependencyObject as ContentElement)?.RaiseEvent(new ScopeValidationErrorEventArgs(error, ValidationErrorEventAction.Removed));
}
foreach (var error in added)
{
(dependencyObject as UIElement)?.RaiseEvent(new ScopeValidationErrorEventArgs(error, ValidationErrorEventAction.Added));
(dependencyObject as ContentElement)?.RaiseEvent(new ScopeValidationErrorEventArgs(error, ValidationErrorEventAction.Added));
}
// ReSharper restore PossibleMultipleEnumeration
}
public BoxImportSchemeViewModel()
{
_boardsSource = new SourceList <BoardImportSchemeViewModel>();
_columnsSource = new SourceList <ColumnImportSchemeViewModel>();
_rowsSource = new SourceList <RowImportSchemeViewModel>();
var boardsPublish = _boardsSource.Connect()
.ObserveOnDispatcher()
.Publish();
boardsPublish
.Count()
.Subscribe(x => HasBoards = x > 0);
boardsPublish
.Bind(out _boards)
.Subscribe();
boardsPublish
.WhenPropertyChanged(x => x.IsSelected)
.Subscribe(x =>
IsAllBoardsSelected = _boards.All(b => b.IsSelected)
? true
: _boards.Any(b => b.IsSelected)
? (bool?)null
: false);
boardsPublish.Connect();
var selectedBoardChanged = this.WhenAnyValue(x => x.SelectedBoard).Publish();
var columnsPublish = _columnsSource.Connect()
.Filter(selectedBoardChanged.Select(CreateColumnPredicate))
.ObserveOnDispatcher()
.Publish();
columnsPublish
.Count()
.Subscribe(x => HasColumns = x > 0);
columnsPublish
.Bind(out _columns)
.Subscribe();
columnsPublish
.WhenPropertyChanged(x => x.IsSelected)
.Subscribe(x =>
IsAllColumnsSelected = _columns.All(c => c.IsSelected)
? true
: _columns.Any(c => c.IsSelected)
? (bool?)null
: false);
columnsPublish.Connect();
var rowsPublish = _rowsSource.Connect()
.Filter(selectedBoardChanged.Select(CreateRowPredicate))
.ObserveOnDispatcher()
.Publish();
rowsPublish
.Count()
.Subscribe(x => HasRows = x > 0);
rowsPublish
.Bind(out _rows)
.Subscribe();
rowsPublish
.WhenPropertyChanged(x => x.IsSelected)
.Subscribe(x =>
IsAllRowsSelected = _rows.All(r => r.IsSelected)
? true
: _rows.Any(r => r.IsSelected)
? (bool?)null
: false);
rowsPublish.Connect();
selectedBoardChanged.Connect();
AllBoardsSelectionCommand = ReactiveCommand.Create <bool?>(x =>
{
foreach (var board in _boards)
{
board.IsSelected = board.IsEnabled && x.HasValue && x.Value;
}
});
AllColumnsSelectionCommand = ReactiveCommand.Create <bool?>(x =>
{
foreach (var column in _columns)
{
column.IsSelected = x.HasValue && x.Value;
}
});
AllRowsSelectionCommand = ReactiveCommand.Create <bool?>(x =>
{
foreach (var row in _rows)
{
row.IsSelected = x.HasValue && x.Value;
}
});
}
// this helper sets properties and raises events in the same order as System.Controls.Validation
private static void UpdateErrorsAndHasErrors(
DependencyObject dependencyObject,
IEnumerable<ValidationError> removedErrors,
IEnumerable<ValidationError> addedErrors,
ReadOnlyObservableCollection<ValidationError> errors)
{
if (errors.Any())
{
SetErrors(dependencyObject, errors);
SetHasError(dependencyObject, true);
}
else
{
SetHasError(dependencyObject, false);
SetErrors(dependencyObject, ErrorCollection.EmptyValidationErrors);
}
// ReSharper disable PossibleMultipleEnumeration
var removed = removedErrors.Except(addedErrors).AsReadOnly();
var added = addedErrors.Except(removedErrors).AsReadOnly();
if (added.Count == 0 && removed.Count == 0)
{
return;
}
dependencyObject.UpdateParent(removed, added);
(dependencyObject as UIElement)?.RaiseEvent(new ErrorsChangedEventArgs(removed, added));
(dependencyObject as ContentElement)?.RaiseEvent(new ErrorsChangedEventArgs(removed, added));
foreach (var error in removed)
{
(dependencyObject as UIElement)?.RaiseEvent(new ScopeValidationErrorEventArgs(error, ValidationErrorEventAction.Removed));
(dependencyObject as ContentElement)?.RaiseEvent(new ScopeValidationErrorEventArgs(error, ValidationErrorEventAction.Removed));
}
foreach (var error in added)
{
(dependencyObject as UIElement)?.RaiseEvent(new ScopeValidationErrorEventArgs(error, ValidationErrorEventAction.Added));
(dependencyObject as ContentElement)?.RaiseEvent(new ScopeValidationErrorEventArgs(error, ValidationErrorEventAction.Added));
}
// ReSharper restore PossibleMultipleEnumeration
}
public override bool CanExecute()
{
return(_groceryItems.Any(g => g.IsInCart));
}
