/// <summary>Initializes a new instance of the <see cref="T:Gorgon.Editor.SpriteEditor.ImporterPlugInSettings"/> class.</summary> public ImporterPlugInSettings() { ID = Guid.NewGuid(); WriteSettingsCommand = new EditorCommand <object>(DoWriteSettings); LoadPlugInAssemblyCommand = new EditorCommand <object>(DoLoadPlugInAssembly); UnloadPlugInAssembliesCommand = new EditorCommand <object>(DoUnloadPlugInAssemblies, CanUnloadPlugInAssemblies); }
public static void Main() { try { using (IEngine engine = EngineFactory.Create(new EngineOptions.Builder().Build())) { Console.WriteLine("Engine created"); using (IBrowser browser = engine.CreateBrowser()) { Console.WriteLine("Browser created"); browser.Navigation.LoadUrl("http://www.google.com") .Wait(); // Inserts "TeamDev DotNetBrowser" text into Google Search field. browser.MainFrame.Execute(EditorCommand.InsertText("TeamDev DotNetBrowser")); // Inserts a new line into Google Search field to simulate Enter. browser.MainFrame.Execute(EditorCommand.InsertNewLine()); Thread.Sleep(3000); // The page will now contain search results. Console.WriteLine("Page contents:"); Console.WriteLine(browser.MainFrame.Document.DocumentElement.InnerText); } } } catch (Exception e) { Console.WriteLine(e); } Console.WriteLine("Press any key to terminate..."); Console.ReadKey(); }
internal static bool GetEnabled(EditorCommand command) { var sf = App.SelectedShapefile; if (sf == null) { return(false); } switch (command) { case EditorCommand.Undo: return(App.Map.UndoList.UndoCount > 0); case EditorCommand.Redo: return(App.Map.UndoList.RedoCount > 0); case EditorCommand.Copy: return(sf.NumSelected > 0); case EditorCommand.Cut: return(sf.NumSelected > 0 && sf.InteractiveEditing); case EditorCommand.Paste: return(!OperationHelper.BufferIsEmpty && sf.InteractiveEditing); } return(false); }
public static void Main() { try { using (IEngine engine = EngineFactory.Create(new EngineOptions.Builder().Build())) { Console.WriteLine("Engine created"); using (IBrowser browser = engine.CreateBrowser()) { Console.WriteLine("Browser created"); browser.Size = new Size(700, 500); browser.Navigation.LoadUrl("https://www.teamdev.com").Wait(); browser.MainFrame.Execute(EditorCommand.SelectAll()); Console.WriteLine("Current selection:"); Console.WriteLine($"\tSelected text: {browser.MainFrame.SelectedText}"); Console.WriteLine($"\tSelected HTML: {browser.MainFrame.SelectedHtml}"); } } } catch (Exception e) { Console.WriteLine(e); } Console.WriteLine("Press any key to terminate..."); Console.ReadKey(); }
private void ExtensionService_ExtensionRemovedAsync(object sender, EditorCommand e) { _languageServer?.SendNotification <ExtensionCommandRemovedNotification>("powerShell/extensionCommandRemoved", new ExtensionCommandRemovedNotification { Name = e.Name, }); }
private void ExtensionService_ExtensionAddedAsync(object sender, EditorCommand e) { _languageServer.SendNotification <ExtensionCommandAddedNotification>("powerShell/extensionCommandAdded", new ExtensionCommandAddedNotification { Name = e.Name, DisplayName = e.DisplayName }); }
private async void ExtensionService_ExtensionRemoved(object sender, EditorCommand e) { await this.SendEvent( ExtensionCommandRemovedNotification.Type, new ExtensionCommandRemovedNotification { Name = e.Name, }); }
private static void Edit(AppViewModel item, EditorCommand command) { var view = item?.Workspace?.SelectedItem?.View; if (view is IEditor editor) { command.Execute(editor.Editor); Keyboard.Focus(editor.Editor); } }
private async void ExtensionService_ExtensionAdded(object sender, EditorCommand e) { await this.SendEvent( ExtensionCommandAddedNotification.Type, new ExtensionCommandAddedNotification { Name = e.Name, DisplayName = e.DisplayName }); }
public override bool TryGetCommand(string commandId, out EditorCommand command) { var commandSpec = GetCommandSpec(commandId); if (commandSpec == null) { command = default(EditorCommand); return(false); } command = ToEditorCommand(commandSpec, commandId); return(true); }
public void Update (IEditor editor, EditorCommand editorCommand) { this.editor = editor; this.editorCommand = editorCommand; if (editor == null) { editorCommand = default(EditorCommand); status = EditorCommandStatus.Unsupported; } else status = editor.GetCommandStatus (editorCommand); CanExecuteChanged?.Invoke (this, EventArgs.Empty); }
public async Task CanUpdateRegisteredCommand() { // Register a command and then update it await extensionService.PowerShellContext.ExecuteScriptStringAsync(TestUtilities.NormalizeNewlines( "function Invoke-Extension { Write-Output \"Extension output!\" }\n" + "Register-EditorCommand -Name \"test.function\" -DisplayName \"Function extension\" -Function \"Invoke-Extension\"\n" + "Register-EditorCommand -Name \"test.function\" -DisplayName \"Updated Function extension\" -Function \"Invoke-Extension\"")); // Wait for the add and update events await this.AssertExtensionEvent(EventType.Add, "test.function"); EditorCommand updatedCommand = await this.AssertExtensionEvent(EventType.Update, "test.function"); Assert.Equal("Updated Function extension", updatedCommand.DisplayName); }
public void Bind(IEditor editor) { currentEditor = editor; if (editor == null || !editor.TryGetCommand(commandId, out command)) { command = default(EditorCommand); status = EditorCommandStatus.Unsupported; } else { Title = command.Title; status = editor.GetCommandStatus(command); } Hidden = status == EditorCommandStatus.Hidden || status == EditorCommandStatus.Unsupported; }
/// <summary> /// Unregisters an existing EditorCommand based on its registered name. /// </summary> /// <param name="commandName">The name of the command to be unregistered.</param> public void UnregisterCommand(string commandName) { EditorCommand existingCommand = null; if (this.editorCommands.TryGetValue(commandName, out existingCommand)) { this.editorCommands.Remove(commandName); this.OnCommandRemoved(existingCommand); } else { throw new KeyNotFoundException( string.Format( "Command '{0}' is not registered", commandName)); } }
public EditorToggleContextualMenuChoice(string name, List<string> labels, float textSize, List<EditorCommand> commands) : base(name, labels, new Text(labels[0], @"Pixelite") { SizeX = textSize }) { if (commands.Count != labels.Count) { Commands = new List<EditorCommand>(); for (int i = 0; i < labels.Count; i++) Commands.Add(commands[0]); } else { Commands = commands; } Command = Commands[CurrentIndex]; }
public static void OnDoEditorCommandCallback(EditorCommand editorCommand, TimelinableTrackBase[] tracks) { switch (editorCommand) { case EditorCommand.Copy: break; case EditorCommand.Paste: DoEditorOperation_Paste(tracks); break; case EditorCommand.Delete: DoEditorOperation_Delete(tracks); break; default: break; } }
public async Task CanRegisterAndInvokeCommandWithScriptBlock() { await extensionService.PowerShellContext.ExecuteScriptStringAsync( "Register-EditorCommand -Name \"test.scriptblock\" -DisplayName \"ScriptBlock extension\" -ScriptBlock { $global:extensionValue = 10 }"); // Wait for the add event EditorCommand command = await this.AssertExtensionEvent(EventType.Add, "test.scriptblock"); // Invoke the command await extensionService.InvokeCommandAsync("test.scriptblock", this.commandContext); // Assert the expected value PSCommand psCommand = new PSCommand(); psCommand.AddScript("$global:extensionValue"); var results = await powerShellContext.ExecuteCommandAsync <int>(psCommand); Assert.Equal(10, results.FirstOrDefault()); }
public async Task CanRegisterAndInvokeCommandWithCmdletName() { await extensionService.PowerShellContext.ExecuteScriptStringAsync( TestUtilities.NormalizeNewlines("function Invoke-Extension { $global:extensionValue = 5 }\n") + "Register-EditorCommand -Name \"test.function\" -DisplayName \"Function extension\" -Function \"Invoke-Extension\""); // Wait for the add event EditorCommand command = await this.AssertExtensionEvent(EventType.Add, "test.function"); // Invoke the command await extensionService.InvokeCommandAsync("test.function", this.commandContext); // Assert the expected value PSCommand psCommand = new PSCommand(); psCommand.AddScript("$global:extensionValue"); var results = await powerShellContext.ExecuteCommandAsync <int>(psCommand); Assert.Equal(5, results.FirstOrDefault()); }
/// <summary> /// Registers a new EditorCommand with the ExtensionService and /// causes its details to be sent to the host editor. /// </summary> /// <param name="editorCommand">The details about the editor command to be registered.</param> /// <returns>True if the command is newly registered, false if the command already exists.</returns> public bool RegisterCommand(EditorCommand editorCommand) { bool commandExists = this.editorCommands.ContainsKey( editorCommand.Name); // Add or replace the editor command this.editorCommands[editorCommand.Name] = editorCommand; if (!commandExists) { this.OnCommandAdded(editorCommand); } else { this.OnCommandUpdated(editorCommand); } return(!commandExists); }
public async Task CanUnregisterCommand() { string filePath = TestUtilities.NormalizePath("C:\\Temp\\Test.ps1"); ScriptFile currentFile = new(new Uri(filePath), "This is a test file", new Version("7.0")); EditorContext editorContext = new( editorOperations : null, currentFile, new BufferPosition(line : 1, column : 1), BufferRange.None); const string commandName = "test.scriptblock"; const string commandDisplayName = "ScriptBlock extension"; EditorCommand removedCommand = null; extensionCommandService.CommandRemoved += (object _, EditorCommand command) => removedCommand = command; // Add the command and wait for the add event await psesHost.ExecutePSCommandAsync( new PSCommand() .AddCommand("Register-EditorCommand") .AddParameter("Name", commandName) .AddParameter("DisplayName", commandDisplayName) .AddParameter("ScriptBlock", ScriptBlock.Create("Write-Output \"Extension output!\"")), CancellationToken.None).ConfigureAwait(true); // Remove the command and wait for the remove event await psesHost.ExecutePSCommandAsync( new PSCommand().AddCommand("Unregister-EditorCommand").AddParameter("Name", commandName), CancellationToken.None).ConfigureAwait(true); Assert.NotNull(removedCommand); Assert.Equal(commandName, removedCommand.Name); Assert.Equal(commandDisplayName, removedCommand.DisplayName); // Ensure that the command has been unregistered await Assert.ThrowsAsync <KeyNotFoundException>( () => extensionCommandService.InvokeCommandAsync("test.scriptblock", editorContext)).ConfigureAwait(true); }
public async Task CanUpdateRegisteredCommand() { EditorCommand updatedCommand = null; extensionCommandService.CommandUpdated += (object _, EditorCommand command) => updatedCommand = command; const string commandName = "test.function"; const string commandDisplayName = "Updated function extension"; // Register a command and then update it await psesHost.ExecutePSCommandAsync( new PSCommand().AddScript( "function Invoke-Extension { Write-Output \"Extension output!\" }; " + $"Register-EditorCommand -Name {commandName} -DisplayName \"Old function extension\" -Function Invoke-Extension; " + $"Register-EditorCommand -Name {commandName} -DisplayName \"{commandDisplayName}\" -Function Invoke-Extension"), CancellationToken.None).ConfigureAwait(true); // Wait for the add and update events Assert.NotNull(updatedCommand); Assert.Equal(commandName, updatedCommand.Name); Assert.Equal(commandDisplayName, updatedCommand.DisplayName); }
public async Task CanRegisterAndInvokeCommandWithScriptBlock() { string filePath = TestUtilities.NormalizePath("C:\\Temp\\Test.ps1"); ScriptFile currentFile = new(new Uri(filePath), "This is a test file", new Version("7.0")); EditorContext editorContext = new( editorOperations : null, currentFile, new BufferPosition(line : 1, column : 1), BufferRange.None); EditorCommand commandAdded = null; extensionCommandService.CommandAdded += (object _, EditorCommand command) => commandAdded = command; const string commandName = "test.scriptblock"; const string commandDisplayName = "ScriptBlock extension"; await psesHost.ExecutePSCommandAsync( new PSCommand() .AddCommand("Register-EditorCommand") .AddParameter("Name", commandName) .AddParameter("DisplayName", commandDisplayName) .AddParameter("ScriptBlock", ScriptBlock.Create("$global:extensionValue = 10")), CancellationToken.None).ConfigureAwait(true); Assert.NotNull(commandAdded); Assert.Equal(commandName, commandAdded.Name); Assert.Equal(commandDisplayName, commandAdded.DisplayName); // Invoke the command await extensionCommandService.InvokeCommandAsync("test.scriptblock", editorContext).ConfigureAwait(true); // Assert the expected value PSCommand psCommand = new PSCommand().AddScript("$global:extensionValue"); IEnumerable <int> results = await psesHost.ExecutePSCommandAsync <int>(psCommand, CancellationToken.None).ConfigureAwait(true); Assert.Equal(10, results.FirstOrDefault()); }
void btnCommand_Checked(object sender, EventArgs e) { ToolStripButton clickBtn = sender as ToolStripButton; if (!clickBtn.Checked) { return; } EditorCommand cmd = (EditorCommand)clickBtn.Tag; bool ok = true; if (cmd == EditorCommand.TerrainMode) { ok = NLevelEditorEngine.Instance.BindSelectedActorToTerrainEd(); if (!ok) { NexusEditor.Program.ShowError("Please Select a Terrain First!"); } } // 开启或者关闭导航图编辑模式 if (cmd == EditorCommand.NavigateMapMode) { NLevelEditorEngine.Instance.NavigateMapEd.BeginNavigateMapEditor(NLevelEditorEngine.Instance.MainLevel); } else { NLevelEditorEngine.Instance.NavigateMapEd.EndNavigateMapEditor(); } if (ok) { NLevelEditorEngine.Instance.Command = cmd; } }
private void OnCommandRemoved(EditorCommand command) { this.CommandRemoved?.Invoke(this, command); }
public void addCommand(Graphics imgGra, EditorCommand command) { this.history.Push(command); command.process(imgGra); }
/// <summary> /// Returns all registered EditorCommands. /// </summary> /// <returns>An Array of all registered EditorCommands.</returns> public EditorCommand[] GetCommands() { EditorCommand[] commands = new EditorCommand[this.editorCommands.Count]; this.editorCommands.Values.CopyTo(commands, 0); return(commands); }
public bool RegisterCommand(EditorCommand editorCommand) => _extensionService.RegisterCommand(editorCommand);
private void OnCommandRemoved(object sender, EditorCommand editorCommand) { CommandRemoved?.Invoke(this, editorCommand); }
private void DoExecuteEditorCommand(EditorCommand command) { // toggle editor mode command if (command.Name == "PlaytestState") { Simulator.EditorState = EditorState.Playtest; Simulator.SyncLevel(); Simulator.Initialize(); Simulator.SyncPlayers(); } else if (command.Name == "EditState") { Simulator.EditorState = EditorState.Editing; Simulator.Initialize(); Simulator.SyncPlayers(); } else if (command.Name == "RestartSimulation") { if (Simulator.EditorState == EditorState.Editing) Simulator.SyncLevel(); Simulator.Initialize(); Simulator.SyncPlayers(); } else if (command.Name == "PauseSimulation") { Simulator.State = GameState.Paused; } else if (command.Name == "ResumeSimulation") { Simulator.State = GameState.Running; } else if (command.Name == "NewLevel") { Simulator.LevelDescriptor = Main.LevelsFactory.GetEmptyDescriptor(); Simulator.Initialize(); Simulator.SyncPlayers(); } else if (command.Name == "SaveLevel") { Simulator.SyncLevel(); var descriptor = Simulator.LevelDescriptor; if (!Main.LevelsFactory.UserDescriptors.ContainsKey(descriptor.Infos.Id)) { Main.LevelsFactory.UserDescriptors.Add(descriptor.Infos.Id, descriptor); ((LevelsPanel) Panels[EditorPanel.Load]).Initialize(); ((LevelsPanel) Panels[EditorPanel.Delete]).Initialize(); } Main.LevelsFactory.SaveUserDescriptorOnDisk(descriptor.Infos.Id); } NotifyEditorCommandExecuted(command); }
public EditorTextContextualMenuChoice(string name, string label, float textSize, EditorCommand command) : base(name, new Text(label, @"Pixelite") { SizeX = textSize }) { Command = command; }
public void DoEditorCommandExecuted(EditorCommand command) { if (command.Name == "AddOrRemovePowerUp") Initialize(); }
public override void SetChoice(int index) { base.SetChoice(index); Command = Commands[CurrentIndex]; }
public void ExecuteCommand(EditorCommand command) { }
public void DoEditorCommandExecuted(EditorCommand command) { if (command.Name == "AddOrRemovePowerUp") { InitializePowerUpsAndTurrets(); CheckAvailablePowerUps(); foreach (var pl in Players.Values) pl.Initialize(); return; } if (command.Type == EditorCommandType.Panel) { if (((EditorPanelCommand) command).Show) { foreach (var player in Players.Values) { player.ActualSelection.CelestialBody = null; player.ActualSelection.Turret = null; player.ActualSelection.TurretToPlace = null; NotifyPlayerChanged(player); } UpdateSelection = false; foreach (var player in Players.Values) player.UpdateSelectionz = false; } else { UpdateSelection = true; foreach (var player in Players.Values) player.UpdateSelectionz = true; } return; } }
public bool TryGetCommand(string commandId, out EditorCommand command) { command = default(EditorCommand); return(false); }
public EditorCommandStatus GetCommandStatus(EditorCommand command) => EditorCommandStatus.Unsupported;
public void DoEditorCommandExecuted(EditorCommand command) { if (command.Name == "PlaytestState" || command.Name == "EditState") { ((EditorToggleContextualMenuChoice) GeneralMenu.SubMenus[EditorGeneralMenuChoice.File].GetChoice(4)).Next(); return; } if (command.Name == "PauseSimulation" || command.Name == "ResumeSimulation") { ((EditorToggleContextualMenuChoice) GeneralMenu.SubMenus[EditorGeneralMenuChoice.File].GetChoice(6)).Next(); return; } if (command.Name == "ShowCelestialBodiesPaths" || command.Name == "HideCelestialBodiesPaths") { ((EditorToggleContextualMenuChoice) GeneralMenu.SubMenus[EditorGeneralMenuChoice.Battlefield].GetChoice(1)).Next(); return; } if (command.Type == EditorCommandType.Panel) { var panelCommand = (EditorPanelCommand) command; Panels[panelCommand.Panel].Fade(panelCommand.Show ? 0 : 255, panelCommand.Show ? 255 : 0, 500); return; } if (command.Type == EditorCommandType.CelestialBody) DoEditorCelestialBodyCommandExecuted((EditorCelestialBodyCommand) command); }
public void DoEditorCommandExecuted(EditorCommand c) { if (c.Type != EditorCommandType.CelestialBody) return; var command = (EditorCelestialBodyCommand) c; if (command.Name == "AddPlanet") { command.CelestialBody.PathPriority = GetLowestPathPriority(CelestialBodies) - 1; command.CelestialBody.AliveOverride = true; command.CelestialBody.CanSelectOverride = true; CelestialBodies.Add(command.CelestialBody); } else if (command.Name == "Remove") { command.CelestialBody.LifePoints = 0; command.CelestialBody.AliveOverride = false; } else if (command.Name == "ToggleSpeed") { command.CelestialBody.SetSpeed(command.Speed); } else if (command.Name == "ToggleAsset") { command.CelestialBody.SetImage(command.AssetName); } else if (command.Name == "PushFirst") { if (!Path.ContainsCelestialBody(command.CelestialBody)) AddToStartingPath(command.CelestialBody); Path.RemoveCelestialBody(command.CelestialBody); command.CelestialBody.PathPriority = GetLowestPathPriority(CelestialBodies) - 1; Path.AddCelestialBody(command.CelestialBody, false); } else if (command.Name == "PushLast") { if (!Path.ContainsCelestialBody(command.CelestialBody)) AddToStartingPath(command.CelestialBody); Path.RemoveCelestialBody(command.CelestialBody); command.CelestialBody.PathPriority = GetHighestPathPriority(CelestialBodies) + 1; Path.AddCelestialBody(command.CelestialBody, false); } else if (command.Name == "ToggleSize") { command.CelestialBody.SetSize(command.Size); command.CelestialBody.SetImage(command.CelestialBody.PartialImageName); } else if (command.Name == "HasMoons") { command.CelestialBody.SetHasMoons(command.HasMoons); } else if (command.Name == "FollowPath") { command.CelestialBody.FollowPath = command.FollowPath; } else if (command.Name == "CanSelect") { command.CelestialBody.CanSelect = command.CanSelect; } else if (command.Name == "StraightLine") { command.CelestialBody.StraightLine = command.StraightLine; } else if (command.Name == "Invincible") { command.CelestialBody.Invincible = command.Invincible; } else if (command.Name == "AddGravitationalTurret") { AddToStartingPath(command.CelestialBody); } else if (command.Name == "RemoveGravitationalTurret") { RemoveFromStartingPath(command.CelestialBody); } else if (command.Name == "Clear") { foreach (var cb in CelestialBodies) { if (cb is AsteroidBelt) continue; cb.LifePoints = 0; cb.AliveOverride = false; } } }
public override void Previous() { base.Previous(); Command = Commands[CurrentIndex]; }
private void ExecuteCommand(EditorCommand command) { if (command is EditorCelestialBodyCommand) DoExecuteEditorCelestialBodyCommand((EditorCelestialBodyCommand) command); else if (command is EditorPanelCommand) DoExecuteEditorPanelCommand((EditorPanelCommand) command); else DoExecuteEditorCommand(command); }
public override void Next() { base.Next(); Command = Commands[CurrentIndex]; }
private void NotifyEditorCommandExecuted(EditorCommand command) { if (EditorCommandExecuted != null) EditorCommandExecuted(command); }
public void addCommand(EditorCommand command) { this.history.Push(command); command.process(); this.onPropertyChange("Count"); }
private async void ExtensionService_ExtensionRemoved(object sender, EditorCommand e) { await this.extensionEventQueue.EnqueueAsync( new Tuple <EventType, EditorCommand>(EventType.Remove, e)); }
private void SetCurrentCommand(EditorCommand command) { CurrentEditorCommand = command; switch (command) { case EditorCommand.Paint: case EditorCommand.PaintArea: case EditorCommand.CreateTeleportEnd: case EditorCommand.CreateTeleportStart: case EditorCommand.SetImpassable: case EditorCommand.SetPassable: case EditorCommand.SetStartupSpot: Cursor = Cursors.Hand; break; case EditorCommand.Select: Cursor = Cursors.Arrow; break; case EditorCommand.Erase: Cursor = Cursors.Cross; break; } }
public void DoEditorCommandExecuted(EditorCommand c) { switch (c.Type) { case EditorCommandType.CelestialBody: DoEditorCelestialBodyCommand((EditorCelestialBodyCommand) c); break; case EditorCommandType.Player: DoEditorPlayerCommand((EditorPlayerCommand) c); break; } }
public void DoEditorCommandExecuted(EditorCommand command) { if (command.Name == "AddOrRemovePowerUp") { MenuPowerUps.Position = new Vector3(-550, 200, 0); MenuPowerUps.Initialize(); } else if (command.Name == "Clear") { //PlayerLives.CelestialBody = null; } else if (command.Name == "AddPlanet" || command.Name == "PushFirst" || command.Name == "PushLast") { //PlayerLives.CelestialBody = Level.CelestialBodyToProtect; } else if (command.Name == "Remove") { //PlayerLives.CelestialBody = Level.CelestialBodyToProtect; } else if (command.Name == "ToggleSize") { var c = (EditorCelestialBodyCommand) command; //if (c.CelestialBody == PlayerLives.CelestialBody) //{ // PlayerLives.CelestialBody = null; // PlayerLives.CelestialBody = c.CelestialBody; //} } else if (command.Name == "ShowCelestialBodiesPaths") { AdvancedView.Visible = true; } else if (command.Name == "HideCelestialBodiesPaths") { AdvancedView.Visible = false; } }