private async void AddProfileAction()
{
CustomDialog customDialog = new CustomDialog()
{
Title = LocalizationManager.GetStringByKey("String_Header_AddProfile")
};
TracerouteProfileViewModel tracerouteProfileViewModel = new TracerouteProfileViewModel(instance =>
{
dialogCoordinator.HideMetroDialogAsync(this, customDialog);
TracerouteProfileInfo tracerouteProfileInfo = new TracerouteProfileInfo
{
Name = instance.Name,
Host = instance.Host,
Group = instance.Group,
Tags = instance.Tags
};
TracerouteProfileManager.AddProfile(tracerouteProfileInfo);
}, instance =>
{
dialogCoordinator.HideMetroDialogAsync(this, customDialog);
}, TracerouteProfileManager.GetProfileGroups());
customDialog.Content = new TracerouteProfileDialog
{
DataContext = tracerouteProfileViewModel
};
await dialogCoordinator.ShowMetroDialogAsync(this, customDialog);
}
private async void AddProfileAction()
{
CustomDialog customDialog = new CustomDialog()
{
Title = Application.Current.Resources["String_Header_AddProfile"] as string
};
IPScannerProfileViewModel ipScannerProfileViewModel = new IPScannerProfileViewModel(instance =>
{
dialogCoordinator.HideMetroDialogAsync(this, customDialog);
IPScannerProfileInfo ipScannerProfileInfo = new IPScannerProfileInfo
{
Name = instance.Name,
IPRange = instance.IPRange,
Group = instance.Group
};
IPScannerProfileManager.AddProfile(ipScannerProfileInfo);
}, instance =>
{
dialogCoordinator.HideMetroDialogAsync(this, customDialog);
}, IPScannerProfileManager.GetProfileGroups(), new IPScannerProfileInfo()
{
IPRange = IPRange
});
customDialog.Content = new IPScannerProfileDialog
{
DataContext = ipScannerProfileViewModel
};
await dialogCoordinator.ShowMetroDialogAsync(this, customDialog);
}
private async void AddProfileAction()
{
CustomDialog customDialog = new CustomDialog()
{
Title = LocalizationManager.GetStringByKey("String_Header_AddProfile")
};
PortScannerProfileViewModel portScannerProfileViewModel = new PortScannerProfileViewModel(instance =>
{
dialogCoordinator.HideMetroDialogAsync(this, customDialog);
PortScannerProfileInfo portScannerProfileInfo = new PortScannerProfileInfo
{
Name = instance.Name,
Hostname = instance.Hostname,
Ports = instance.Ports,
Group = instance.Group
};
PortScannerProfileManager.AddProfile(portScannerProfileInfo);
}, instance =>
{
dialogCoordinator.HideMetroDialogAsync(this, customDialog);
}, PortScannerProfileManager.GetProfileGroups());
customDialog.Content = new PortScannerProfileDialog
{
DataContext = portScannerProfileViewModel
};
await dialogCoordinator.ShowMetroDialogAsync(this, customDialog);
}
/// <summary>
/// Manage an exception
/// </summary>
/// <param name="exception">The exception to manage</param>
private void ManageException(Exception exception)
{
if (_isManagingException)
{
return;
}
_isManagingException = true;
IsMovieFlyoutOpen = false;
IsSettingsFlyoutOpen = false;
if (exception is WebException || exception is SocketException)
{
ApplicationState.IsConnectionInError = true;
}
DispatcherHelper.CheckBeginInvokeOnUI(async() =>
{
var exceptionDialog =
new ExceptionDialog(
new ExceptionDialogSettings(
LocalizationProviderHelper.GetLocalizedValue <string>("EmbarrassingError"), exception.Message));
await _dialogCoordinator.ShowMetroDialogAsync(this, exceptionDialog);
await exceptionDialog.WaitForButtonPressAsync();
_isManagingException = false;
await _dialogCoordinator.HideMetroDialogAsync(this, exceptionDialog);
});
}
private async void OpenOfferSettingsDialog(Action <CompanyInfoDialogViewModel> closeHandler, Action <CompanyInfoDialogViewModel> completionHandler)
{
var dialogViewModel = new CompanyInfoDialogViewModel(closeHandler, completionHandler);
_customDialog.Content = new CompanyInfoDialogView {
DataContext = dialogViewModel
};
await _dialogCoordinator.ShowMetroDialogAsync(this, _customDialog);
}
private async void AddProfileAction()
{
CustomDialog customDialog = new CustomDialog()
{
Title = LocalizationManager.GetStringByKey("String_Header_AddProfile")
};
ProfileViewModel profileViewModel = new ProfileViewModel(instance =>
{
dialogCoordinator.HideMetroDialogAsync(this, customDialog);
ConfigurationManager.Current.IsDialogOpen = false;
ProfileManager.AddProfile(instance);
}, instance =>
{
dialogCoordinator.HideMetroDialogAsync(this, customDialog);
ConfigurationManager.Current.IsDialogOpen = false;
}, ProfileManager.GetGroups());
customDialog.Content = new ProfileDialog
{
DataContext = profileViewModel
};
ConfigurationManager.Current.IsDialogOpen = true;
await dialogCoordinator.ShowMetroDialogAsync(this, customDialog);
}
public static async Task ShowEditGroupDialog(IProfileManager viewModel, IDialogCoordinator dialogCoordinator, string group)
{
var customDialog = new CustomDialog
{
Title = Localization.Resources.Strings.EditGroup
};
var editGroupViewModel = new GroupViewModel(async instance =>
{
await dialogCoordinator.HideMetroDialogAsync(viewModel, customDialog);
viewModel.OnProfileDialogClose();
ProfileManager.RenameGroup(instance.OldGroup, instance.Group);
viewModel.RefreshProfiles();
}, async instance =>
{
await dialogCoordinator.HideMetroDialogAsync(viewModel, customDialog);
viewModel.OnProfileDialogClose();
}, group, ProfileManager.GetGroups());
customDialog.Content = new GroupDialog
{
DataContext = editGroupViewModel
};
viewModel.OnProfileDialogOpen();
await dialogCoordinator.ShowMetroDialogAsync(viewModel, customDialog);
}
public async void showCreateSphereDialog()
{
Console.WriteLine("MainWindowViewModel@createSphere | create sphere in view model");
var dialog = new CreateSphereDialog();
dialog.Height = 300;
dialog.Width = 400;
var dialogViewModel = new CreateSphereDialogViewModel(async instance =>
{
Console.WriteLine("MainWindowViewModel@createSphere | closing dialog");
await _dialogCoordinator.HideMetroDialogAsync(this, dialog);
//instance --> dialog ViewModel
//if (!(instance.Cancel || String.IsNullOrEmpty(instance.UserInput)) ProcessUserInput(instance.UserInput);
if (!instance.Cancel)
{
Console.WriteLine("MainWindowViewModel@createSphere | generating sphere ( name {0}, radius {1}, accuracy {2}, color {3}", instance.name, instance.radius, instance.accuracy, instance.color);
generateSphere(instance.color, instance.radius, instance.accuracy, instance.name);
}
});
dialogViewModel.MessageText = "SPHERE CONFIGURATION";
dialog.DataContext = dialogViewModel;
await _dialogCoordinator.ShowMetroDialogAsync(this, dialog);
}
public static async Task ShowCopyAsProfileDialog(IProfileManager viewModel, IDialogCoordinator dialogCoordinator, ProfileInfo selectedProfile)
{
var customDialog = new CustomDialog
{
Title = Localization.Resources.Strings.CopyProfile,
Style = (Style)Application.Current.FindResource("ProfileMetroDialog")
};
var profileViewModel = new ProfileViewModel(async instance =>
{
await dialogCoordinator.HideMetroDialogAsync(viewModel, customDialog);
viewModel.OnProfileDialogClose();
AddProfile(instance);
}, async instance =>
{
await dialogCoordinator.HideMetroDialogAsync(viewModel, customDialog);
viewModel.OnProfileDialogClose();
}, ProfileManager.GetGroups(), ProfileEditMode.Copy, selectedProfile);
customDialog.Content = new ProfileDialog
{
DataContext = profileViewModel
};
viewModel.OnProfileDialogOpen();
await dialogCoordinator.ShowMetroDialogAsync(viewModel, customDialog);
}
public async void Execute(CoroutineExecutionContext context)
{
var mySettings = new MetroDialogSettings()
{
AffirmativeButtonText = "OK",
AnimateShow = true,
AnimateHide = false
};
IDialogCoordinator coordinator = IoC.Get <IDialogCoordinator>();
DialogContent.CloseButton.Click += async(s, e) =>
{
Result = (T)DialogContent.Combo.SelectedItem;
await coordinator.HideMetroDialogAsync(context.Target, DialogContent);
var args = new ResultCompletionEventArgs()
{
WasCancelled = Result == null
};
this.Completed(this, args);
};
DialogContent.Title = Title;
await coordinator.ShowMetroDialogAsync(context.Target, DialogContent);
}
public static async void ShowDeleteProfileDialog(IProfileViewModel viewModel, IDialogCoordinator dialogCoordinator, ProfileInfo selectedProfile)
{
var customDialog = new CustomDialog
{
Title = Resources.Localization.Strings.DeleteProfile
};
var confirmRemoveViewModel = new ConfirmRemoveViewModel(instance =>
{
dialogCoordinator.HideMetroDialogAsync(viewModel, customDialog);
viewModel.OnProfileDialogClose();
RemoveProfile(selectedProfile);
}, instance =>
{
dialogCoordinator.HideMetroDialogAsync(viewModel, customDialog);
viewModel.OnProfileDialogClose();
}, Resources.Localization.Strings.DeleteProfileMessage);
customDialog.Content = new ConfirmRemoveDialog
{
DataContext = confirmRemoveViewModel
};
viewModel.OnProfileDialogOpen();
await dialogCoordinator.ShowMetroDialogAsync(viewModel, customDialog);
}
private async Task <bool> DroppedFileCustomDialogAsync(string file)
{
MessageDialogResult result = await _dialogService.ShowMessageAsync(this, "", "", MessageDialogStyle.AffirmativeAndNegative);
if (result == MessageDialogResult.Affirmative)
{
return(false);
}
var settings = new MetroDialogSettings();
settings.ColorScheme = MetroDialogColorScheme.Theme;
var fileNoExt = Path.GetFileNameWithoutExtension(file);
ConvertSettings.AudioName = fileNoExt;
ConvertSettings.AnimationName = fileNoExt;
var info = await MediaToolKit.GetVideoFormat(file);
var infoSplit = info.Split(',');
ConvertSettings.Fps = double.Parse(infoSplit[1]);
customDialog = new CustomDialog()
{
Title = info
};
customDialog.Content = (VideoCopyView)_regionManager.Regions[RegionNames.ContentRegion].GetView("VideoCopyView");
await _dialogService.ShowMetroDialogAsync(this, customDialog, settings);
return(true);
}
public static async void ShowEditProfileDialog(IProfileManager viewModel, IDialogCoordinator dialogCoordinator, ProfileInfo selectedProfile)
{
var customDialog = new CustomDialog
{
Title = Localization.Resources.Strings.EditProfile
};
var profileViewModel = new ProfileViewModel(async instance =>
{
await dialogCoordinator.HideMetroDialogAsync(viewModel, customDialog);
viewModel.OnProfileDialogClose();
ProfileManager.RemoveProfile(selectedProfile);
AddProfile(instance);
}, async instance =>
{
await dialogCoordinator.HideMetroDialogAsync(viewModel, customDialog);
viewModel.OnProfileDialogClose();
}, ProfileManager.GetGroups(), ProfileEditMode.Edit, selectedProfile);
customDialog.Content = new ProfileDialog
{
DataContext = profileViewModel
};
viewModel.OnProfileDialogOpen();
await dialogCoordinator.ShowMetroDialogAsync(viewModel, customDialog);
}
public static async Task ShowDeleteProfileDialog(IProfileManager viewModel, IDialogCoordinator dialogCoordinator, ProfileInfo selectedProfile)
{
var customDialog = new CustomDialog
{
Title = Localization.Resources.Strings.DeleteProfile
};
var confirmDeleteViewModel = new ConfirmDeleteViewModel(async instance =>
{
await dialogCoordinator.HideMetroDialogAsync(viewModel, customDialog);
viewModel.OnProfileDialogClose();
ProfileManager.RemoveProfile(selectedProfile);
}, async instance =>
{
await dialogCoordinator.HideMetroDialogAsync(viewModel, customDialog);
viewModel.OnProfileDialogClose();
}, Localization.Resources.Strings.DeleteProfileMessage);
customDialog.Content = new ConfirmDeleteDialog
{
DataContext = confirmDeleteViewModel
};
viewModel.OnProfileDialogOpen();
await dialogCoordinator.ShowMetroDialogAsync(viewModel, customDialog);
}
private async Task <LoginWithUrlDialogData> LoginToRedmine()
{
var settings = new LoginWithUrlDialogSettings
{
AnimateShow = true,
AnimateHide = true,
AffirmativeButtonText = "Login",
NegativeButtonText = "Cancel",
NegativeButtonVisibility = Visibility.Visible,
EnablePasswordPreview = true,
RememberCheckBoxVisibility = Visibility.Collapsed
};
var loginDialog = new LoginWithUrlDialog(null, settings)
{
Title = "Login to Redmine"
};
await _dialogCoordinator.ShowMetroDialogAsync(this, loginDialog);
var result = await loginDialog.WaitForButtonPressAsync();
await _dialogCoordinator.HideMetroDialogAsync(this, loginDialog);
return(result);
}
public static async void ShowAddProfileDialog(IProfileManager viewModel, IDialogCoordinator dialogCoordinator)
{
var customDialog = new CustomDialog
{
Title = Resources.Localization.Strings.AddProfile
};
var profileViewModel = new ProfileViewModel(instance =>
{
dialogCoordinator.HideMetroDialogAsync(viewModel, customDialog);
viewModel.OnProfileDialogClose();
AddProfile(instance);
}, instance =>
{
dialogCoordinator.HideMetroDialogAsync(viewModel, customDialog);
viewModel.OnProfileDialogClose();
}, GetGroups());
customDialog.Content = new ProfileDialog
{
DataContext = profileViewModel
};
viewModel.OnProfileDialogOpen();
await dialogCoordinator.ShowMetroDialogAsync(viewModel, customDialog);
}
private async Task <LoginWithUrlDialogData> LoginToRedmine()
{
var settings = new LoginWithUrlDialogSettings
{
InitialHost = appConfig.LastRedmineUrl,
InitialUsername = appConfig.LastRedmineUser,
AnimateShow = true,
AnimateHide = true,
AffirmativeButtonText = "Login",
NegativeButtonText = "Cancel",
NegativeButtonVisibility = Visibility.Visible,
EnablePasswordPreview = true,
RememberCheckBoxVisibility = Visibility.Collapsed
};
var loginDialog = new LoginWithUrlDialog(null, settings)
{
Title = "Login to Redmine"
};
await dialCoord.ShowMetroDialogAsync(this, loginDialog);
var result = await loginDialog.WaitForButtonPressAsync();
await dialCoord.HideMetroDialogAsync(this, loginDialog);
if (result != null)
{
appConfig.LastRedmineUrl = result.Host;
appConfig.LastRedmineUser = result.Username;
}
return(result);
}
private void startEncaisse()
{
var dialog = new CustomDialog();
var content = new ChoiceBDEUC(dialog, BasketItems, ReductionPrice * -1);
dialog.Content = content;
dialogCoordinator.ShowMetroDialogAsync(this, dialog);
}
/// <summary>
/// Shows a <see cref="PackManagementDialog" /> dialog inside the current window.
/// </summary>
/// <param name="packs">All packs available to choose from.</param>
/// <param name="packToEdit">The pack to modify.</param>
/// <param name="action">The message to the user. I.e 'edit' will be displayed.</param>
/// <returns>The dialog</returns>
public async Task <IPackDialog> ShowPackManagementDialogAsync(IEnumerable <Pack> packs, Pack packToEdit, string action)
{
await dialogCoordinator.ShowMetroDialogAsync(shell, new PackManagementDialog(packs, dialogCoordinator, shell, packToEdit, action));
IPackDialog dialog = await dialogCoordinator.GetCurrentDialogAsync <PackManagementDialog>(shell);
return(dialog);
}
private async void SetMasterPasswordAction()
{
CustomDialog customDialog = new CustomDialog()
{
Title = LocalizationManager.GetStringByKey("String_Header_SetMasterPassword")
};
CredentialsSetMasterPasswordViewModel credentialsSetMasterPasswordViewModel = new CredentialsSetMasterPasswordViewModel(instance =>
{
dialogCoordinator.HideMetroDialogAsync(this, customDialog);
// Create new collection of credentials and set the password
if (CredentialManager.Load(instance.Password))
{
CredentialManager.CredentialsChanged = true; // Save to file when application is closed
}
CheckCredentialsLoaded();
TimerLockUIStart();
}, instance =>
{
dialogCoordinator.HideMetroDialogAsync(this, customDialog);
});
customDialog.Content = new CredentialsSetMasterPasswordDialog
{
DataContext = credentialsSetMasterPasswordViewModel
};
await dialogCoordinator.ShowMetroDialogAsync(this, customDialog);
}
private async void DoiT()
{
var myDialog = new AddDialog();
myDialog.ShowDialogExternally();
await dialogCoordinator.ShowMetroDialogAsync(this, myDialog);
//await dialogCoordinator.HideMetroDialogAsync(this, myDialog);
}
private async void ConnectNewSessionAction()
{
CustomDialog customDialog = new CustomDialog()
{
Title = Application.Current.Resources["String_Header_Connect"] as string
};
RemoteDesktopSessionConnectViewModel connectRemoteDesktopSessionViewModel = new RemoteDesktopSessionConnectViewModel(instance =>
{
dialogCoordinator.HideMetroDialogAsync(this, customDialog);
ConfigurationManager.Current.FixAirspace = false;
// Add host to history
AddHostToHistory(instance.Host);
// Create new remote desktop session info
Models.RemoteDesktop.RemoteDesktopSessionInfo remoteDesktopSessionInfo = new Models.RemoteDesktop.RemoteDesktopSessionInfo
{
Hostname = instance.Host
};
if (instance.UseCredentials)
{
remoteDesktopSessionInfo.CustomCredentials = true;
if (instance.CustomCredentials)
{
remoteDesktopSessionInfo.Username = instance.Username;
remoteDesktopSessionInfo.Password = instance.Password;
}
else
{
CredentialInfo credentialInfo = CredentialManager.GetCredentialByID((int)instance.CredentialID);
remoteDesktopSessionInfo.Username = credentialInfo.Username;
remoteDesktopSessionInfo.Password = credentialInfo.Password;
}
}
ConnectSession(remoteDesktopSessionInfo);
}, instance =>
{
dialogCoordinator.HideMetroDialogAsync(this, customDialog);
ConfigurationManager.Current.FixAirspace = false;
});
customDialog.Content = new RemoteDesktopSessionConnectDialog
{
DataContext = connectRemoteDesktopSessionViewModel
};
ConfigurationManager.Current.FixAirspace = true;
await dialogCoordinator.ShowMetroDialogAsync(this, customDialog);
}
private async void OpenDialog()
{
var customDialog = new MyCustomDialog();
await _dialogCoordinator.ShowMetroDialogAsync(this, customDialog);
var result = await customDialog.WaitForClosingAsync();
await _dialogCoordinator.HideMetroDialogAsync(this, customDialog);
}
private async void ShowDialogAsync()
{
var addMusicDialog = new AddMusicDialogViewModel(_dialogCoordinator);
_customDialog.Content = new Views.AddMusicDialog()
{
DataContext = addMusicDialog
};
await _dialogCoordinator.ShowMetroDialogAsync(this, _customDialog);
}
public async void ExecuteGeneratePassword(object o)
{
var dialogViewModel = new GeneratorDialogViewModel(this);
GeneratorDialog = new GeneratorDialogView()
{
DataContext = dialogViewModel
};
await dialogCoordinator.ShowMetroDialogAsync(this, GeneratorDialog);
}
public async Task ShowDialogAsync(object context, IDialogInstance dialog, IDialogSettings settings = null)
{
// Get the current dialog
var metroDialog = await Instance.GetCurrentDialogAsync <BaseMetroDialog>(context);
// Perform a very simply check to see if the correct dialog is returned, then show it
if (metroDialog is not null && metroDialog.Title == dialog.Title)
{
await Instance.ShowMetroDialogAsync(context, metroDialog, settings?.ToMetroDialogSettings());
}
}
private async void RunUploadLogDiaglog()
{
var uploadLogDiaglog = new QAToolsUploadDialog();
var uploadLogDiaglogContent = new QAToolsUploadViewModel((instance) => {
_dialogCoordinator.HideMetroDialogAsync(this, uploadLogDiaglog);
});
uploadLogDiaglog.Content = new QAToolsUpload {
DataContext = uploadLogDiaglogContent
};
await _dialogCoordinator.ShowMetroDialogAsync(this, uploadLogDiaglog);
}
private async void RunInstallWorkloadDialog()
{
var diaglog = new WorkLoadInstallDialog();
var diaglogContent = new PageFourViewModel((instance) => {
_dialogCoordinator.HideMetroDialogAsync(this, diaglog);
});
diaglog.Content = new PageFour {
DataContext = diaglogContent
};
await _dialogCoordinator.ShowMetroDialogAsync(this, diaglog);
}
public async void ConvertDialog()
{
if (this.FwPath != "" && File.Exists(this.FwPath))
{
try
{
string saveName = Path.GetFileNameWithoutExtension(this.FwPath);
saveName = $"{saveName}_converted_{DateTime.Now.ToString("yyyyMMddTHHmmss")}{this.ConvertFormat.ToExt()}";
this.ConvertDestination = Path.Combine(Path.GetDirectoryName(this.FwPath), saveName);
}
catch (Exception) { }
this.IsDialogOpen = true;
await coordinator.ShowMetroDialogAsync(this, dialogConvert, dialogSettings);
}
else
{
MessageBox.Show(ERR1, "BSL430.NET", MessageBoxButton.OK, MessageBoxImage.Warning);
}
this.IsDialogOpen = false;
}
public async void ShowTimedDialog()
{
var customDialog = new CustomDialog()
{
Title = "Dialog with time-out; will close in 2 seconds."
};
await _dialogCoordinator.ShowMetroDialogAsync(this, customDialog);
await Task.Delay(2000);
await _dialogCoordinator.HideMetroDialogAsync(this, customDialog);
}
