/// <summary>
/// Initializes a new instance of the <see cref="RuleViewModel" /> class.
/// </summary>
/// <param name="rootProject">The root project this rule belongs to.</param>
/// <param name="rule">The rule.</param>
/// <param name="visualStudioService">The visual studio service.</param>
/// <param name="uiVisualizerService">The UI visualizer service.</param>
/// <exception cref="ArgumentNullException">The <paramref name="rootProject" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="rootProject" /> is <c>null</c>.</exception>
public RuleViewModel(RootProject rootProject, Rule rule, IVisualStudioService visualStudioService, IUIVisualizerService uiVisualizerService)
{
Argument.IsNotNull(() => rootProject);
Argument.IsNotNull(() => rule);
Argument.IsNotNull(() => visualStudioService);
Argument.IsNotNull(() => uiVisualizerService);
_uiVisualizerService = uiVisualizerService;
var project = visualStudioService.GetProjectByName(rootProject.Name);
if (project != null)
{
_rootProjectItem = new ProjectItem(project);
}
Rule = rule;
RuleTypes = Enum<RuleType>.ToList();
ProjectTypes = new ObservableCollection<SelectableProjectType>();
foreach (var projectType in ProjectTypeHelper.GetAvailableProjectTypes())
{
bool isSelected = rule.ProjectTypes.Contains(projectType);
var selectableProjectType = new SelectableProjectType(projectType, isSelected);
this.SubscribeToWeakPropertyChangedEvent(selectableProjectType, OnSelectableProjectTypePropertyChanged);
ProjectTypes.Add(selectableProjectType);
}
SelectProjectItem = new Command(OnSelectProjectItemExecute, OnSelectProjectItemCanExecute);
}
public MainWindowViewModel(Target target, ISerializerService<Account> accountSerializerService, ISchedulerService accountSchedulerService,
IUIVisualizerService uiVisualizerService, IMessageService messageService)
{
Argument.IsNotNull(() => accountSerializerService);
Argument.IsNotNull(() => accountSchedulerService);
Argument.IsNotNull(() => uiVisualizerService);
Argument.IsNotNull(() => messageService);
Argument.IsNotNull(() => target);
_accountSerializerService = accountSerializerService;
_accountSchedulerService = accountSchedulerService;
_uiVisualizerService = uiVisualizerService;
_messageService = messageService;
Target = target;
AddTarget = new Command(OnAddTargetExecute);
RemoveTarget = new Command(OnRemoveTargetExecute, OnRemoveTargetCanExecute);
/*var job = JobBuilder.Create<HelloJob>().WithIdentity(new JobKey("Task_1", "TaskGroup")).Build();
var t =
TriggerBuilder.Create()
.WithIdentity("Trigger_1", "TaskGroup")
.StartAt(DateBuilder.TodayAt(21, 15, 0))
.EndAt(DateBuilder.TodayAt(21, 18, 0))
.Build();
_accountSchedulerService.Scheduler.ScheduleJob(job, t);
MessageBox.Show(_accountSchedulerService.Scheduler.IsStarted.ToString()); */
}
/// <summary>
/// Initializes a new instance of the <see cref="RootProjectViewModel" /> class.
/// </summary>
/// <param name="rootProject">The root project.</param>
/// <param name="visualStudioService">The visual studio service.</param>
/// <param name="uiVisualizerService">The UI visualizer service.</param>
/// <param name="messageService">The message service.</param>
/// <exception cref="ArgumentNullException">The <paramref name="rootProject" /> is <c>null</c>.</exception>
public RootProjectViewModel(RootProject rootProject, IVisualStudioService visualStudioService, IUIVisualizerService uiVisualizerService,
IMessageService messageService)
{
Argument.IsNotNull(() => rootProject);
Argument.IsNotNull(() => visualStudioService);
Argument.IsNotNull(() => uiVisualizerService);
Argument.IsNotNull(() => messageService);
_uiVisualizerService = uiVisualizerService;
_messageService = messageService;
AvailableProjects = new List<string>();
var availableProjects = visualStudioService.GetAllProjects();
foreach (var availableProject in availableProjects)
{
AvailableProjects.Add(availableProject.Name);
}
RootProject = rootProject;
Add = new Command(OnAddExecute, OnAddCanExecute);
Edit = new Command(OnEditExecute, OnEditCanExecute);
Remove = new Command(OnRemoveExecute, OnRemoveCanExecute);
}
/// <summary>
/// Initializes a new instance of the <see cref="EmployeesViewModel"/> class.
/// </summary>
public EmployeesViewModel(IMessageMediator messageMediator, IUIVisualizerService uiVisualizerService, IEmployeeRepository employeeRepository,
IMessageService messageService)
: base(messageMediator)
{
Argument.IsNotNull(() => uiVisualizerService);
Argument.IsNotNull(() => employeeRepository);
Argument.IsNotNull(() => messageService);
_uiVisualizerService = uiVisualizerService;
_employeeRepository = employeeRepository;
_messageService = messageService;
AddEmployee = new Command(OnAddEmployeeExecute);
EditEmployee = new Command(OnEditEmployeeExecute, OnEditEmployeeCanExecute);
DeleteEmployee = new Command(OnDeleteEmployeeExecute, OnDeleteEmployeeCanExecute);
Employees = new FastObservableCollection<IEmployee>();
if (!ObjectHelper.IsNull(SelectedDepartment))
{
Employees.AddRange(EmployeeRepository.GetAllEmployees(SelectedDepartment.Name));
}
if (Employees.Count > 0)
{
SelectedEmployee = Employees[0];
}
Mediator.Register<string>(this, OnSelectedDepartmentUpdated, "UpdateEmployees");
}
public LicenseViewModel(LicenseInfo licenseInfo, INavigationService navigationService, IProcessService processService,
ILicenseService licenseService, ILicenseValidationService licenseValidationService, IUIVisualizerService uiVisualizerService,
IMessageService messageService, ILanguageService languageService, ILicenseModeService licenseModeService)
{
Argument.IsNotNull(() => licenseInfo);
Argument.IsNotNull(() => navigationService);
Argument.IsNotNull(() => processService);
Argument.IsNotNull(() => licenseService);
Argument.IsNotNull(() => licenseValidationService);
Argument.IsNotNull(() => uiVisualizerService);
Argument.IsNotNull(() => messageService);
Argument.IsNotNull(() => languageService);
Argument.IsNotNull(() => licenseModeService);
_navigationService = navigationService;
_processService = processService;
_licenseService = licenseService;
_licenseValidationService = licenseValidationService;
_uiVisualizerService = uiVisualizerService;
_messageService = messageService;
_languageService = languageService;
_licenseModeService = licenseModeService;
LicenseInfo = licenseInfo;
Title = licenseInfo.Title;
XmlData = new ObservableCollection <XmlDataModel>();
Paste = new TaskCommand(OnPasteExecuteAsync);
ShowClipboard = new TaskCommand(OnShowClipboardExecuteAsync);
PurchaseLinkClick = new Command(OnPurchaseLinkClickExecute);
AboutSiteClick = new Command(OnAboutSiteClickExecute);
RemoveLicense = new TaskCommand(OnRemoveLicenseExecuteAsync, OnRemoveLicenseCanExecute);
}
public ConnectionStringEditViewModel(string connectionString, DbProvider provider, IMessageService messageService,
IConnectionStringBuilderService connectionStringBuilderService, IUIVisualizerService uiVisualizerService, ITypeFactory typeFactory, IDispatcherService dispatcherService)
{
Argument.IsNotNull(() => connectionStringBuilderService);
Argument.IsNotNull(() => uiVisualizerService);
Argument.IsNotNull(() => typeFactory);
Argument.IsNotNull(() => messageService);
Argument.IsNotNull(() => dispatcherService);
_messageService = messageService;
_connectionStringBuilderService = connectionStringBuilderService;
_uiVisualizerService = uiVisualizerService;
_typeFactory = typeFactory;
_dispatcherService = dispatcherService;
_initalDbProvider = provider;
_initialConnectionString = connectionString;
InitServers = new Command(() => InitServersAsync(), () => !IsServersRefreshing);
RefreshServers = new Command(() => RefreshServersAsync(), () => !IsServersRefreshing);
InitDatabases = new Command(() => InitDatabasesAsync(), () => !IsDatabasesRefreshing);
RefreshDatabases = new Command(() => RefreshDatabasesAsync(), CanInitDatabases);
TestConnection = new Command(OnTestConnection);
ShowAdvancedOptions = new TaskCommand(OnShowAdvancedOptionsAsync, () => ConnectionString != null);
_initializeTimer.Elapsed += OnInitializeTimerElapsed;
}
/// <summary>
/// Initializes a new instance of the <see cref="MainWindowViewModel"/> class.
/// </summary>
public MainWindowViewModel(IUIVisualizerService uiVisualizerService, IPleaseWaitService pleaseWaitService, ILanguageService languageService)
: base()
{
_uiVisualizerService = uiVisualizerService;
_pleaseWaitService = pleaseWaitService;
_languageService = languageService;
AvailableLanguages = new ObservableCollection <Language>();
AvailableLanguages.Add(new Language("English", "en-US"));
AvailableLanguages.Add(new Language("Chinese (simplified)", "zh-HANS"));
AvailableLanguages.Add(new Language("Dutch", "nl"));
AvailableLanguages.Add(new Language("French", "fr"));
AvailableLanguages.Add(new Language("German", "de"));
AvailableLanguages.Add(new Language("Spanish", "es"));
AvailableLanguages.Add(new Language("Turkish", "tr"));
var currentLanguage = (from language in AvailableLanguages
where Thread.CurrentThread.CurrentUICulture.Name.StartsWith(language.Code)
select language).FirstOrDefault();
SelectedLanguage = currentLanguage ?? AvailableLanguages[0];
DataWindow = new Command(OnDataWindowExecute);
PleaseWaitWindow = new Command(OnPleaseWaitWindowExecute);
MultipleChoiceWindow = new Command(OnMultipleChoiceWindowExecute);
MultiLineInput = new Command(OnMultiLineInputExecute);
}
private static IViewModelFactory GetViewModelFactory(IUIVisualizerService uiVisualizerService)
{
var dependencyResolver = uiVisualizerService.GetDependencyResolver();
var viewModelFactory = dependencyResolver.Resolve <IViewModelFactory>();
return(viewModelFactory);
}
public RibbonViewModel(
ISettingsManager settingsManager,
IProjectManager projectManager,
ILoggerService loggerService,
INavigationService navigationService,
IUIVisualizerService uiVisualizerService
)
{
Argument.IsNotNull(() => loggerService);
Argument.IsNotNull(() => navigationService);
Argument.IsNotNull(() => uiVisualizerService);
Argument.IsNotNull(() => projectManager);
Argument.IsNotNull(() => settingsManager);
_projectManager = projectManager;
_loggerService = loggerService;
_navigationService = navigationService;
_uiVisualizerService = uiVisualizerService;
_settingsManager = settingsManager;
Command1 = new RelayCommand(RunCommand1, CanRunCommand1);
ViewSelectedCommand = new DelegateCommand <object>(ExecuteViewSelected, CanViewSelected);
var assembly = AssemblyHelper.GetEntryAssembly();
Title = assembly.Title();
}
public PluginToolsShowPluginInfoCommandContainer(ICommandManager commandManager, IServiceLocator serviceLocator)
: base(Commands.PluginTools.ShowPluginInfo, commandManager, serviceLocator)
{
_uiVisualizerService = ServiceLocator.ResolveType <IUIVisualizerService>();
_globalFrontendService.SelectedPlugins.CollectionChanged += OnSelectedPluginsListChanged;
}
public PackagesUIService(IUIVisualizerService uiVisualizerService, ITypeFactory typeFactory)
{
Argument.IsNotNull(() => uiVisualizerService);
Argument.IsNotNull(() => typeFactory);
_uiVisualizerService = uiVisualizerService;
}
public RibbonViewModel(IRegexService regexService, ICommandManager commandManager,
INavigationService navigationService, IConfigurationService configurationService, IUIVisualizerService uiVisualizerService,
IWorkspaceManager workspaceManager, IPleaseWaitService pleaseWaitService, IFilterService filterService)
{
Argument.IsNotNull(() => regexService);
Argument.IsNotNull(() => commandManager);
Argument.IsNotNull(() => navigationService);
Argument.IsNotNull(() => configurationService);
Argument.IsNotNull(() => uiVisualizerService);
Argument.IsNotNull(() => workspaceManager);
Argument.IsNotNull(() => pleaseWaitService);
Argument.IsNotNull(() => filterService);
_regexService = regexService;
Filter = filterService.Filter;
_navigationService = navigationService;
_configurationService = configurationService;
_uiVisualizerService = uiVisualizerService;
_workspaceManager = workspaceManager;
_pleaseWaitService = pleaseWaitService;
_filterService = filterService;
SaveWorkspace = new TaskCommand(OnSaveWorkspaceExecuteAsync, OnSaveWorkspaceCanExecute);
CreateWorkspace = new TaskCommand(OnCreateWorkspaceExecuteAsync);
ShowKeyboardMappings = new TaskCommand(OnShowKeyboardMappingsExecuteAsync);
Title = AssemblyHelper.GetEntryAssembly().Title();
}
/// <summary>
/// Initializes a new instance of the <see cref="MainWindowViewModel"/> class.
/// </summary>
public MainWindowViewModel(ILicenseService licenseService, ILicenseValidationService licenseValidationService,
IMessageService messageService, INetworkLicenseService networkLicenseService,
ILicenseVisualizerService licenseVisualizerService, IUIVisualizerService uiVisualizerService)
{
Argument.IsNotNull(() => licenseService);
Argument.IsNotNull(() => licenseValidationService);
Argument.IsNotNull(() => messageService);
Argument.IsNotNull(() => networkLicenseService);
Argument.IsNotNull(() => licenseVisualizerService);
Argument.IsNotNull(() => uiVisualizerService);
_licenseService = licenseService;
_licenseValidationService = licenseValidationService;
_messageService = messageService;
_networkLicenseService = networkLicenseService;
_licenseVisualizerService = licenseVisualizerService;
_uiVisualizerService = uiVisualizerService;
RemoveLicense = new Command(OnRemoveLicenseExecute);
ValidateLicenseOnServer = new TaskCommand(OnValidateLicenseOnServerExecuteAsync, OnValidateLicenseOnServerCanExecute);
ValidateLicenseOnLocalNetwork = new TaskCommand(OnValidateLicenseOnLocalNetworkExecuteAsync, OnValidateLicenseOnLocalNetworkCanExecute);
ShowLicense = new Command(OnShowLicenseExecute);
ShowLicenseUsage = new Command(OnShowLicenseUsageExecute);
ServerUri = string.Format("http://localhost:1815/api/license/validate");
}
public MainViewModel(IPackagesUIService packagesUiService, IEchoService echoService, INuGetConfigurationService nuGetConfigurationService,
INuGetFeedVerificationService feedVerificationService, IMessageService messageService, IPackagesUpdatesSearcherService packagesUpdatesSearcherService,
IPackageBatchService packageBatchService, IUIVisualizerService uiVisualizerService)
{
Argument.IsNotNull(() => packagesUiService);
Argument.IsNotNull(() => echoService);
Argument.IsNotNull(() => nuGetConfigurationService);
Argument.IsNotNull(() => feedVerificationService);
Argument.IsNotNull(() => messageService);
Argument.IsNotNull(() => packageBatchService);
Argument.IsNotNull(() => uiVisualizerService);
_packagesUiService = packagesUiService;
_nuGetConfigurationService = nuGetConfigurationService;
_feedVerificationService = feedVerificationService;
_messageService = messageService;
_packagesUpdatesSearcherService = packagesUpdatesSearcherService;
_packageBatchService = packageBatchService;
_uiVisualizerService = uiVisualizerService;
Echo = echoService.GetPackageManagementEcho();
AvailableUpdates = new ObservableCollection <IPackageDetails>();
ShowExplorer = new Command(OnShowExplorerExecute);
AdddPackageSource = new TaskCommand(OnAdddPackageSourceExecute, OnAdddPackageSourceCanExecute);
VerifyFeed = new TaskCommand(OnVerifyFeedExecute, OnVerifyFeedCanExecute);
CheckForUpdates = new TaskCommand(OnCheckForUpdatesExecute);
OpenUpdateWindow = new TaskCommand(OnOpenUpdateWindowExecute, OnOpenUpdateWindowCanExecute);
Settings = new TaskCommand(OnSettingsExecute);
}
public MainViewModel(IPackagesUIService packagesUiService, IEchoService echoService, INuGetConfigurationService nuGetConfigurationService,
INuGetFeedVerificationService feedVerificationService, IMessageService messageService, IPackagesUpdatesSearcherService packagesUpdatesSearcherService,
IPackageBatchService packageBatchService, IUIVisualizerService uiVisualizerService)
{
Argument.IsNotNull(() => packagesUiService);
Argument.IsNotNull(() => echoService);
Argument.IsNotNull(() => nuGetConfigurationService);
Argument.IsNotNull(() => feedVerificationService);
Argument.IsNotNull(() => messageService);
Argument.IsNotNull(() => packageBatchService);
Argument.IsNotNull(() => uiVisualizerService);
_packagesUiService = packagesUiService;
_nuGetConfigurationService = nuGetConfigurationService;
_feedVerificationService = feedVerificationService;
_messageService = messageService;
_packagesUpdatesSearcherService = packagesUpdatesSearcherService;
_packageBatchService = packageBatchService;
_uiVisualizerService = uiVisualizerService;
Echo = echoService.GetPackageManagementEcho();
AvailableUpdates = new ObservableCollection<IPackageDetails>();
ShowExplorer = new Command(OnShowExplorerExecute);
AdddPackageSource = new TaskCommand(OnAdddPackageSourceExecute, OnAdddPackageSourceCanExecute);
VerifyFeed = new TaskCommand(OnVerifyFeedExecute, OnVerifyFeedCanExecute);
CheckForUpdates = new TaskCommand(OnCheckForUpdatesExecute);
OpenUpdateWindow = new TaskCommand(OnOpenUpdateWindowExecute, OnOpenUpdateWindowCanExecute);
Settings = new TaskCommand(OnSettingsExecute);
}
public MainViewModel(IUIVisualizerService uiVisualizerService, IPleaseWaitService pleaseWaitService, IMessageService messageService)
{
_uiVisualizerService = uiVisualizerService;
_pleaseWaitService = pleaseWaitService;
_messageService = messageService;
BooksCollection = new ObservableCollection <Book>
{
new Book {
Title = "Автостопом по галактике", Author = "Дуглас Адамс"
},
new Book {
Title = "Сто лет одиночества", Author = "Габриель Гарсиа Маркес"
},
new Book {
Title = "Маленький принц", Author = "Антуан де Сент-Экзюпери"
},
new Book {
Title = "1984", Author = "Джордж Оруэлл"
},
new Book {
Title = "Над пропастью во ржи", Author = "Джером Дэвид Сэлинджер"
},
};
}
public RibbonViewModel(INavigationService navigationService, IUIVisualizerService uiVisualizerService,
ICommandManager commandManager, IRecentlyUsedItemsService recentlyUsedItemsService, IProcessService processService,
IMessageService messageService)
{
Argument.IsNotNull(() => navigationService);
Argument.IsNotNull(() => uiVisualizerService);
Argument.IsNotNull(() => commandManager);
Argument.IsNotNull(() => recentlyUsedItemsService);
Argument.IsNotNull(() => processService);
Argument.IsNotNull(() => messageService);
_navigationService = navigationService;
_uiVisualizerService = uiVisualizerService;
_recentlyUsedItemsService = recentlyUsedItemsService;
_processService = processService;
_messageService = messageService;
OpenRecentlyUsedItem = new Command <string>(OnOpenRecentlyUsedItemExecute);
UnpinItem = new Command <string>(OnUnpinItemExecute);
PinItem = new Command <string>(OnPinItemExecute);
OpenInExplorer = new Command <string>(OnOpenInExplorerExecute);
Help = new Command(OnHelpExecute);
Exit = new Command(OnExitExecute);
ShowKeyboardMappings = new Command(OnShowKeyboardMappingsExecute);
commandManager.RegisterCommand("Help.About", Help, this);
commandManager.RegisterCommand("File.Exit", Exit, this);
var assembly = AssemblyHelper.GetEntryAssembly();
Title = assembly.Title();
}
public RibbonViewModel(INavigationService navigationService, IUIVisualizerService uiVisualizerService,
ICommandManager commandManager, IRecentlyUsedItemsService recentlyUsedItemsService, IProcessService processService,
IMessageService messageService, ISelectDirectoryService selectDirectoryService)
{
Argument.IsNotNull(() => navigationService);
Argument.IsNotNull(() => uiVisualizerService);
Argument.IsNotNull(() => commandManager);
Argument.IsNotNull(() => recentlyUsedItemsService);
Argument.IsNotNull(() => processService);
Argument.IsNotNull(() => messageService);
Argument.IsNotNull(() => selectDirectoryService);
_navigationService = navigationService;
_uiVisualizerService = uiVisualizerService;
_recentlyUsedItemsService = recentlyUsedItemsService;
_processService = processService;
_messageService = messageService;
_selectDirectoryService = selectDirectoryService;
OpenProject = new Command(OnOpenProjectExecute);
OpenRecentlyUsedItem = new Command<string>(OnOpenRecentlyUsedItemExecute);
OpenInExplorer = new Command<string>(OnOpenInExplorerExecute);
UnpinItem = new Command<string>(OnUnpinItemExecute);
PinItem = new Command<string>(OnPinItemExecute);
ShowKeyboardMappings = new Command(OnShowKeyboardMappingsExecute);
commandManager.RegisterCommand("File.Open", OpenProject, this);
var assembly = AssemblyHelper.GetEntryAssembly();
Title = assembly.Title();
}
public ApplicationDeleteProjectCommandContainer(
IRecentlyUsedItemsService recentlyUsedItemsService,
IServiceLocator serviceLocator,
ICommandManager commandManager,
INavigationService navigationService,
IProjectManager projectManager,
ISaveFileService saveFileService,
INotificationService notificationService,
IUIVisualizerService uIVisualizerService,
IViewModelFactory viewModelFactory,
IMessageService messageService,
ILoggerService loggerService)
: base(AppCommands.Application.DelProject, commandManager)
{
Argument.IsNotNull(() => recentlyUsedItemsService);
Argument.IsNotNull(() => serviceLocator);
Argument.IsNotNull(() => navigationService);
Argument.IsNotNull(() => loggerService);
Argument.IsNotNull(() => saveFileService);
_recentlyUsedItemsService = recentlyUsedItemsService;
_serviceLocator = serviceLocator;
_navigationService = navigationService;
_loggerService = loggerService;
_saveFileService = saveFileService;
_uIVisualizerService = uIVisualizerService;
_viewModelFactory = viewModelFactory;
_messageService = messageService;
}
public static async Task CreateAsync(IUIVisualizerService _uiVisualizerService, MasterViewModel viewModel)
{
_ = viewModel.Dispatcher.Invoke(async() =>
{
Dialogue dialogue_new = new Dialogue();
ITypeFactory dialogueFactory = viewModel.GetTypeFactory();
var dialogVM = dialogueFactory.CreateInstanceWithParametersAndAutoCompletion <DialogueViewModel>(dialogue_new);
DocumentAdded += (object sender, UICompletedEventArgs e) =>
{
if (!dialogue_new.IsCanceled)
{
Console.WriteLine("[RodskaNote]: New Dialogue - " + dialogue_new.Title);
Dialogues.Add(dialogue_new);
RodskaApp app = (RodskaApp)RodskaApp.Current;
MainWindow window = (MainWindow)app.MainWindow;
window.CurrentDocument = dialogue_new;
}
};
var result = await GetFromPrompt(_uiVisualizerService, dialogVM);
DocumentAdded -= (object sender, UICompletedEventArgs e) =>
{
if (!dialogue_new.IsCanceled)
{
Console.WriteLine("[RodskaNote]: New Dialogue - " + dialogue_new.Title);
Dialogues.Add(dialogue_new);
RodskaApplication app = (RodskaApplication)RodskaApplication.Current;
MainWindow window = (MainWindow)app.MainWindow;
window.CurrentDocument = dialogue_new;
}
};
});
await Task.CompletedTask;
}
public ImageLoaderViewModel(
IMessageBoxService messageBoxService,
IOpenFileService openFileService,
ISaveFileService saveFileService,
IUIVisualizerService uiVisualizerService,
IImageProvider imageProvider,
IImageDiskOperations imageDiskOperations,
IViewAwareStatus viewAwareStatusService)
{
//setup services
this.messageBoxService = messageBoxService;
this.openFileService = openFileService;
this.saveFileService = saveFileService;
this.uiVisualizerService = uiVisualizerService;
this.imageProvider = imageProvider;
this.imageDiskOperations = imageDiskOperations;
this.viewAwareStatusService = viewAwareStatusService;
this.viewAwareStatusService.ViewLoaded += ViewAwareStatusService_ViewLoaded;
//commands, SimpleCommand<T1,T2> T1 is CanExecute parameter type, and T2 is Execute type
AddImageRatingCommand = new SimpleCommand <Object, Object>(ExecuteAddImageRatingCommand);
SaveToFileCommand = new SimpleCommand <Object, Object>(ExecuteSaveToFileCommand);
OpenExistingFileCommand = new SimpleCommand <Object, Object>(ExecuteOpenExistingFileCommand);
//EventToCommand triggered, see the View
ShowActionsCommand = new SimpleCommand <Object, Object>(ExecuteShowActionsCommand);
HideActionsCommand = new SimpleCommand <Object, Object>(ExecuteHideActionsCommand);
//some reverse commands, that the VM fires, and the View uses as CompletedAwareCommandTriggers
//to carry out some actions. In this case GoToStateActions are used in the View
ShowActionsCommandReversed = new SimpleCommand <Object, Object>((input) => { });
HideActionsCommandReversed = new SimpleCommand <Object, Object>((input) => { });
}
/// <summary>
/// Initializes a new instance of the <see cref="MainWindowViewModel"/> class.
/// </summary>
public MainWindowViewModel(IMacroService macroService, IUIVisualizerService uiVisualizerService, IMessageService messageService)
{
Argument.IsNotNull(() => macroService);
Argument.IsNotNull(() => uiVisualizerService);
Argument.IsNotNull(() => messageService);
//_familyService = familyService;
this.macroService = macroService;
this.uiVisualizerService = uiVisualizerService;
this.messageService = messageService;
InputTest = new Command(OnInputTestExecute);
MacroSave = new Command(OnSaveMacroExecute);
MacroAdd = new Command(OnMacroAddExecute);
MacroRecord = new Command(OnMacroRecordExecute);
MacroEdit = new Command(OnMacroEditExecute, OnEditMacroCanExecute);
MacroAdd = new Command(OnMacroAddExecute);
MacroCopy = new Command(OnMacroCopyExecute);
MacroDelete = new Command(OnMacroDeleteExecute);
MacroRun = new Command(OnMacroRunExecute);
MacroLoad = new Command(OnMacroLoadExecute);
OpenSettings = new Command(OnOpenSettingsExecute);
// TODO: Move code above to constructor
Util.Initialize();
//AddFamily = new Command(OnAddFamilyExecute);
//EditFamily = new Command(OnEditFamilyExecute, OnEditFamilyCanExecute);
//RemoveFamily = new Command(OnRemoveFamilyExecute, OnRemoveFamilyCanExecute);
}
protected override void Load(string fileName, bool isReload)
{
MetaModel.BaseGlobalDirectory = MetaModelLibraryBase.GetBaseDirectory(fileName);
LoadVModell(fileName, isReload);
MetaModel model = this.RootElement as MetaModel;
model.IsTopMost = true;
// set locks to imported libraries
SetLocksToImportedLibraries(model);
// create model data, store and view model
ModelData = new ModelData(model);
ViewModelStore = new ViewModelStore(ModelData);
ViewModel = new MainSurfaceViewModel(ViewModelStore);
// register known windows
try
{
IUIVisualizerService popupVisualizer = ViewModel.GlobalServiceProvider.Resolve <IUIVisualizerService>();
popupVisualizer.Register("TargetSelectorForm", typeof(TargetSelectorForm));
popupVisualizer.Register("CategorizedSelectionPopup", typeof(CategorizedSelectionPopup));
popupVisualizer.Register("DiagramClassTemplateSelector", typeof(DiagramClassTemplateSelector));
popupVisualizer.Register("DataTemplatePresetsPopup", typeof(DataTemplatePresetsPopup));
popupVisualizer.Register("OptimizationControl", typeof(OptimizationControl));
}
catch { }
}
public RibbonViewModel(INavigationService navigationService, IUIVisualizerService uiVisualizerService,
ICommandManager commandManager, IRecentlyUsedItemsService recentlyUsedItemsService, IProcessService processService,
IMessageService messageService, ISelectDirectoryService selectDirectoryService, IDirectoryService directoryService)
{
Argument.IsNotNull(() => navigationService);
Argument.IsNotNull(() => uiVisualizerService);
Argument.IsNotNull(() => commandManager);
Argument.IsNotNull(() => recentlyUsedItemsService);
Argument.IsNotNull(() => processService);
Argument.IsNotNull(() => messageService);
Argument.IsNotNull(() => selectDirectoryService);
Argument.IsNotNull(() => directoryService);
_navigationService = navigationService;
_uiVisualizerService = uiVisualizerService;
_recentlyUsedItemsService = recentlyUsedItemsService;
_processService = processService;
_messageService = messageService;
_selectDirectoryService = selectDirectoryService;
_directoryService = directoryService;
OpenProject = new TaskCommand(OnOpenProjectExecuteAsync);
OpenRecentlyUsedItem = new TaskCommand <string>(OnOpenRecentlyUsedItemExecuteAsync);
OpenInExplorer = new TaskCommand <string>(OnOpenInExplorerExecuteAsync);
UnpinItem = new Command <string>(OnUnpinItemExecute);
PinItem = new Command <string>(OnPinItemExecute);
ShowKeyboardMappings = new TaskCommand(OnShowKeyboardMappingsExecuteAsync);
commandManager.RegisterCommand("File.Open", OpenProject, this);
var assembly = AssemblyHelper.GetEntryAssembly();
Title = assembly.Title();
}
/// <summary>
/// Shows a window that is registered with the specified view model in a non-modal state.
/// </summary>
/// <param name="this">The <see cref="IUIVisualizerService" /> service self instance.</param>
/// <param name="viewModel">The view model.</param>
/// <param name="openedProc">The callback procedure that will be invoked when the window is opened (registered in the <see cref="IViewManager" />). This value can be <c>null</c>.</param>
/// <param name="completedProc">The callback procedure that will be invoked as soon as the window is closed. This value can be <c>null</c>.</param>
/// <param name="timeOutInMilliseconds">The time out in milliseconds.</param>
/// <returns><c>true</c> if the popup window is successfully opened; otherwise <c>false</c>.</returns>
/// <exception cref="System.ArgumentNullException">The <paramref name="this" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="viewModel" /> is <c>null</c>.</exception>
/// <exception cref="ViewModelNotRegisteredException">The <paramref name="viewModel" /> is not registered by the
/// <see cref="IUIVisualizerService.Register(string,System.Type,bool)" />
/// method first.</exception>
/// <remarks>If the <see cref="IViewManager.GetViewsOfViewModel" /> method returns no active views for the <paramref name="viewModel" /> in the expected <paramref name="timeOutInMilliseconds" /> time
/// then this method will assume that the view is actually opened and invokes <paramref name="openedProc" /> anyway.</remarks>
public static Task <bool?> ShowAsync(this IUIVisualizerService @this, IViewModel viewModel, Action openedProc = null, EventHandler <UICompletedEventArgs> completedProc = null, uint timeOutInMilliseconds = 10000)
{
Argument.IsNotNull("@this", @this);
return(new Task <bool?>(() =>
{
var innerTask = @this.ShowAsync(viewModel, completedProc);
return innerTask.ContinueWith(t =>
{
if ((t.Result ?? false) && openedProc != null)
{
var startTime = DateTime.Now;
ThreadPool.QueueUserWorkItem(state =>
{
var viewManager = ResolveTypeFromContainer <IViewManager>();
while (viewManager.GetViewsOfViewModel(viewModel).Length == 0 && DateTime.Now.Subtract(startTime).TotalMilliseconds < timeOutInMilliseconds)
{
ThreadHelper.Sleep(100);
}
var dispatcherService = ResolveTypeFromContainer <IDispatcherService>();
dispatcherService.Invoke(openedProc, true);
});
}
return t.Result;
}).Result;
}));
}
/// <summary>
/// Initializes a new instance of the <see cref="LicenseViewModel" /> class.
/// </summary>
/// <param name="licenseInfo">The single license model.</param>
/// <param name="navigationService">The navigation service.</param>
/// <param name="processService">The process service.</param>
/// <param name="licenseService">The license service.</param>
/// <param name="licenseValidationService">The license validation service.</param>
/// <param name="uiVisualizerService">The uiVisualizer service.</param>
/// <param name="messageService">The message service.</param>
/// <exception cref="ArgumentNullException">The <paramref name="licenseInfo" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="navigationService" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="processService" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="licenseService" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="uiVisualizerService" /> is <c>null</c>.</exception>
public LicenseViewModel(LicenseInfo licenseInfo, INavigationService navigationService, IProcessService processService,
ILicenseService licenseService, ILicenseValidationService licenseValidationService, IUIVisualizerService uiVisualizerService,
IMessageService messageService)
{
Argument.IsNotNull(() => licenseInfo);
Argument.IsNotNull(() => navigationService);
Argument.IsNotNull(() => processService);
Argument.IsNotNull(() => licenseService);
Argument.IsNotNull(() => licenseValidationService);
Argument.IsNotNull(() => uiVisualizerService);
Argument.IsNotNull(() => messageService);
_navigationService = navigationService;
_processService = processService;
_licenseService = licenseService;
_licenseValidationService = licenseValidationService;
_uiVisualizerService = uiVisualizerService;
_messageService = messageService;
LicenseInfo = licenseInfo;
Title = licenseInfo.Title;
XmlData = new ObservableCollection<XmlDataModel>();
Paste = new TaskCommand(OnPasteExecuteAsync);
ShowClipboard = new Command(OnShowClipboardExecute);
PurchaseLinkClick = new Command(OnPurchaseLinkClickExecute);
AboutSiteClick = new Command(OnAboutSiteClickExecute);
RemoveLicense = new TaskCommand(OnRemoveLicenseExecuteAsync, OnRemoveLicenseCanExecute);
}
/// <summary>
/// Initializes a new instance of the <see cref="MainWindowViewModel"/> class.
/// </summary>
public MainWindowViewModel(ILicenseService licenseService, ILicenseValidationService licenseValidationService,
IMessageService messageService, INetworkLicenseService networkLicenseService,
ILicenseVisualizerService licenseVisualizerService, IUIVisualizerService uiVisualizerService)
{
Argument.IsNotNull(() => licenseService);
Argument.IsNotNull(() => licenseValidationService);
Argument.IsNotNull(() => messageService);
Argument.IsNotNull(() => networkLicenseService);
Argument.IsNotNull(() => licenseVisualizerService);
Argument.IsNotNull(() => uiVisualizerService);
_licenseService = licenseService;
_licenseValidationService = licenseValidationService;
_messageService = messageService;
_networkLicenseService = networkLicenseService;
_licenseVisualizerService = licenseVisualizerService;
_uiVisualizerService = uiVisualizerService;
RemoveLicense = new Command(OnRemoveLicenseExecute);
ValidateLicenseOnServer = new TaskCommand(OnValidateLicenseOnServerExecuteAsync, OnValidateLicenseOnServerCanExecute);
ValidateLicenseOnLocalNetwork = new TaskCommand(OnValidateLicenseOnLocalNetworkExecuteAsync, OnValidateLicenseOnLocalNetworkCanExecute);
ShowLicense = new Command(OnShowLicenseExecute);
ShowLicenseUsage = new Command(OnShowLicenseUsageExecute);
ServerUri = string.Format("http://localhost:1815/api/license/validate");
}
/// <summary>
/// Initializes a new instance of the <see cref="MainWindowViewModel"/> class.
/// </summary>
public MainWindowViewModel(IUIVisualizerService uiVisualizerService)
{
_uiVisualizerService = uiVisualizerService;
InterestedInExample = new Command(OnInterestedInExampleExecute);
MessageMediatorExample = new Command(OnMessageMediatorExampleExecute);
}
public BackupSetViewModel(IBackupSet backupSet, IUIVisualizerService uiVisualizerService)
{
Argument.IsNotNull(() => backupSet);
Argument.IsNotNull(() => uiVisualizerService);
BackupSet = backupSet;
_uiVisualizerService = uiVisualizerService;
_timer = new Timer(new TimerCallback((o)=>
{
RefreshLog();
}), null, Timeout.Infinite, Timeout.Infinite);
UpdateScheduleStatus();
BrowseSourceCommand = new Command(() => SourceDirectory = SetDirectory(SourceDirectory, "Select Source Directory"));
BrowseDestinationCommand = new Command(() => DestinationDirectory = SetDirectory(DestinationDirectory, "Select Destination Directory"));
ExcludeDirectoriesCommand = new Command(OnExcludeDirectoriesExecute, ()=>!String.IsNullOrEmpty(SourceDirectory));
RunBackupCommand = new Command(() =>
{
if(BackupSet.DestinationType == BackupDestinationType.ExternalDrive)
{
var typeFactory = this.GetTypeFactory();
var driveSelectionViewModel = typeFactory.CreateInstanceWithParametersAndAutoCompletion<DriveSelectionViewModel>();
driveSelectionViewModel.SetDefaultDrive(DestinationDirectory.Substring(0, 1));
if(_uiVisualizerService.ShowDialog(driveSelectionViewModel) == true )
{
UpdateDestinationDriveLetter(driveSelectionViewModel.SelectedDrive.Name);
}
else
{
return;
}
}
_timer.Change(1000, 1000);
BackupSet.RunBackup();
}
, () => CanRunBackup);
CancelBackupCommand = new Command(() =>
{
_timer.Change(Timeout.Infinite, Timeout.Infinite);
BackupSet.CancelBackup();
}
, () => CanCancelBackup);
EditBackupSetCommand = new RelayCommand((o)=>
{
StateService.RequestBackupSetEdit((string)o);
}
,(o) => ProcessingStatus == BackupProcessingStatus.NotStarted ||
ProcessingStatus == BackupProcessingStatus.Cancelled ||
ProcessingStatus == BackupProcessingStatus.Finished);
FinishEditingBackupSetCommand = new RelayCommand((o) =>
{
StateService.RequestBackupSetEdit((string)o);
});
BackupSet.PropertyChanged += BackupSetPropertyChanged;
}
public RibbonViewModel(IRegexService regexService, ICommandManager commandManager,
INavigationService navigationService, IConfigurationService configurationService, IUIVisualizerService uiVisualizerService,
IWorkspaceManager workspaceManager, IPleaseWaitService pleaseWaitService, IFilterService filterService)
{
Argument.IsNotNull(() => regexService);
Argument.IsNotNull(() => commandManager);
Argument.IsNotNull(() => navigationService);
Argument.IsNotNull(() => configurationService);
Argument.IsNotNull(() => uiVisualizerService);
Argument.IsNotNull(() => workspaceManager);
Argument.IsNotNull(() => pleaseWaitService);
Argument.IsNotNull(() => filterService);
_regexService = regexService;
Filter = filterService.Filter;
_navigationService = navigationService;
_configurationService = configurationService;
_uiVisualizerService = uiVisualizerService;
_workspaceManager = workspaceManager;
_pleaseWaitService = pleaseWaitService;
_filterService = filterService;
SaveWorkspace = new Command(OnSaveWorkspaceExecute, OnSaveWorkspaceCanExecute);
CreateWorkspace = new Command(OnCreateWorkspaceExecute);
ShowSettings = new Command(OnShowSettingsExecute);
ShowKeyboardMappings = new Command(OnShowKeyboardMappingsExecute);
Exit = new Command(OnExitExecute);
commandManager.RegisterCommand(Commands.Settings.General, ShowSettings, this);
commandManager.RegisterCommand(Commands.File.Exit, Exit, this);
Title = AssemblyHelper.GetEntryAssembly().Title();
}
public MainViewModel(IUIVisualizerService uiVisualizerService, IPleaseWaitService pleaseWaitService, IMessageService messageService)
{
_uiVisualizerService = uiVisualizerService;
_pleaseWaitService = pleaseWaitService;
_messageService = messageService;
//TODO: Источник данных задан хардкодом.
//Добавить команды обработки событий "загрузить данные" / "сохранить данные"
//Использовать по выбору: присоединенный / отсоединенный режимы работы с РБД
//или Entity Framework DatabaseFirst
currCollection = new ObservableCollection <Book>();
BooksCollection = new ObservableCollection <Book>
{
new Book {
Title = "Автостопом по галактике", Author = "Дуглас Адамс"
},
new Book {
Title = "Сто лет одиночества", Author = "Габриель Гарсиа Маркес"
},
new Book {
Title = "Маленький принц", Author = "Антуан де Сент-Экзюпери"
},
new Book {
Title = "1984", Author = "Джордж Оруэлл"
},
new Book {
Title = "Над пропастью во ржи", Author = "Джером Дэвид Сэлинджер"
},
};
foreach (var item in BooksCollection)
{
currCollection.Add(item);
}
}
public ExplorerTopBarViewModel(ExplorerSettingsContainer settings, ITypeFactory typeFactory, IUIVisualizerService uIVisualizerService, INuGetConfigurationService configurationService,
INuGetCacheManager nuGetCacheManager, IPleaseWaitService pleaseWaitService, IMessageService messageService, IMessageMediator messageMediator)
{
Argument.IsNotNull(() => typeFactory);
Argument.IsNotNull(() => uIVisualizerService);
Argument.IsNotNull(() => configurationService);
Argument.IsNotNull(() => settings);
Argument.IsNotNull(() => nuGetCacheManager);
Argument.IsNotNull(() => pleaseWaitService);
Argument.IsNotNull(() => messageService);
Argument.IsNotNull(() => messageMediator);
_typeFactory = typeFactory;
_uIVisualizerService = uIVisualizerService;
_configurationService = configurationService;
_nuGetCacheManager = nuGetCacheManager;
_pleaseWaitService = pleaseWaitService;
_messageService = messageService;
_messageMediator = messageMediator;
Settings = settings;
Title = "Manage NuGet Packages";
CommandInitialize();
}
public MaterialListViewModel(IMessageBoxService messageBoxService, IUIVisualizerService uiVisualizerService,
IMaterialManager materialManager, IMaterialGroupManager materialGroupManager, IUnitManager unitManager) : base(messageBoxService, uiVisualizerService, materialManager)
{
// do initialization
try
{
if (materialGroupManager == null)
{
throw new ArgumentNullException("materialGroupManager");
}
_materialGroupManager = materialGroupManager;
if (unitManager == null)
{
throw new ArgumentNullException("unitManager");
}
_unitManager = unitManager;
this.DisplayName = "Material List";
}
catch (Exception ex)
{
this.MessageBoxService.ShowError(this.GetType().FullName + System.Reflection.MethodBase.GetCurrentMethod().Name + ": " + ex.Message);
}
}
public FilterBuilderViewModel(IUIVisualizerService uiVisualizerService, IFilterSchemeManager filterSchemeManager,
IFilterService filterService, IMessageService messageService, IServiceLocator serviceLocator, IReflectionService reflectionService, ILanguageService languageService)
{
Argument.IsNotNull(() => uiVisualizerService);
Argument.IsNotNull(() => filterSchemeManager);
Argument.IsNotNull(() => filterService);
Argument.IsNotNull(() => messageService);
Argument.IsNotNull(() => serviceLocator);
Argument.IsNotNull(() => reflectionService);
Argument.IsNotNull(() => languageService);
_uiVisualizerService = uiVisualizerService;
_filterSchemeManager = filterSchemeManager;
_filterService = filterService;
_messageService = messageService;
_serviceLocator = serviceLocator;
_reflectionService = reflectionService;
_languageService = languageService;
NewSchemeCommand = new TaskCommand(OnNewSchemeExecuteAsync);
EditSchemeCommand = new TaskCommand <FilterScheme>(OnEditSchemeExecuteAsync, OnEditSchemeCanExecute);
ApplySchemeCommand = new TaskCommand(OnApplySchemeExecuteAsync, OnApplySchemeCanExecute);
ResetSchemeCommand = new Command(OnResetSchemeExecute, OnResetSchemeCanExecute);
DeleteSchemeCommand = new Command <FilterScheme>(OnDeleteSchemeExecute, OnDeleteSchemeCanExecute);
}
public MainWindowViewModel(IUIVisualizerService visualizerService, IMessageService messageService)
{
_visualizerService = visualizerService;
_messageService = messageService;
AddBankCommand = new Command(OnAddBankCommandExecute);
}
public PackagesUIService(IUIVisualizerService uiVisualizerService, ITypeFactory typeFactory)
{
Argument.IsNotNull(() => uiVisualizerService);
Argument.IsNotNull(() => typeFactory);
_uiVisualizerService = uiVisualizerService;
}
/// <summary>
/// Initializes a new instance of the <see cref="EmployeesViewModel"/> class.
/// </summary>
public EmployeesViewModel(IMessageMediator messageMediator, IUIVisualizerService uiVisualizerService, IEmployeeRepository employeeRepository,
IMessageService messageService)
: base(messageMediator)
{
Argument.IsNotNull(() => uiVisualizerService);
Argument.IsNotNull(() => employeeRepository);
Argument.IsNotNull(() => messageService);
_uiVisualizerService = uiVisualizerService;
_employeeRepository = employeeRepository;
_messageService = messageService;
AddEmployee = new Command(OnAddEmployeeExecute);
EditEmployee = new Command(OnEditEmployeeExecute, OnEditEmployeeCanExecute);
DeleteEmployee = new Command(OnDeleteEmployeeExecute, OnDeleteEmployeeCanExecute);
Employees = new FastObservableCollection <IEmployee>();
if (!ObjectHelper.IsNull(SelectedDepartment))
{
Employees.AddRange(EmployeeRepository.GetAllEmployees(SelectedDepartment.Name));
}
if (Employees.Count > 0)
{
SelectedEmployee = Employees[0];
}
Mediator.Register <string>(this, OnSelectedDepartmentUpdated, "UpdateEmployees");
}
public MainViewModel(IUIVisualizerService uiVisualizerService, IPleaseWaitService pleaseWaitService,
ILanguageService languageService)
{
Argument.IsNotNull(() => uiVisualizerService);
Argument.IsNotNull(() => pleaseWaitService);
Argument.IsNotNull(() => languageService);
_uiVisualizerService = uiVisualizerService;
_pleaseWaitService = pleaseWaitService;
_languageService = languageService;
AvailableLanguages = new ObservableCollection <Language>();
AvailableLanguages.Add(new Language("English", "en-US"));
AvailableLanguages.Add(new Language("Chinese (simplified)", "zh-HANS"));
AvailableLanguages.Add(new Language("Dutch", "nl"));
AvailableLanguages.Add(new Language("French", "fr"));
AvailableLanguages.Add(new Language("German", "de"));
AvailableLanguages.Add(new Language("Spanish", "es"));
AvailableLanguages.Add(new Language("Turkish", "tr"));
var currentLanguage = (from language in AvailableLanguages
where Thread.CurrentThread.CurrentUICulture.Name.StartsWith(language.Code)
select language).FirstOrDefault();
SelectedLanguage = currentLanguage ?? AvailableLanguages[0];
DataWindow = new TaskCommand(OnDataWindowExecuteAsync);
Title = "MultiLingual example";
}
/// <summary>
/// Initializes a new instance of the <see cref="MainWindowViewModel"/> class.
/// </summary>
public MainWindowViewModel(IUIVisualizerService uiVisualizerService, IPleaseWaitService pleaseWaitService, ILanguageService languageService)
: base()
{
_uiVisualizerService = uiVisualizerService;
_pleaseWaitService = pleaseWaitService;
_languageService = languageService;
AvailableLanguages = new ObservableCollection<Language>();
AvailableLanguages.Add(new Language("English", "en-US"));
AvailableLanguages.Add(new Language("Chinese (simplified)", "zh-HANS"));
AvailableLanguages.Add(new Language("Dutch", "nl"));
AvailableLanguages.Add(new Language("French", "fr"));
AvailableLanguages.Add(new Language("German", "de"));
AvailableLanguages.Add(new Language("Spanish", "es"));
AvailableLanguages.Add(new Language("Turkish", "tr"));
var currentLanguage = (from language in AvailableLanguages
where Thread.CurrentThread.CurrentUICulture.Name.StartsWith(language.Code)
select language).FirstOrDefault();
SelectedLanguage = currentLanguage ?? AvailableLanguages[0];
DataWindow = new Command(OnDataWindowExecute);
PleaseWaitWindow = new Command(OnPleaseWaitWindowExecute);
MultipleChoiceWindow = new Command(OnMultipleChoiceWindowExecute);
MultiLineInput = new Command(OnMultiLineInputExecute);
}
internal async Task CheckDirectoriesAsync()
{
var dodgy = new List <string>();
using (new CursorOverride(Cursors.Wait))
{
var files = ListFiles();
foreach (var file in files)
{
if (!legitDirectories.Contains(file.Path))
{
dodgy.Add(file.Path);
}
}
}
if (dodgy.Count == 0)
{
MessageBox.Show("Nothing dodgy", "WebWriter AntiHacker", MessageBoxButton.OK, MessageBoxImage.Information);
}
else
{
IUIVisualizerService uIVisualiserService = ServiceLocator.Default.ResolveType <IUIVisualizerService>();
if (!(uIVisualiserService is null))
{
await uIVisualiserService.ShowDialogAsync <DodgyStuffViewModel>(dodgy);
}
}
}
public AboutViewModel(AboutInfo aboutInfo, IProcessService processService, IUIVisualizerService uiVisualizerService,
IMessageService messageService)
{
Argument.IsNotNull(() => aboutInfo);
Argument.IsNotNull(() => processService);
Argument.IsNotNull(() => uiVisualizerService);
Argument.IsNotNull(() => messageService);
_processService = processService;
_uiVisualizerService = uiVisualizerService;
_messageService = messageService;
var assembly = aboutInfo.Assembly;
var version = VersionHelper.GetCurrentVersion(assembly);
var buildDateTime = assembly.GetBuildDateTime();
Title = assembly.Title();
Version = string.Format("v {0}", version);
BuildDateTime = string.Format("Built on {0}", buildDateTime);
UriInfo = aboutInfo.UriInfo;
Copyright = assembly.Copyright();
CompanyLogoUri = aboutInfo.CompanyLogoUri;
ImageSourceUrl = aboutInfo.LogoImageSource;
ShowLogButton = aboutInfo.ShowLogButton;
AppIcon = assembly.ExtractLargestIcon();
OpenUrl = new Command(OnOpenUrlExecute, OnOpenUrlCanExecute);
OpenLog = new TaskCommand(OnOpenLogExecuteAsync);
ShowSystemInfo = new Command(OnShowSystemInfoExecute);
EnableDetailedLogging = new Command(OnEnableDetailedLoggingExecute);
}
static DefaultRadGridContextMenuCommands()
{
var servicelocator = ServiceLocator.Default;
ViewModelFactory = servicelocator.ResolveType <IViewModelFactory>();
UIVisualizerService = servicelocator.ResolveType <IUIVisualizerService>();
//SaveFileService = servicelocator.ResolveType<ISaveFileService>();
//OpenFileService = servicelocator.ResolveType<IOpenFileService>();
//StorageService = servicelocator.ResolveType<IStorageService>();
SortAscendingCommand = new Command <HeaderCommandParameter>(OnSortAscendingExecute);
SortDescendingCommand = new Command <HeaderCommandParameter>(OnSortDescendingExecute);
SortClearingCommand = new Command <HeaderCommandParameter>(OnSortClearingExecute);
GroupByCommand = new Command <HeaderCommandParameter>(OnGroupByExecute);
UnGroupByCommand = new Command <HeaderCommandParameter>(OnUnGroupByExecute);
DeleteFiltersCommand = new Command <HeaderCommandParameter>(OnDeleteFiltersExecute);
//ExportGridCommand = new Command<RadGridView>(OnExportGridCommand, CanExecuteExportGrid);
//SaveSettingsCommand = new Command<HeaderCommandParameter>(OnSaveSettingsCommandExecute, CanSaveSettingsCommandExecute);
//LoadSettingsCommand = new Command<HeaderCommandParameter>(OnLoadSettingsCommandExecute, CanLoadSettingsCommandExecute);
ClearSettingsCommand = new Command <HeaderCommandParameter>(OnClearSettingsCommandExecute);
SetDefaultCommand = new Command <HeaderCommandParameter>(OnSetDefaultCommandExecute);
ChangeColorCommand = new TaskCommand <HeaderCommandParameter>(OnChangeColorCommandExecute);
ChangeFontCommand = new TaskCommand <HeaderCommandParameter>(OnChangeFontCommandExecute);
PropertiesCommand = new TaskCommand <HeaderCommandParameter>(OnPropertiesCommandExecute);
//BaseStyle = Application.Current.FindResource("GridViewCellCoreStyle") as System.Windows.Style;
}
public RibbonViewModel(
ISettingsManager settingsManager,
IProjectManager projectManager,
ILoggerService loggerService,
INavigationService navigationService,
IUIVisualizerService uiVisualizerService
)
{
Argument.IsNotNull(() => loggerService);
Argument.IsNotNull(() => navigationService);
Argument.IsNotNull(() => uiVisualizerService);
Argument.IsNotNull(() => projectManager);
Argument.IsNotNull(() => settingsManager);
_projectManager = projectManager;
_loggerService = loggerService;
_navigationService = navigationService;
_uiVisualizerService = uiVisualizerService;
_settingsManager = settingsManager;
StartScreenShown = false;
BackstageIsOpen = true;
GlobalRibbonVM = this;
ViewSelectedCommand = new DelegateCommand <object>(ExecuteViewSelected, CanViewSelected);
var assembly = AssemblyHelper.GetEntryAssembly();
Title = assembly.Title();
}
/// <summary>
/// Creates a window in non-modal state. If a window with the specified viewModelType exists, the window is activated instead of being created.
/// </summary>
/// <param name="uiVisualizerService">The UI visualizer service.</param>
/// <typeparam name="TViewModel">The type of the view model.</typeparam>
/// <param name="model">The model to be injected into the view model, can be <c>null</c>.</param>
/// <param name="completedProc">The completed proc. Not applicable if window already exists.</param>
/// <returns><c>true</c> if shown or activated successfully, <c>false</c> otherwise.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="uiVisualizerService" /> is <c>null</c>.</exception>
public static Task <bool?> ShowOrActivateAsync <TViewModel>(this IUIVisualizerService uiVisualizerService, object model = null, EventHandler <UICompletedEventArgs> completedProc = null)
where TViewModel : IViewModel
{
Argument.IsNotNull("uiVisualizerService", uiVisualizerService);
var dependencyResolver = uiVisualizerService.GetDependencyResolver();
var viewModelManager = dependencyResolver.Resolve <IViewModelManager>();
var viewModel = viewModelManager.GetFirstOrDefaultInstance(typeof(TViewModel));
if (viewModel == null)
{
var viewModelFactory = GetViewModelFactory(uiVisualizerService);
var vm = viewModelFactory.CreateViewModel(typeof(TViewModel), model);
return(uiVisualizerService.ShowAsync(vm, completedProc));
}
var viewLocator = dependencyResolver.Resolve <IViewLocator>();
var viewType = viewLocator.ResolveView(viewModel.GetType());
var viewManager = dependencyResolver.Resolve <IViewManager>();
var view = viewManager.GetFirstOrDefaultInstance(viewType);
var window = view as System.Windows.Window;
if (view == null || window == null)
{
return(uiVisualizerService.ShowAsync(viewModel, completedProc));
}
var activated = ActivateWindow(window);
return(TaskHelper <bool?> .FromResult(activated));
}
public AboutViewModel(AboutInfo aboutInfo, IProcessService processService, IUIVisualizerService uiVisualizerService,
IMessageService messageService, ILanguageService languageService)
{
Argument.IsNotNull(() => aboutInfo);
Argument.IsNotNull(() => processService);
Argument.IsNotNull(() => uiVisualizerService);
Argument.IsNotNull(() => messageService);
Argument.IsNotNull(() => languageService);
_processService = processService;
_uiVisualizerService = uiVisualizerService;
_messageService = messageService;
_languageService = languageService;
var assembly = aboutInfo.Assembly;
var version = aboutInfo.DisplayVersion;
var buildDateTime = aboutInfo.BuildDateTime.Value;
Title = aboutInfo.Name;
Version = string.Format("v {0}", aboutInfo.DisplayVersion);
BuildDateTime = string.Format(languageService.GetString("Orchestra_BuiltOn"), buildDateTime);
UriInfo = aboutInfo.UriInfo;
Copyright = aboutInfo.Copyright;
CompanyLogoUri = aboutInfo.CompanyLogoUri;
ImageSourceUrl = aboutInfo.LogoImageSource;
ShowLogButton = aboutInfo.ShowLogButton;
AppIcon = aboutInfo.AppIcon;
OpenUrl = new Command(OnOpenUrlExecute, OnOpenUrlCanExecute);
OpenLog = new TaskCommand(OnOpenLogExecuteAsync);
ShowSystemInfo = new Command(OnShowSystemInfoExecute);
EnableDetailedLogging = new Command(OnEnableDetailedLoggingExecute);
}
public AboutViewModel(AboutInfo aboutInfo, IProcessService processService, IUIVisualizerService uiVisualizerService,
IMessageService messageService, ILanguageService languageService)
{
Argument.IsNotNull(() => aboutInfo);
Argument.IsNotNull(() => processService);
Argument.IsNotNull(() => uiVisualizerService);
Argument.IsNotNull(() => messageService);
Argument.IsNotNull(() => languageService);
_processService = processService;
_uiVisualizerService = uiVisualizerService;
_messageService = messageService;
_languageService = languageService;
var buildDateTime = aboutInfo.BuildDateTime.Value;
Title = aboutInfo.Name;
Version = string.Format("v {0}", aboutInfo.DisplayVersion);
BuildDateTime = string.Format(languageService.GetString("Orchestra_BuiltOn"), buildDateTime);
UriInfo = aboutInfo.UriInfo;
Copyright = aboutInfo.Copyright;
CopyrightUrl = aboutInfo.CopyrightUri == null ? null : aboutInfo.CopyrightUri.ToString();
CompanyLogoUri = aboutInfo.CompanyLogoUri;
ImageSourceUrl = aboutInfo.LogoImageSource;
ShowLogButton = aboutInfo.ShowLogButton;
AppIcon = aboutInfo.AppIcon;
OpenUrl = new Command(OnOpenUrlExecute, OnOpenUrlCanExecute);
OpenCopyrightUrl = new Command(OnOpenCopyrightUrlExecute, OnOpenCopyrightUrlCanExecute);
ShowThirdPartyNotices = new TaskCommand(OnShowThirdPartyNoticesExecuteAsync);
OpenLog = new TaskCommand(OnOpenLogExecuteAsync);
ShowSystemInfo = new TaskCommand(OnShowSystemInfoExecuteAsync);
EnableDetailedLogging = new Command(OnEnableDetailedLoggingExecute);
}
public PresetToolsShowPresetDataCommandContainer(ICommandManager commandManager, IServiceLocator serviceLocator)
: base(Commands.PresetTools.ShowPresetData, commandManager, serviceLocator)
{
_uiVisualizerService = Catel.IoC.ServiceLocator.Default.ResolveType <IUIVisualizerService>();
_globalFrontendService.SelectedPresets.CollectionChanged += OnSelectedPresetsListChanged;
}
public MainWindowViewModel(IUIVisualizerService uiVisualizerService, IPleaseWaitService pleaseWaitService,
IMessageService messageService, IDependencyResolver dependencyResolver)
{
_uiVisualizerService = uiVisualizerService;
_pleaseWaitService = pleaseWaitService;
_messageService = messageService;
_dependencyResolver = dependencyResolver;
}
public AboutService(IUIVisualizerService uiVisualizerService, IAboutInfoService aboutInfoService)
{
Argument.IsNotNull(() => uiVisualizerService);
Argument.IsNotNull(() => aboutInfoService);
_uiVisualizerService = uiVisualizerService;
_aboutInfoService = aboutInfoService;
}
public PackageBatchService(IUIVisualizerService uiVisualizerService, IDispatcherService dispatcherService)
{
Argument.IsNotNull(() => uiVisualizerService);
Argument.IsNotNull(() => dispatcherService);
_uiVisualizerService = uiVisualizerService;
_dispatcherService = dispatcherService;
}
public MainWindowViewModel(IUIVisualizerService uiVisualizerService, IPleaseWaitService pleaseWaitService, IMessageService messageService, IDependencyResolver dependencyResolver)
{
this._uiVisualizerService = uiVisualizerService;
this._pleaseWaitService = pleaseWaitService;
this._messageService = messageService;
this._dependencyResolver = dependencyResolver;
this.FormsCollection = new FastObservableCollection<Form>();
}
/// <summary>
/// Initializes a new instance of the <see cref="MainWindowViewModel"/> class.
/// </summary>
public MainWindowViewModel(IUIVisualizerService uiVisualizerService, IAuthenticationProvider authenticationProvider)
{
_uiVisualizerService = uiVisualizerService;
_authenticationProvider = authenticationProvider;
RoleCollection = new ObservableCollection<string>(new [] { "Read-only", "Administrator" });
ShowView = new Command(OnShowViewExecute, OnShowViewCanExecute);
}
/// <summary>
/// Initializes a new instance of the <see cref="MainWindowViewModel"/> class.
/// </summary>
public MainWindowViewModel(IUIVisualizerService uiVisualizerService)
{
_uiVisualizerService = uiVisualizerService;
OpenValidationViaValidateMethods = new Command(OnOpenValidationViaValidateMethodsExecute);
OpenValidationViaDataAnnotations = new Command(OnOpenValidationViaDataAnnotationsExecute);
OpenValidationInModel = new Command(OnOpenValidationInModelExecute);
OpenValidationInIValidator = new Command(OnOpenValidationInIValidatorExecute);
OpenValidationViaFluentValidation = new Command(OpenValidationViaFluentValidationExecute);
}
public MahAppsService(ICommandManager commandManager, IMessageService messageService, IUIVisualizerService uiVisualizerService)
{
Argument.IsNotNull(() => commandManager);
Argument.IsNotNull(() => messageService);
Argument.IsNotNull(() => uiVisualizerService);
_commandManager = commandManager;
_messageService = messageService;
_uiVisualizerService = uiVisualizerService;
}
public MainViewModel(IUIVisualizerService uiVisualizerService, IDispatcherService dispatcherService)
{
Argument.IsNotNull(() => uiVisualizerService);
Argument.IsNotNull(() => dispatcherService);
_uiVisualizerService = uiVisualizerService;
_dispatcherService = dispatcherService;
ShowInstalledDialog = new Command(OnShowInstalledDialogExecute);
}
/// <summary>
/// Initializes a new instance of the <see cref="MainWindowViewModel"/> class.
/// </summary>
public MainWindowViewModel(IPleaseWaitService pleaseWaitService, IUIVisualizerService uiVisualizerService, IMessageService messageService)
: base()
{
_pleaseWaitService = pleaseWaitService;
_uiVisualizerService = uiVisualizerService;
_messageService = messageService;
FirstCommand = new Command(OnFirstCommandExecute);
SecondCommand = new Command(OnSecondCommandExecute);
ShowWindow = new Command(OnShowWindowExecute);
}
public MessageService(IDispatcherService dispatcherService, IUIVisualizerService uiVisualizerService, IViewModelFactory viewModelFactory)
: base(dispatcherService)
{
Argument.IsNotNull(() => dispatcherService);
Argument.IsNotNull(() => uiVisualizerService);
Argument.IsNotNull(() => viewModelFactory);
_dispatcherService = dispatcherService;
_uiVisualizerService = uiVisualizerService;
_viewModelFactory = viewModelFactory;
}
public RibbonViewModel(ITestDataService testDataService, IFilterSchemeManager filterSchemeManager,
IFilterService filterService, IUIVisualizerService uiVisualizerService)
{
_testDataService = testDataService;
_filterSchemeManager = filterSchemeManager;
_filterService = filterService;
_uiVisualizerService = uiVisualizerService;
RawItems = _testDataService.GetTestItems();
NewSchemeCommand = new Command(OnNewSchemeExecute);
}
/// <summary>
/// Initializes a new instance of the <see cref="MainWindowViewModel"/> class.
/// </summary>
public MainWindowViewModel(IUIVisualizerService uiVisualizerService, ITabService tabService)
{
_uiVisualizerService = uiVisualizerService;
_tabService = tabService;
_timer.Tick += OnTimerTick;
_timer.Interval = new TimeSpan(0, 0, 0, 0, 500);
_timer.Start();
AddTab = new TaskCommand(OnAddTabExecuteAsync);
}
public MainWindowViewModel(IUIVisualizerService uiVisualizerService, IPleaseWaitService pleaseWaitService, IMessageService messageService, IOpenFileService openFileService)
{
_uiVisualizerService = uiVisualizerService;
_pleaseWaitService = pleaseWaitService;
_messageService = messageService;
_openFileService = openFileService;
AddMagnet = new Command(OnAddMagnetExecuteAsync);
EditMagnet = new Command(OnEditMagnetExecuteAsync, OnEditMagnetCanExecute);
RemoveMagnet = new Command(OnRemoveMagnetExecuteAsync, OnRemoveMagnetCanExecute);
}
