public HelpCommand(ICommandManager commandManager, string commandExe, string productName, string helpUrl)
{
_commandManager = commandManager;
_commandExe = commandExe;
_productName = productName;
_helpUrl = helpUrl;
}
public Engine(IInputReader reader, IOutputWriter writer, ICommandManager commandManager)
{
this.writer = writer;
this.reader = reader;
this.commandManager = commandManager;
this.commandManager.Engine = this;
}
public CommandActionsEntryPoint(ICommandManager commandManager, IPresentationManager presentationManager, IPlaybackManager playbackManager, INavigationService navigationService, IScreensaverManager screensaverManager, ILogManager logManager)
{
_commandManager = commandManager;
_defaultCommandActionMap = new DefaultCommandActionMap(presentationManager, playbackManager, navigationService, screensaverManager, logManager);
_logger = logManager.GetLogger(GetType().Name);
}
public CommandStep(ICommandManager commandManager,
RecipeExecutionLogger logger)
: base(logger)
{
_commandManager = commandManager;
_commandParser = new CommandParser();
}
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 override void InitializePlugin(IPoderosaWorld poderosa)
{
base.InitializePlugin(poderosa);
_instance = this;
ICoreServices cs = (ICoreServices)poderosa.GetAdapter(typeof(ICoreServices));
poderosa.Culture.AddChangeListener(UsabilityPlugin.Strings);
IPluginManager pm = poderosa.PluginManager;
_commandManager = cs.CommandManager;
Debug.Assert(_commandManager != null);
_windowManager = cs.WindowManager;
Debug.Assert(_windowManager != null);
//Guevara AboutBox
pm.FindExtensionPoint("org.poderosa.window.aboutbox").RegisterExtension(new GuevaraAboutBoxFactory());
#if TERMCONTROL
#else
//SSH KnownHost
_sshKnownHosts = new SSHKnownHosts();
cs.PreferenceExtensionPoint.RegisterExtension(_sshKnownHosts);
pm.FindExtensionPoint(ProtocolsPluginConstants.HOSTKEYCHECKER_EXTENSION).RegisterExtension(_sshKnownHosts);
#endif
}
public ApplicationExitCommandContainer(ICommandManager commandManager, INavigationService navigationService)
: base(Commands.Application.Exit, commandManager)
{
Argument.IsNotNull(() => navigationService);
_navigationService = navigationService;
}
protected ContentViewModel(AbstractWorkspace workspace, ICommandManager commandManager, ILoggerService logger)
{
_workspace = workspace;
_commandManager = commandManager;
_logger = logger;
CloseCommand = new DelegateCommand(CloseDocument);
}
public DemoShowMessageBoxCommandContainer(ICommandManager commandManager, IMessageService messageService)
: base(Commands.Demo.ShowMessageBox, commandManager)
{
Argument.IsNotNull(() => messageService);
_messageService = messageService;
}
public CommandRecipeHandler(ICommandManager commandManager)
{
_commandManager = commandManager;
_commandParser = new CommandParser();
Logger = NullLogger.Instance;
T = NullLocalizer.Instance;
}
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 CommandRecipeHandler(ICommandManager commandManager, IRecipeJournal recipeJournal) {
_commandManager = commandManager;
_recipeJournal = recipeJournal;
_commandParser = new CommandParser();
Logger = NullLogger.Instance;
T = NullLocalizer.Instance;
}
public DelegateCommand(ICommandManager commandManager,
Action executeMethod)
: this(commandManager,
executeMethod,
() => true)
{
}
public DemoHiddenCommandContainer(ICommandManager commandManager, IMessageService messageService)
: base(Commands.Demo.Hidden, commandManager)
{
Argument.IsNotNull(() => messageService);
_messageService = messageService;
}
internal CodeEditor(
ICommandManager commandManager
, IEditorView editorView
, IEditorViewHost editorViewHost
, IEditorCommands editorCommands
, IUndoManager undoManager
, IFindLogic findLogic
, CodeOptionsModel codeOptionsModel
)
{
this.commandManager = commandManager;
this.editorView = editorView;
this.editorViewHost = editorViewHost;
this.findLogic = findLogic;
this.editorCommands = editorCommands;
this.undoManager = undoManager;
FrameworkElement element = this.Element;
element.PreviewLostKeyboardFocus += new KeyboardFocusChangedEventHandler(this.Editor_LostFocus);
element.LostFocus += new RoutedEventHandler(this.Editor_LostFocus);
if (this.commandManager != null)
{
this.commandManager.CommandExecuting += new CommandExecutionEventHandler(this.Editor_LostFocus);
}
this.editorView.Background = Brushes.White;
TextFormattingRunProperties.DefaultProperties.SetTypeface(new Typeface(FontName));
TextFormattingRunProperties.DefaultProperties.SetFontRenderingEmSize(FontSize);
this.editorViewHost.LineNumberGutterForegroundColor = Colors.Black;
this.editorViewHost.LineNumberGutterTypeface = new Typeface(FontName);
this.editorViewHost.LineNumberGutterFontSize = FontSize;
this.editorView.Invalidate();
this.codeOptionsModel = codeOptionsModel;
this.codeOptionsModel.PropertyChanged += new PropertyChangedEventHandler(this.CodeOptionsModel_PropertyChanged);
this.UpdateOptions();
}
public CommandActionsEntryPoint(ICommandManager commandManager, ITheaterApplicationHost appHost, IPresenter presentationManager, IPlaybackManager playbackManager, INavigator navigationService, /*IScreensaverManager screensaverManager,*/ ILogManager logManager, IEventAggregator events)
{
_commandManager = commandManager;
_defaultCommandActionMap = new DefaultCommandActionMap(appHost, presentationManager, playbackManager, navigationService, /*screensaverManager,*/ logManager, events);
_logger = logManager.GetLogger(GetType().Name);
}
public ApplicationAboutCommandContainer(ICommandManager commandManager, IAboutService aboutService)
: base(Commands.Application.About, commandManager)
{
Argument.IsNotNull(() => aboutService);
_aboutService = aboutService;
}
public WebTestCurrentResultViewModel(AbstractWorkspace workspace, ICommandManager commandManager, ILoggerService logger, IMenuService menuService, WebTestResultView view)
: base(workspace, commandManager, logger, menuService)
{
_tooltip = "Web Test Results";
_title = "Web Test Results";
this.View = view;
}
public PluginManager(ICommandManager commandManager, IPluginStorageManager pluginStorageManager,
IPluginPermissionManager pluginPermissionManager, IAuthenticationManager authenticationManager)
{
_commandManager = commandManager;
_pluginStorageManager = pluginStorageManager;
_pluginPermissionManager = pluginPermissionManager;
_authenticationManager = authenticationManager;
}
public MinesweeperEngine(IDataBase db, ICommandManager commandManager, IInputReader reader, IOutputWriter writer)
{
this.db = db;
this.commandManager = commandManager;
this.commandManager.Engine = this;
this.reader = reader;
this.writer = writer;
}
public void SetUp()
{
_mocks = new MockRepository();
_commandManager = _mocks.StrictMock<ICommandManager>();
_commandLoader = _mocks.StrictMock<ICommandLoader>();
_commandHost = new CommandHost(_commandManager, _commandLoader);
}
public GameEngine(IEnumerable<IPlayer> players, ICommandManager commandManager, GameType mode, IMessageLogger logger)
{
commandManager.SetGameEngine(this);
this.commandManager = commandManager;
this.Players = players;
this.Mode = mode;
this.Logger = logger;
}
/// <summary>
/// Creates a new command. As CommandManger (Context) the global GCommandManger Singleton is used.
/// </summary>
/// <param name="execute">The execution logic.</param>
/// <param name="canExecute">The execution status logic.</param>
public WrapperCommand(ICommandUndo command, ICommandManager context) {
if (command == null)
throw new ArgumentNullException("command");
if (context == null)
throw new ArgumentNullException("context");
_context = context;
_command = command;
}
/// <summary>
/// Initializes a new instance of the <see cref="DefaultPlayer"/> class.
/// </summary>
public DefaultPlayer(IGame game, ICommandManager commandManager)
{
this.Game = game;
this.Information = new CharacterInformation();
commandManager.SetOwner(this);
this.CommandManager = commandManager;
}
public GameEngine(ICommandManager commandManager, Galaxy galaxy)
{
this.CommandManager = commandManager;
this.Galaxy = galaxy;
this.ShipFactory = new ShipFactory();
this.EnhancementFactory = new EnhancementFactory();
this.Starships = new List<IStarship>();
}
public TextModel(ICommandManager commandManager)
{
Document = new TextDocument();
_commandManager = commandManager;
Document.PropertyChanged += Document_PropertyChanged;
Document.TextChanged += DocumentOnTextChanged;
_oldText = "";
}
public FlyoutService(ITypeFactory typeFactory, ICommandManager commandManager)
{
Argument.IsNotNull(() => typeFactory);
Argument.IsNotNull(() => commandManager);
_typeFactory = typeFactory;
_commandManager = commandManager;
}
public CCommand(ICommandManager commandManager, ulong id)
{
m_comamndManager = commandManager;
m_id = id;
m_bIsViewCommand = false;
m_comamndManager.RegisterCommand(this);
}
public KeyboardMappingsService(ICommandManager commandManager, IXmlSerializer xmlSerializer)
{
Argument.IsNotNull(() => commandManager);
Argument.IsNotNull(() => xmlSerializer);
_commandManager = commandManager;
_xmlSerializer = xmlSerializer;
_fileName = Path.Combine(Path.GetApplicationDataDirectory(), "keyboardmappings.xml");
}
public void Init() {
var builder = new ContainerBuilder();
builder.RegisterType<DefaultCommandManager>().As<ICommandManager>();
builder.RegisterType<MyCommand>().As<ICommandHandler>();
builder.RegisterModule(new CommandModule());
var container = builder.Build();
_manager = container.Resolve<ICommandManager>();
}
protected override async Task <int> Execute(ICommandManager commandManager)
{
return(await commandManager.Execute(AddDeprecatedInformation(new SetTargetsCommandArgs(Name, Version, Add, Remove, Path)))
.ConfigureAwait(false));
}
public CommandLineParser(ICommandManager manager)
{
_commandManager = manager;
}
protected CommandContainerBase(string commandName, ICommandManager commandManager)
: base(commandName, commandManager)
{
}
public static void Execute(this ICommandManager commandManager, string commandVariable = "{Command2Run}",
ParameterDic parameterDic = null, IScriptRunner scriptRunner = null)
{
commandManager.Execute(commandManager.GetCommandFromDictionary(commandVariable),
parameterDic, scriptRunner);
}
/// <summary>
/// Initializes a new instance of the <see cref="CiscoVoiceModule"/> class.
/// </summary>
/// <param name="container">The container.</param>
/// <param name="viewManager">The view manager.</param>
/// <param name="commandManager">The command manager.</param>
public USDModule(IObjectContainer container, IViewManager viewManager, ICommandManager commandManager)
{
this.container = container;
this.viewManager = viewManager;
this.commandManager = commandManager;
}
/// <summary>
/// Initializes a new instance of the <see cref="CommandManagerBinding"/> class.
/// </summary>
public CommandManagerBinding()
{
var dependencyResolver = this.GetDependencyResolver();
_commandManager = dependencyResolver.Resolve <ICommandManager>();
}
/// <summary>
/// Initializes a new instance of the <see cref="ContentViewModel"/> class.
/// </summary>
/// <param name="workspace">The injected workspace.</param>
/// <param name="commandManager">The injected command manager.</param>
/// <param name="logger">The injected logger.</param>
protected ContentViewModel(IContainerExtension continer)
{
_commandManager = continer.Resolve <ICommandManager>();
_menuService = continer.Resolve <IMenuService>();
CloseCommand = new DelegateCommand <Object>(Close, CanClose);
}
protected BaseViewModel(ICommandManager commandManager)
{
_commandManager = commandManager ?? throw new ArgumentNullException(nameof(commandManager));
_commandManager.AssignOnPropertyChanged(ref PropertyChanged !);
_commandsList = new HashSet <IRemovableCommand>();
}
public HelpCommand(ICommandManager commandManager)
{
_commandManager = commandManager;
}
public DemoLongOperationCommandContainer(ICommandManager commandManager,
IPleaseWaitService pleaseWaitService)
: base(Commands.Demo.LongOperation, commandManager)
{
_pleaseWaitService = pleaseWaitService;
}
public GenericCommandInterface(ICommandManager commandManager)
{
CommandManager = commandManager;
}
public HealthService(ILogger logger, ITickManager ticks, ICommunicationManager comms, ICommandManager commands, IOverlayManager overlay, User user) : base(logger, ticks, comms, commands, overlay, user)
{
}
public CutCommandContainer(ICommandManager commandManager, IDrawingHostServices drawingHostServices)
: base(Commands.Cut, commandManager)
{
_drawingHostServices = drawingHostServices;
}
/// <summary>
/// Creates a command using a naming convention with the specified gesture.
/// </summary>
/// <param name="commandManager">The command manager.</param>
/// <param name="containerType">Type of the container.</param>
/// <param name="commandNameFieldName">Name of the command name field.</param>
/// <exception cref="ArgumentNullException">The <paramref name="commandManager"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="containerType"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="commandNameFieldName"/> is <c>null</c>.</exception>
public static void CreateCommandWithGesture(this ICommandManager commandManager, Type containerType, string commandNameFieldName)
{
Argument.IsNotNull("commandManager", commandManager);
Argument.IsNotNull("containerType", containerType);
Argument.IsNotNullOrWhitespace("commandNameFieldName", commandNameFieldName);
Log.Debug("Creating command '{0}'", commandNameFieldName);
// Note: we must store bindingflags inside variable otherwise invalid IL will be generated
var bindingFlags = BindingFlags.Public | BindingFlags.Static;
var commandNameField = containerType.GetFieldEx(commandNameFieldName, bindingFlags);
if (commandNameField == null)
{
throw Log.ErrorAndCreateException <InvalidOperationException>("Command '{0}' is not available on container type '{1}'",
commandNameFieldName, containerType.GetSafeFullName());
}
var commandName = (string)commandNameField.GetValue(null);
if (commandManager.IsCommandCreated(commandName))
{
Log.Debug("Command '{0}' is already created, skipping...", commandName);
return;
}
InputGesture commandInputGesture = null;
var inputGestureField = containerType.GetFieldEx(string.Format("{0}InputGesture", commandNameFieldName), bindingFlags);
if (inputGestureField != null)
{
commandInputGesture = inputGestureField.GetValue(null) as InputGesture;
}
commandManager.CreateCommand(commandName, commandInputGesture);
var commandContainerName = string.Format("{0}CommandContainer", commandName.Replace(".", string.Empty));
var commandContainerType = (from type in TypeCache.GetTypes()
where string.Equals(type.Name, commandContainerName, StringComparison.OrdinalIgnoreCase)
select type).FirstOrDefault();
if (commandContainerType != null)
{
Log.Debug("Found command container '{0}', registering it in the ServiceLocator now", commandContainerType.GetSafeFullName());
var serviceLocator = commandManager.GetServiceLocator();
if (!serviceLocator.IsTypeRegistered(commandContainerType))
{
var typeFactory = serviceLocator.ResolveType <ITypeFactory>();
var commandContainer = typeFactory.CreateInstance(commandContainerType);
if (commandContainer != null)
{
serviceLocator.RegisterInstance(commandContainer);
}
else
{
Log.Warning("Cannot create command container '{0}', skipping registration", commandContainerType.GetSafeFullName());
}
}
}
}
public override void InitializePlugin(IPoderosaWorld poderosa)
{
base.InitializePlugin(poderosa);
_instance = this;
_optionSupplier = new TerminalOptionsSupplier();
_keepAlive = new KeepAlive();
_customKeySettings = new CustomKeySettings();
_shellSchemeCollection = new ShellSchemeCollection();
GEnv.Init();
IPluginManager pm = poderosa.PluginManager;
ICoreServices cs = (ICoreServices)poderosa.GetAdapter(typeof(ICoreServices));
Debug.Assert(cs != null);
cs.PreferenceExtensionPoint.RegisterExtension(_optionSupplier);
cs.PreferenceExtensionPoint.RegisterExtension(_shellSchemeCollection);
_coreServices = cs;
//Serialize Service
cs.SerializerExtensionPoint.RegisterExtension(new TerminalSettingsSerializer(pm));
_commandManager = cs.CommandManager;
TerminalCommand.Register(_commandManager);
TerminalSettingMenuGroup.Initialize();
//PromptChecker
_promptCheckerWithTimer = new PromptCheckerWithTimer();
//Edit Menuに追加
IExtensionPoint editmenu = pm.FindExtensionPoint("org.poderosa.menu.edit");
editmenu.RegisterExtension(new AdvancedCopyPasteMenuGroup());
editmenu.RegisterExtension(new TerminalBufferMenuGroup());
editmenu.RegisterExtension(new SelectionMenuGroup());
//Console Menu : これは処置に困るところだが！
IExtensionPoint consolemenu = pm.FindExtensionPoint("org.poderosa.menu.console");
consolemenu.RegisterExtension(new TerminalSettingMenuGroup());
consolemenu.RegisterExtension(new IntelliSenseMenuGroup());
//Context Menu
_contextMenu = pm.CreateExtensionPoint(TerminalEmulatorConstants.TERMINAL_CONTEXT_MENU_EXTENSIONPOINT, typeof(IPoderosaMenuGroup), this);
_contextMenu.RegisterExtension(new BasicCopyPasteMenuGroup());
_contextMenu.RegisterExtension(new TerminalSettingMenuGroup());
_contextMenu.RegisterExtension(new IntelliSenseMenuGroup());
//タブのコンテキストメニュー
_documentContextMenu = pm.CreateExtensionPoint(TerminalEmulatorConstants.DOCUMENT_CONTEXT_MENU_EXTENSIONPOINT, typeof(IPoderosaMenuGroup), this);
_documentContextMenu.RegisterExtension(new PoderosaMenuGroupImpl(new PoderosaMenuItemImpl(
cs.CommandManager.Find("org.poderosa.core.session.closedocument"), GEnv.Strings, "Menu.DocumentClose")));
//ToolBar
IExtensionPoint toolbar = pm.FindExtensionPoint("org.poderosa.core.window.toolbar");
TerminalToolBar terminaltoolbar = new TerminalToolBar();
toolbar.RegisterExtension(terminaltoolbar);
GetSessionManager().AddActiveDocumentChangeListener(terminaltoolbar);
//その他 Extension
_intelliSenseExtension = pm.CreateExtensionPoint(TerminalEmulatorConstants.INTELLISENSE_CANDIDATE_EXTENSIONPOINT, typeof(IIntelliSenseCandidateExtension), this);
_autoLogFileFormatter = pm.CreateExtensionPoint(TerminalEmulatorConstants.LOG_FILENAME_FORMATTER_EXTENSIONPOINT, typeof(IAutoLogFileFormatter), this);
_dynamicCaptionFormatter = pm.CreateExtensionPoint(TerminalEmulatorConstants.DYNAMIC_CAPTION_FORMATTER_EXTENSIONPOINT, typeof(IDynamicCaptionFormatter), this);
//Command Popup
CommandResultSession.Init(poderosa);
PopupStyleCommandResultRecognizer.CreateExtensionPointAndDefaultCommands(pm);
// Preferences for PromptRecognizer
cs.PreferenceExtensionPoint.RegisterExtension(PromptRecognizerPreferences.Instance);
// Preferences for XTerm
cs.PreferenceExtensionPoint.RegisterExtension(XTermPreferences.Instance);
}
public static void SetCommandManager(DependencyObject obj, ICommandManager value)
{
obj.SetValue(CommandManagerProperty, value);
}
public ApplicationInitializationService(ITypeFactory typeFactory, IServiceLocator serviceLocator, ICommandManager commandManager)
{
Argument.IsNotNull(() => typeFactory);
Argument.IsNotNull(() => serviceLocator);
Argument.IsNotNull(() => commandManager);
_typeFactory = typeFactory;
_serviceLocator = serviceLocator;
_commandManager = commandManager;
}
public Ball() : base(ServiceProvider.Instance.Resolve <SpriteBatch>(), Constants.EntityIds.BallId)
{
_moveCommand = new MoveCommand <Ball>(this, 4, new Vector2(1f, 0.15f));
_commandManager = ServiceProvider.Instance.Resolve <ICommandManager>();
}
public SettingsForm(Mapping mapping, ICommandManager commandManager)
{
this.mapping = mapping;
InitializeComponent();
string vs = null;
if (mapping != null)
{
vs = Configs.Instance.GetRecentProperty(mapping.Filename, Configs.PROPERTY_EDITOR);
}
else
{
cbApplyVsToProject.Checked = cbApplyVsToProject.Enabled = false;
}
if (vs == null)
{
vs = Configs.Instance.Editor;
}
IVisualStudioInfo selected = VisualStudioDetector.GetVisualStudioInfo(vs);
if (selected == null)
{
selected = VisualStudioDetector.GetHighestVisualStudio();
}
foreach (IVisualStudioInfo info in VisualStudioDetector.GetVisualStudios())
{
BrokenListItem item = new BrokenListItem(info.Description);
try
{
Icon icon = Icon.ExtractAssociatedIcon(info.Path);
imageList.Images.Add(icon);
item.ImageIndex = imageList.Images.Count - 1;
}
catch { }
item.Tag = info;
blvEditors.Items.Add(item);
if (info == selected)
{
item.Selected = true;
}
}
cbShowUnicode.Checked = Configs.Instance.ShowUnicode;
cbSimplifySystemNames.Checked = Configs.Instance.SimplifySystemNames;
cbSimplifyNullable.Checked = Configs.Instance.SimplifyNullable;
cbSimplifyRef.Checked = Configs.Instance.SimplifyRef;
cbGroupByNamespaces.Checked = Configs.Instance.GroupNamespaces;
cbGroupByModules.Checked = Configs.Instance.GroupModules;
cbUseColumns.Checked = Configs.Instance.UseColumns;
cbWatchClipboard.Checked = Configs.Instance.WatchClipboard;
EnumHelper.FillCombobox(cbDoubleClick, Configs.Instance.DoubleClickAction);
EnumHelper.FillCombobox(cbUpdateInterval, Configs.Instance.UpdateHelper.Interval);
commandSelector.CommandManager = commandManager;
commandSelector.CommandType = typeof(Actions);
}
public MainViewModel(
[NotNull] SynchronizationContext synchronizationContext,
[NotNull] IProcessUtility processUtility,
[NotNull] IMessageHub messageHub,
[NotNull] ICmdUtility cmdUtility,
[NotNull] IGitUtility gitUtility,
[NotNull] Func <string, GitInfo, TfsInfo, ShelveViewModel> shelveViewModelFactory,
[NotNull] Func <string, GitInfo, TfsInfo, UnshelveViewModel> unshelveViewModelFactory,
[NotNull] Func <string, TfsInfo, PullViewModel> pullViewModelFactory,
[NotNull] IGitTfsUtility gitTfsUtility,
[NotNull] ITfsUtility tfsUtility,
[NotNull] ICancellationTokenSourceProvider cancellationTokenSourceProvider,
[NotNull] Func <string, bool, ConfirmationViewModel> confirmationViewModelFactory,
[NotNull] Func <ConfirmationViewModel, IConfirmationWindow> confirmationWindowFactory,
[NotNull] ICommandManager commandManager,
[NotNull] IRateLimiter rateLimiter)
: base(commandManager)
{
_ = rateLimiter ?? throw new ArgumentNullException(nameof(rateLimiter));
_tfsUtility = tfsUtility;
_cancellationTokenSourceProvider = cancellationTokenSourceProvider ?? throw new ArgumentNullException(nameof(cancellationTokenSourceProvider));
_confirmationViewModelFactory = confirmationViewModelFactory ?? throw new ArgumentNullException(nameof(confirmationViewModelFactory));
_confirmationWindowFactory = confirmationWindowFactory ?? throw new ArgumentNullException(nameof(confirmationWindowFactory));
_rateLimiter = rateLimiter;
_pullViewModelFactory = pullViewModelFactory ?? throw new ArgumentNullException(nameof(pullViewModelFactory));
_synchronizationContext = synchronizationContext ?? throw new ArgumentNullException(nameof(synchronizationContext));
processUtility = processUtility ?? throw new ArgumentNullException(nameof(processUtility));
_messageHub = messageHub ?? throw new ArgumentNullException(nameof(messageHub));
_cmdUtility = cmdUtility ?? throw new ArgumentNullException(nameof(cmdUtility));
_gitUtility = gitUtility ?? throw new ArgumentNullException(nameof(gitUtility));
_gitTfsUtility = gitTfsUtility ?? throw new ArgumentNullException(nameof(gitTfsUtility));
_shelveViewModelFactory = shelveViewModelFactory ?? throw new ArgumentNullException(nameof(shelveViewModelFactory));
_unshelveViewModelFactory = unshelveViewModelFactory ?? throw new ArgumentNullException(nameof(unshelveViewModelFactory));
processUtility.ProcessMessageFired += ProcessUtility_ProcessMessageFired;
processUtility.ProcessErrorFired += ProcessUtility_ProcessErrorFired;
ChooseDirectoryCommand = AddCommand(ChooseDirectoryAsync, () => CanBrowse);
SetDirectoryCommand = AddCommand <string>(SetDirectoryAsync, directory => CanBrowse);
PullCommand = AddCommand(GitTfsPull, () => CanExecuteGitTfsAction);
OpenShelveDialogCommand = AddCommand(OpenShelveDialogAsync, () => CanExecuteGitTfsAction);
OpenUnshelveDialogCommand = AddCommand(OpenUnshelveDialogAsync, () => CanExecuteGitTfsAction);
WindowClosingCommand = AddCommand(WindowClosing);
CancelCommand = AddCommand(Cancel, () => CanCancel);
CopyShelvesetToClipboardCommand = AddCommand(CopyShelvesetToClipboard, () => CreatedShelvesetName != null);
OpenShelvesetInBrowserCommand = AddCommand(OpenShelvesetInBrowser, () => _createdShelvesetUrl != null);
ShowLogsCommand = AddCommand(ProcessCommands.ViewLogs);
_dialog = new CommonOpenFileDialog
{
IsFolderPicker = true,
InitialDirectory = DirectoryPath
};
var savedUsedPaths = Settings.Default.UsedDirectoryPaths;
UsedPaths = string.IsNullOrEmpty(savedUsedPaths)
? new ObservableCollection <string>()
: new ObservableCollection <string>(savedUsedPaths.Split(UsedPathsSeparator).Select(x => x.Trim()).Where(x => x != string.Empty));
if (!string.IsNullOrWhiteSpace(Settings.Default.DirectoryPath))
{
_ = SetDirectoryAsync(Settings.Default.DirectoryPath);
}
_subscriptionTokens.Add(messageHub.Subscribe <Message>(OnNewMessage));
_subscriptionTokens.Add(messageHub.Subscribe <TaskState>(OnTaskAction));
_subscriptionTokens.Add(messageHub.Subscribe <CancellationState>(OnCancellationStateChange));
_subscriptionTokens.Add(messageHub.Subscribe <DialogType>(OnDialogChanged));
_subscriptionTokens.Add(messageHub.Subscribe <GitInfo>(OnGitInfoChanged));
_subscriptionTokens.Add(messageHub.Subscribe <TfsInfo>(OnTfsInfoChanged));
_subscriptionTokens.Add(messageHub.Subscribe <ShelvesetData>(OnShelvesetEvent));
_fileSystemWatcher = new FileSystemWatcher
{
Filter = "HEAD.lock",
IncludeSubdirectories = true,
InternalBufferSize = 64 * 1024
};
_fileSystemWatcher.Changed += FileSystemWatcher_Changed;
Version = GetProgramVersion();
}
public ApplicationShowSettingsCommandContainer(ICommandManager commandManager)
: base(AppCommands.Application.ShowSettings, commandManager)
{
}
/// <summary>
/// Initialize processor.
/// </summary>
/// <param name="commandManager">Manager of Commands.</param>
/// <param name="unitManager">Manager of Command units.</param>
public void Initialize(ICommandManager commandManager, ICommandUnitManager unitManager)
{
CommandManager = commandManager;
CommandUnitManager = unitManager;
}
static public void Init(ICommandManager commandManager)
{
commandManager.AddCommandHandler(new UPNP());
}
public HelpOpenDocumentationLinkCommandContainer(ICommandManager commandManager,
IUIVisualizerService uiVisualizerService,
IViewModelFactory viewModelFactory, IServiceLocator serviceLocator)
: base(Commands.Help.OpenDocumentationLink, commandManager)
{
}
/// <summary>
/// Execute an Explorer command.
/// </summary>
/// <param name="command"></param>
/// <param name="parameterDic"></param>
/// <param name="scriptRunner"></param>
/// <returns></returns>
public static async Task ExecuteAsync(this ICommandManager commandManager, IScriptCommand[] commands,
ParameterDic parameterDic = null, IScriptRunner scriptRunner = null)
{
scriptRunner = scriptRunner ?? new ScriptRunner();
await scriptRunner.RunAsync(commandManager.ParameterDicConverter.ConvertAndMerge(parameterDic), commands);
}
public StartService(ILogger logger, ITickManager ticks, IEventManager events, IRpcHandler rpc, ICommandManager commands, OverlayManager overlayManager, User user) : base(logger, ticks, events, rpc, commands, overlayManager, user)
{
}
/// <summary>
/// Execute an Explorer command.
/// </summary>
/// <param name="command"></param>
/// <param name="parameterDic"></param>
/// <param name="scriptRunner"></param>
/// <returns></returns>
public static async Task ExecuteAsync(this ICommandManager commandManager, IScriptCommand command,
ParameterDic parameterDic = null, IScriptRunner scriptRunner = null)
{
await ExecuteAsync(commandManager, new IScriptCommand[] { command }, parameterDic, scriptRunner);
}
public PluginAdminService(ILogger logger, ITickManager ticks, IEventManager events, IRpcHandler rpc, ICommandManager commands, OverlayManager overlay, User user) : base(logger, ticks, events, rpc, commands, overlay, user)
{
this.Commands.Register("car", new Action <string>(Car));
this.Commands.Register("dv", new Action(Dv));
this.Commands.Register("noclip", new Action(ToggleNoclip));
}
/// <summary>
/// Initializes a new instance of the <see cref="ContentViewModel" /> class.
/// </summary>
/// <param name="workspace">The injected workspace.</param>
/// <param name="commandManager">The injected command manager.</param>
/// <param name="logger">The injected logger.</param>
/// <param name="menuService">The menu service.</param>
public HSViewModel(AbstractWorkspace workspace, ICommandManager commandManager, ILoggerService logger,
IMenuService menuService)
: base(workspace, commandManager, logger, menuService)
{
}
protected ToggleConfigurationCommandContainerBase(string commandName, string configurationKey, bool defaultValue, ICommandManager commandManager, IConfigurationService configurationService)
: base(commandName, configurationKey, defaultValue, commandManager, configurationService)
{
}
