private RadialMenuCommand CreateKnownCommand(CommandId id)
{
RadialMenuCommand command = null;
switch (id)
{
case CommandId.Open:
command = new OpenMenuCommand();
break;
case CommandId.Close:
command = new CloseMenuCommand();
break;
case CommandId.NavigateToView:
command = new NavigateCommand();
break;
case CommandId.NavigateBack:
command = new NavigateBackCommand();
break;
default:
throw new ArgumentException("Unknown command id!", "id");
}
command.Id = id;
command.Owner = this.Owner;
return(command);
}
protected virtual void OnLoggedIn(RequestSecurityTokenResponse requestSecurityTokenResponse)
{
if (requestSecurityTokenResponse == null)
{
Mvx.TaggedTrace(MvxTraceLevel.Error, "DefaultIdentityProviderCollectionViewModel", "Got an empty response from IdentityProvider");
if (LoginError != null)
{
LoginError(this, new LoginErrorEventArgs {
Message = "Got an empty response from IdentityProvider, try logging in again."
});
}
return;
}
var tokenStore = Mvx.Resolve <ISimpleWebTokenStore>();
var tokenFactory = Mvx.Resolve <ISimpleWebToken>();
var token = tokenFactory.CreateTokenFromRaw(requestSecurityTokenResponse.SecurityToken);
tokenStore.SimpleWebToken = token;
if (!CanGoBack)
{
ShowProgressAfterLogin = true;
}
RaisePropertyChanged(() => IsLoggedIn);
RaisePropertyChanged(() => LoggedInProvider);
if (tokenStore.IsValid() && CanGoBack)
{
NavigateBackCommand.Execute(null);
}
}
protected virtual void AssumeCancelled()
{
RaisePropertyChanged(() => IsLoggedIn);
RaisePropertyChanged(() => LoggedInProvider);
NavigateBackCommand.Execute(null);
}
public void Execute(NavigateBackCommand command)
{
Profiler.BeginSample("Load Navigation Step");
var navHistoryItems = Repository.All <NavHistoryItem>().ToList();
var activeHistoryItem = navHistoryItems.FirstOrDefault(i => i.IsActive);
if (activeHistoryItem == null)
{
return;
}
var closesHistoryItem = navHistoryItems.Where(i => i.Time < activeHistoryItem.Time).OrderByDescending(i => i.Time).FirstOrDefault();
if (closesHistoryItem == null)
{
return;
}
activeHistoryItem.IsActive = false;
closesHistoryItem.IsActive = true;
Execute(new NavigateCommand()
{
ItemId = closesHistoryItem.ItemId,
GraphId = closesHistoryItem.GraphId,
Workspaceid = closesHistoryItem.WorkspaceId,
FilterId = closesHistoryItem.FilterId,
Scroll = closesHistoryItem.Scroll,
});
_saveOnNextUpdate = false;
Profiler.EndSample();
// var filter =
// Repository.AllOf<IGraphFilter>().Where(f => f.Identifier == closesHistoryItem.FilterId).FirstOrDefault();
//
}
public AutoLogEntryViewModel(
NavigateBackCommand navigateBackCommand, IEventAggregator eventAggregator,
LogbookService logbookService)
{
_navigateBackCommand = navigateBackCommand;
_eventAggregator = eventAggregator;
_logbookService = logbookService;
}
public ManualEntryViewModel(
NavigateBackCommand navigateBackCommand, IEventAggregator eventAggregator,
LogbookService logbookService)
{
_navigateBackCommand = navigateBackCommand;
_eventAggregator = eventAggregator;
_logbookService = logbookService;
_eventAggregator.GetEvent <PubSubEvent <LocationSelectedEvent> >().Subscribe(OnMapLocationChanged);
}
public SettingsViewModel(
NavigateBackCommand navigateBackCommand,
ISettingsService settingsService)
{
_navigateBackCommand = navigateBackCommand;
_settingsService = settingsService;
XPlaneRootPath = Properties.Settings.Default.XPlaneRootPath;
DataPath = Properties.Settings.Default.DataPath;
}
public RouteEditorViewModel(
NavigateBackCommand navigateBackCommand, IAircraftService aircraftService,
IEventAggregator eventAggregator)
{
_navigateBackCommand = navigateBackCommand;
_aircraftService = aircraftService;
_eventAggregator = eventAggregator;
_eventAggregator.GetEvent <PubSubEvent <LocationSelectedEvent> >().Subscribe(OnLocationSelected);
}
/// <summary>
/// Initialisiert eine neue Instanz der <see cref="T:System.Object" />-Klasse.
/// </summary>
public LogListViewModel(
NavigateBackCommand navigateBackCommand, ShowManualEntryCommand showManualEntryCommand, ILogbookService logbookService,
IEventAggregator eventAggregator, IAircraftService aircraftService,
ShowAutoEntryCommand showAutoEntryCommand)
{
_navigateBackCommand = navigateBackCommand;
_showManualEntryCommand = showManualEntryCommand;
_logbookService = logbookService;
_eventAggregator = eventAggregator;
_aircraftService = aircraftService;
_showAutoEntryCommand = showAutoEntryCommand;
}
public FooterViewModel(NavigationStore navigationStore,
UserInterfaceManager userInterfaceManager)
{
_navigationStore = navigationStore;
_navigationStore.HistoryViewModelsUpdated += OnHistoryViewModelsUpdated;
_userInterfaceManager = userInterfaceManager;
_userInterfaceManager.ThemeUpdated += OnThemeUpdated;
NavigateBackCommand = new NavigateBackCommand(_navigationStore);
Recalc();
StartTimer();
}
private void RefreshPage()
{
DeregisterPageEvents();
Page = Frame.Content as ApplicationPage;
RefreshPageDataContext();
RefreshTitleBarTemplateSelector();
RefreshTitleTemplate();
RefreshTitleControlsTemplate();
RefreshTitleElementSizes();
GoBackCommand.RaiseCanExecuteChanged();
NavigateBackCommand.RaiseCanExecuteChanged();
NavigateForwardCommand.RaiseCanExecuteChanged();
RegisterPageEvents();
}
private async void ChangePassword()
{
var isSuccess = await _fitMeetRestService.ChangePasswordAsync(Password);
if (isSuccess)
{
await _dialogService.DisplayAlertAsync("Success", "Your password has changed", "Ok");
NavigateBackCommand?.Execute();
}
else
{
await _dialogService.DisplayAlertAsync("Error", "There are some problem with our server, please try again later", "Ok");
}
}
private async void FindPassword()
{
var isSuccess = await _fitMeetRestService.ResetPasswordAsync(Email);
if (isSuccess)
{
await _dialogService.DisplayAlertAsync("Success", "Please check your email", "Go back to login page");
NavigateBackCommand?.Execute();
}
else
{
await _dialogService.DisplayAlertAsync("Error", "There are some problem with our server, please try again later", "Ok");
}
}
private void RegisterFrameEvents()
{
Frame.ContentChanged += Frame_ContentChanged;
Frame.RegisterPropertyChangedCallback(Windows.UI.Xaml.Controls.Frame.CanGoBackProperty, (s, e) =>
{
GoBackCommand.RaiseCanExecuteChanged();
NavigateBackCommand.RaiseCanExecuteChanged();
});
Frame.RegisterPropertyChangedCallback(Windows.UI.Xaml.Controls.Frame.CanGoForwardProperty, (s, e) =>
{
NavigateForwardCommand.RaiseCanExecuteChanged();
});
//Frame.Navigated += Frame_Navigated;
//Frame.Loaded += Frame_Loaded;
}
public DefaultIdentityProviderCollectionViewModel(IIdentityProviderClient client, ISimpleWebTokenStore store,
ILoginIdentityProviderTask loginIdentityProviderTask, IMvxMessenger messenger)
{
_messenger = messenger;
_simpleWebTokenStore = store;
_loginIdentityProviderTask = loginIdentityProviderTask;
_identityProviderClient = client;
RaisePropertyChanged(() => IsLoggedIn);
RaisePropertyChanged(() => LoggedInProvider);
_closeSelfToken = messenger.Subscribe <CloseSelfMessage>(message =>
{
if (message.Close)
{
NavigateBackCommand.Execute(null);
}
});
}
protected async Task HandleViewCommandAsync(ViewCommand command)
{
try
{
if (command == null)
{
return;
}
if (command is ReturnCommand)
{
if (_previousParameterCommand != null)
{
command = _previousParameterCommand;
}
else
{
command = new NavigateBackCommand();
}
}
switch (command)
{
case NavigateCommand navigateCommand:
UriHelper.NavigateTo(navigateCommand.Uri);
break;
case NavigateBackCommand navigateBackCommand:
// TODO: improve this
await JSRuntime.InvokeAsync <bool>("history.back");
break;
case UpdateParameterCommand parameterCommand:
_previousParameterCommand = new UpdateParameterCommand
{
Action = Action,
CollectionAlias = CollectionAlias,
Id = Id,
ParentId = ParentId,
VariantAlias = VariantAlias
};
var data = new Dictionary <string, object>()
{
{ "Action", parameterCommand.Action },
{ "CollectionAlias", parameterCommand.CollectionAlias }
};
if (parameterCommand.VariantAlias != null)
{
data.Add("VariantAlias", parameterCommand.VariantAlias);
}
if (parameterCommand.Id != null)
{
data.Add("Id", parameterCommand.Id);
}
if (parameterCommand.ParentId != null)
{
data.Add("ParentId", parameterCommand.ParentId);
}
var update = ParameterView.FromDictionary(data);
await SetParametersAsync(update);
break;
case ReloadCommand reloadCommand:
await LoadDataAsync(reloadCommand.EntityId);
break;
case NoOperationCommand _:
default:
StateHasChanged();
break;
}
}
catch (Exception ex)
{
HandleException(ex);
}
}
public MediaFileBrowserViewModel(MediaFileWatcher mediaFileWatcher, IRegionManager regionManager, IEventAggregator eventAggregator)
{
MediaFileWatcher = mediaFileWatcher;
RegionManager = regionManager;
EventAggregator = eventAggregator;
MediaFileGridViewModel = new MediaFileGridViewModel(mediaFileWatcher.MediaFileState, EventAggregator);
ImageViewModel = new MediaFileBrowserImagePanelViewModel(eventAggregator);
ImageViewModel.SelectedScaleMode = MediaViewer.UserControls.ImagePanel.ScaleMode.FIT_HEIGHT_AND_WIDTH;
imageMediaStackPanelViewModel = new MediaFileStackPanelViewModel(MediaFileGridViewModel.MediaStateCollectionView, EventAggregator);
imageMediaStackPanelViewModel.IsVisible = true;
VideoViewModel = new VideoPanel.VideoViewModel(EventAggregator);
videoMediaStackPanelViewModel = new MediaFileStackPanelViewModel(MediaFileGridViewModel.MediaStateCollectionView, EventAggregator);
videoMediaStackPanelViewModel.IsVisible = true;
GeotagFileBrowserViewModel = new GeotagFileBrowserViewModel(MediaFileGridViewModel.MediaStateCollectionView, EventAggregator);
GeotagFileBrowserStackPanelViewModel = new MediaFileStackPanelViewModel(MediaFileGridViewModel.MediaStateCollectionView, EventAggregator);
GeotagFileBrowserStackPanelViewModel.IsVisible = true;
DeleteSelectedItemsCommand = new Command(new Action(deleteSelectedItems));
ImportSelectedItemsCommand = new Command(() =>
{
ImportView import = new ImportView();
import.DataContext = new ImportViewModel(MediaFileWatcher.Instance);
import.ShowDialog();
});
ExportSelectedItemsCommand = new Command(() =>
{
ImportView export = new ImportView();
export.DataContext = new ExportViewModel(MediaFileWatcher.Instance);
export.ShowDialog();
});
ExpandCommand = new Command <MediaFileItem>((item) =>
{
if (item == null)
{
if (SelectedItems.Count == 0)
{
return;
}
item = SelectedItems.ElementAt(0) as MediaFileItem;
}
if (item.Metadata is ImageMetadata)
{
navigateToImageView(item);
}
else if (item.Metadata is VideoMetadata ||
item.Metadata is AudioMetadata)
{
navigateToVideoView(item);
}
});
ContractCommand = new Command(() =>
{
NavigateBackCommand.Execute(null);
});
ContractCommand.IsExecutable = false;
NavigateToGeotagFileBrowserCommand = new Command(() =>
{
navigateToGeotagFileBrowser();
});
CreateImageCollageCommand = new Command(() =>
{
if (SelectedItems.Count == 0)
{
return;
}
ImageCollageView collage = new ImageCollageView();
collage.ViewModel.Media = SelectedItems;
collage.ShowDialog();
});
TranscodeVideoCommand = new Command(() =>
{
if (SelectedItems.Count == 0)
{
return;
}
VideoTranscodeView transcode = new VideoTranscodeView();
List <VideoAudioPair> items = new List <VideoAudioPair>();
foreach (MediaItem item in SelectedItems)
{
items.Add(new VideoAudioPair(item));
}
transcode.ViewModel.Items = items;
transcode.ViewModel.OutputPath = MediaFileWatcher.Path;
transcode.ShowDialog();
});
TranscodeImageCommand = new Command(() =>
{
if (SelectedItems.Count == 0)
{
return;
}
ImageTranscodeView transcode = new ImageTranscodeView();
transcode.ViewModel.Items = SelectedItems;
transcode.ViewModel.OutputPath = MediaFileWatcher.Path;
transcode.ShowDialog();
});
CreateVideoPreviewImagesCommand = new Command(() =>
{
if (SelectedItems.Count == 0)
{
return;
}
VideoPreviewImageView preview = new VideoPreviewImageView();
preview.ViewModel.Media = SelectedItems;
preview.ShowDialog();
});
CreateTorrentFileCommand = new Command(() =>
{
//if (SelectedItems.Count == 0) return;
try
{
TorrentCreationView torrent = new TorrentCreationView();
torrent.ViewModel.PathRoot = mediaFileWatcher.Path;
torrent.ViewModel.Media = new ObservableCollection <MediaFileItem>(SelectedItems);
torrent.ShowDialog();
}
catch (Exception e)
{
MessageBox.Show(e.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
});
NavigateToMediaFileGridCommand = new Command(navigateToMediaFileGrid);
NavigateToImageViewCommand = new Command <MediaFileItem>(navigateToImageView);
NavigateToVideoViewCommand = new Command <MediaFileItem>(navigateToVideoView);
NavigateBackCommand = NavigateToMediaFileGridCommand;
SelectedItems = new List <MediaFileItem>();
EventAggregator.GetEvent <MediaSelectionEvent>().Subscribe(mediaFileBrowser_MediaSelectionEvent);
}
