public PowerShellRawUI(PowerShellConsoleModel model) { _model = model; ForegroundColor = ConsoleColor.White; BackgroundColor = ConsoleColor.Black; CursorPosition = new Coordinates(0, 0); }
public ScriptingHostRawUserInterface(ApplicationSettings settings) { Output = new OutputBuffer(); backgroundColor = settings.BackgroundColor; foregroundColor = settings.ForegroundColor; cursorPosition = new Coordinates(0, 0); windowPosition = new Coordinates(0, 0); cursorSize = 1; bufferSize = new Size(settings.HostWidth, Int32.MaxValue); windowSize = bufferSize; }
internal ProgressPane(ConsoleHostUserInterface ui) { this.location = new Coordinates(0, 0); if (ui != null) { this.ui = ui; this.rawui = ui.RawUI; return; } else { throw new ArgumentNullException("ui"); } }
internal void Show() { BufferCell[,] bufferCellArray = this.progressRegion; if (bufferCellArray != null) { int length = bufferCellArray.GetLength(0); int num = bufferCellArray.GetLength(1); this.location = this.rawui.WindowPosition; this.location.X = 0; this.location.Y = Math.Min(this.location.Y + 2, this.bufSize.Height); this.savedRegion = this.rawui.GetBufferContents(new Rectangle(this.location.X, this.location.Y, this.location.X + num - 1, this.location.Y + length - 1)); this.rawui.SetBufferContents(this.location, bufferCellArray); return; } else { return; } }
public override void SetBufferContents(Coordinates origin, BufferCell[,] contents) { throw new NotImplementedException(); }
public override void SetBufferContents(Coordinates origin, BufferCell[,] contents) { throw new NotSupportedException(Resources.PSHostRawUserInterfaceSetBufferContentsNotSupported); }
/// <summary> /// Executes the native command once all of the input has been gathered. /// </summary> /// <exception cref="PipelineStoppedException"> /// The pipeline is stopping /// </exception> /// <exception cref="ApplicationFailedException"> /// The native command could not be run /// </exception> internal override void Complete() { // Indicate whether we need to consider redirecting the output/error of the current native command. // Usually a windows program which is the last command in a pipeline can be executed as 'background' -- we don't need to capture its output/error streams. bool background; // Figure out if we're going to run this process "standalone" i.e. without // redirecting anything. This is a bit tricky as we always run redirected so // we have to see if the redirection is actually being done at the topmost level or not. //Calculate if input and output are redirected. bool redirectOutput; bool redirectError; bool redirectInput; CalculateIORedirection(out redirectOutput, out redirectError, out redirectInput); // Find out if it's the only command in the pipeline. bool soloCommand = this.Command.MyInvocation.PipelineLength == 1; // Get the start info for the process. ProcessStartInfo startInfo = GetProcessStartInfo(redirectOutput, redirectError, redirectInput, soloCommand); if (this.Command.Context.CurrentPipelineStopping) { throw new PipelineStoppedException(); } // If a problem occurred in running the program, this exception will // be set and should be rethrown at the end of the try/catch block... Exception exceptionToRethrow = null; Host.Coordinates startPosition = new Host.Coordinates(); bool scrapeHostOutput = false; try { // If this process is being run standalone, tell the host, which might want // to save off the window title or other such state as might be tweaked by // the native process if (!redirectOutput) { this.Command.Context.EngineHostInterface.NotifyBeginApplication(); // Also, store the Raw UI coordinates so that we can scrape the screen after // if we are transcribing. try { if (this.Command.Context.EngineHostInterface.UI.IsTranscribing) { scrapeHostOutput = true; startPosition = this.Command.Context.EngineHostInterface.UI.RawUI.CursorPosition; startPosition.X = 0; } } catch (Host.HostException) { // The host doesn't support scraping via its RawUI interface scrapeHostOutput = false; } } //Start the process. If stop has been called, throw exception. //Note: if StopProcessing is called which this method has the lock, //Stop thread will wait for nativeProcess to start. //If StopProcessing gets the lock first, then it will set the stopped //flag and this method will throw PipelineStoppedException when it gets //the lock. lock (_sync) { if (_stopped) { throw new PipelineStoppedException(); } try { _nativeProcess = new Process(); _nativeProcess.StartInfo = startInfo; _nativeProcess.Start(); } catch (Win32Exception) { #if CORECLR // Shell doesn't exist on OneCore, so a file cannot be associated with an executable, // and we cannot run an executable as 'ShellExecute' either. throw; #else // See if there is a file association for this command. If so // then we'll use that. If there's no file association, then // try shell execute... string executable = FindExecutable(startInfo.FileName); bool notDone = true; if (!String.IsNullOrEmpty(executable)) { if (IsConsoleApplication(executable)) { // Allocate a console if there isn't one attached already... ConsoleVisibility.AllocateHiddenConsole(); } string oldArguments = startInfo.Arguments; string oldFileName = startInfo.FileName; startInfo.Arguments = "\"" + startInfo.FileName + "\" " + startInfo.Arguments; startInfo.FileName = executable; try { _nativeProcess.Start(); notDone = false; } catch (Win32Exception) { // Restore the old filename and arguments to try shell execute last... startInfo.Arguments = oldArguments; startInfo.FileName = oldFileName; } } // We got here because there was either no executable found for this // file or we tried to launch the exe and it failed. In either case // we will try launching one last time using ShellExecute... if (notDone) { if (soloCommand && startInfo.UseShellExecute == false) { startInfo.UseShellExecute = true; startInfo.RedirectStandardInput = false; startInfo.RedirectStandardOutput = false; startInfo.RedirectStandardError = false; _nativeProcess.Start(); } else { throw; } } #endif } } if (this.Command.MyInvocation.PipelinePosition < this.Command.MyInvocation.PipelineLength) { // Never background unless you're at the end of a pipe. // Something like // ls | notepad | sort.exe // should block until the notepad process is terminated. background = false; } else { background = true; if (startInfo.UseShellExecute == false) { background = IsWindowsApplication(_nativeProcess.StartInfo.FileName); } } try { //If input is redirected, start input to process. if (startInfo.RedirectStandardInput) { NativeCommandIOFormat inputFormat = NativeCommandIOFormat.Text; if (_isMiniShell) { inputFormat = ((MinishellParameterBinderController)NativeParameterBinderController).InputFormat; } lock (_sync) { if (!_stopped) { _inputWriter.Start(_nativeProcess, inputFormat); } } } if (background == false) { //if output is redirected, start reading output of process. if (startInfo.RedirectStandardOutput || startInfo.RedirectStandardError) { lock (_sync) { if (!_stopped) { _outputReader = new ProcessOutputReader(_nativeProcess, Path, redirectOutput, redirectError); _outputReader.Start(); } } if (_outputReader != null) { ProcessOutputHelper(); } } } } catch (Exception) { StopProcessing(); throw; } finally { if (background == false) { //Wait for process to exit _nativeProcess.WaitForExit(); //Wait for input writer to finish. _inputWriter.Done(); //Wait for outputReader to finish if (_outputReader != null) { _outputReader.Done(); } // Capture screen output if we are transcribing if (this.Command.Context.EngineHostInterface.UI.IsTranscribing && scrapeHostOutput) { Host.Coordinates endPosition = this.Command.Context.EngineHostInterface.UI.RawUI.CursorPosition; endPosition.X = this.Command.Context.EngineHostInterface.UI.RawUI.BufferSize.Width - 1; // If the end position is before the start position, then capture the entire buffer. if (endPosition.Y < startPosition.Y) { startPosition.Y = 0; } Host.BufferCell[,] bufferContents = this.Command.Context.EngineHostInterface.UI.RawUI.GetBufferContents( new Host.Rectangle(startPosition, endPosition)); StringBuilder lineContents = new StringBuilder(); StringBuilder bufferText = new StringBuilder(); for (int row = 0; row < bufferContents.GetLength(0); row++) { if (row > 0) { bufferText.Append(Environment.NewLine); } lineContents.Clear(); for (int column = 0; column < bufferContents.GetLength(1); column++) { lineContents.Append(bufferContents[row, column].Character); } bufferText.Append(lineContents.ToString().TrimEnd(Utils.Separators.SpaceOrTab)); } this.Command.Context.InternalHost.UI.TranscribeResult(bufferText.ToString()); } this.Command.Context.SetVariable(SpecialVariables.LastExitCodeVarPath, _nativeProcess.ExitCode); if (_nativeProcess.ExitCode != 0) this.commandRuntime.PipelineProcessor.ExecutionFailed = true; } } } catch (Win32Exception e) { exceptionToRethrow = e; } // try catch (PipelineStoppedException) { // If we're stopping the process, just rethrow this exception... throw; } catch (Exception e) { CommandProcessorBase.CheckForSevereException(e); exceptionToRethrow = e; } finally { if (!redirectOutput) { this.Command.Context.EngineHostInterface.NotifyEndApplication(); } // Do the clean up... CleanUp(); } // An exception was thrown while attempting to run the program // so wrap and rethrow it here... if (exceptionToRethrow != null) { // It's a system exception so wrap it in one of ours and re-throw. string message = StringUtil.Format(ParserStrings.ProgramFailedToExecute, this.NativeCommandName, exceptionToRethrow.Message, this.Command.MyInvocation.PositionMessage); ApplicationFailedException appFailedException = new ApplicationFailedException(message, exceptionToRethrow); // There is no need to set this exception here since this exception will eventually be caught by pipeline processor. // this.commandRuntime.PipelineProcessor.ExecutionFailed = true; throw appFailedException; } }
public override void ScrollBufferContents(Rectangle source, Coordinates destination, Rectangle clip, BufferCell fill) { // TODO: REIMPLEMENT PSHostRawUserInterface.ScrollBufferContents(Rectangle source, Coordinates destination, Rectangle clip, BufferCell fill) throw new NotImplementedException("The ScrollBufferContents method is not (yet) implemented!"); //if (_control.Dispatcher.CheckAccess()) //{ // _control.ScrollBufferContents(source, destination, clip, fill); //} //else //{ // _control.Dispatcher.BeginInvoke(DispatcherPriority.Normal, (Action)delegate // { // _control.ScrollBufferContents(source, destination, clip, fill); // }); //} }
/// <summary> /// Scrolls the contents of the console buffer. /// </summary> /// <param name="source">The source rectangle to scroll.</param> /// <param name="destination">The destination coordinates by which to scroll.</param> /// <param name="clip">The rectangle inside which the scrolling will be clipped.</param> /// <param name="fill">The cell with which the buffer will be filled.</param> public override void ScrollBufferContents( Rectangle source, Coordinates destination, Rectangle clip, BufferCell fill) { Logger.Write( LogLevel.Warning, "PSHostRawUserInterface.ScrollBufferContents was called"); }
/// <summary> /// /// Handle backspace with proper cursor adjustment for ReadLineSafe /// /// </summary> /// <param name="originalCursorPosition"> /// /// it is the cursor position where ReadLineSafe begins /// /// </param> /// <exception cref="HostException"> /// /// If obtaining information about the buffer failed /// OR /// Win32's SetConsoleCursorPosition failed /// /// </exception> private void WriteBackSpace(Coordinates originalCursorPosition) { Coordinates cursorPosition = _rawui.CursorPosition; if (cursorPosition == originalCursorPosition) { // at originalCursorPosition, don't move return; } if (cursorPosition.X == 0) { if (cursorPosition.Y <= originalCursorPosition.Y) { return; } // BufferSize.Width is 1 larger than cursor position cursorPosition.X = _rawui.BufferSize.Width - 1; cursorPosition.Y--; BlankAtCursor(cursorPosition); } else if (cursorPosition.X > 0) { cursorPosition.X--; BlankAtCursor(cursorPosition); } // do nothing if cursorPosition.X is left of screen }
/// <summary> /// Get the character at the cursor when the user types 'tab' in the middle of line. /// </summary> /// <param name="cursorPosition">the cursor position where 'tab' is hit</param> /// <returns></returns> private char GetCharacterUnderCursor(Coordinates cursorPosition) { Rectangle region = new Rectangle(0, cursorPosition.Y, RawUI.BufferSize.Width - 1, cursorPosition.Y); BufferCell[,] content = RawUI.GetBufferContents(region); for (int index = 0, column = 0; column <= cursorPosition.X; index++) { BufferCell cell = content[0, index]; if (cell.BufferCellType == BufferCellType.Complete || cell.BufferCellType == BufferCellType.Leading) { if (column == cursorPosition.X) { return cell.Character; } column += ConsoleControl.LengthInBufferCells(cell.Character); } } Dbg.Assert(false, "the character at the cursor should be retrieved, never gets to here"); return '\0'; }
public override void ScrollBufferContents(Rectangle source, Coordinates destination, Rectangle clip, BufferCell fill) { }
/// <summary> /// Copies a given character to a region of the screen buffer based /// on the coordinates of the region. This method is not implemented. /// The call fails with an exception. /// </summary> /// <param name="origin">The coordnates of the region.</param> /// <param name="contents">A BufferCell structure that defines the fill character.</param> public override void SetBufferContents(Coordinates origin, BufferCell[,] contents) { throw new NotImplementedException("The SetBufferContents() method is not implemented by MyRawUserInterface."); }
/// <summary> /// Crops a region of the screen buffer. This functionality is not /// implemented. The call fails with an exception. /// </summary> /// <param name="source">A Rectangle structure that identifies the /// region of the screen to be scrolled.</param> /// <param name="destination">A Coordinates structure that /// identifies the upper-left coordinates of the region of the /// screen to receive the source region contents.</param> /// <param name="clip">A Rectangle structure that identifies the /// region of the screen to include in the operation.</param> /// <param name="fill">A BufferCell structure that identifies the /// character and attributes to be used to fill all cells within /// the intersection of the source rectangle and clip rectangle /// that are left "empty" by the move.</param> public override void ScrollBufferContents(Rectangle source, Coordinates destination, Rectangle clip, BufferCell fill) { throw new NotImplementedException("The ScrollBufferContents() method is not implemented by MyRawUserInterface."); }
public override void ScrollBufferContents(Rectangle source, Coordinates destination, Rectangle clip, BufferCell fill) { if (this.externalRawUI == null) { this.ThrowNotInteractive(); } this.externalRawUI.ScrollBufferContents(source, destination, clip, fill); }
public override void ScrollBufferContents(System.Management.Automation.Host.Rectangle source, System.Management.Automation.Host.Coordinates destination, System.Management.Automation.Host.Rectangle clip, System.Management.Automation.Host.BufferCell fill) { // throw new NotImplementedException(); }
ScrollBufferContents ( Rectangle source, Coordinates destination, Rectangle clip, BufferCell fill ) { if (_externalRawUI == null) { ThrowNotInteractive(); } _externalRawUI.ScrollBufferContents(source, destination, clip, fill); }
public override void SetBufferContents(Coordinates origin, BufferCell[,] contents) { }
/// <summary> /// /// Handle writing print token with proper cursor adjustment for ReadLineSafe /// /// </summary> /// <param name="printToken"> /// /// token output for each char input. It must be a one-char string /// /// </param> /// <param name="originalCursorPosition"> /// /// it is the cursor position where ReadLineSafe begins /// /// </param> /// <exception cref="HostException"> /// /// If obtaining information about the buffer failed /// OR /// Win32's SetConsoleCursorPosition failed /// /// </exception> private void WritePrintToken( string printToken, ref Coordinates originalCursorPosition) { Dbg.Assert(!string.IsNullOrEmpty(printToken), "Calling WritePrintToken with printToken being null or empty"); Dbg.Assert(printToken.Length == 1, "Calling WritePrintToken with printToken's Length being " + printToken.Length); Size consoleBufferSize = _rawui.BufferSize; Coordinates currentCursorPosition = _rawui.CursorPosition; // if the cursor is currently at the lower right corner, this write will cause the screen buffer to // scroll up. So, it is necessary to adjust the original cursor position one row up. if (currentCursorPosition.Y >= consoleBufferSize.Height - 1 && // last row currentCursorPosition.X >= consoleBufferSize.Width - 1) // last column { if (originalCursorPosition.Y > 0) { originalCursorPosition.Y--; } } WriteToConsole(printToken, false); }
/// <summary> /// Scroll buffer contents. /// </summary> public override void ScrollBufferContents(Rectangle source, Coordinates destination, Rectangle clip, BufferCell fill) { _serverMethodExecutor.ExecuteVoidMethod(RemoteHostMethodId.ScrollBufferContents, new object[] { source, destination, clip, fill }); }
/// <summary> /// Blank out at and move rawui.CursorPosition to <paramref name="cursorPosition"/> /// </summary> /// <param name="cursorPosition">Position to blank out</param> private void BlankAtCursor(Coordinates cursorPosition) { _rawui.CursorPosition = cursorPosition; WriteToConsole(" ", true); _rawui.CursorPosition = cursorPosition; }
/// <summary> /// Set buffer contents. /// </summary> public override void SetBufferContents(Coordinates origin, BufferCell[,] contents) { _serverMethodExecutor.ExecuteVoidMethod(RemoteHostMethodId.SetBufferContents2, new object[] { origin, contents }); }
/// <summary> /// Sets the contents of the buffer at the given coordinate. /// </summary> /// <param name="origin">The coordinate at which the buffer will be changed.</param> /// <param name="contents">The new contents for the buffer at the given coordinate.</param> public override void SetBufferContents( Coordinates origin, BufferCell[,] contents) { Logger.Write( LogLevel.Warning, "PSHostRawUserInterface.SetBufferContents was called"); }
public abstract void ScrollBufferContents(Rectangle source, Coordinates destination, Rectangle clip, BufferCell fill);
public override void SetBufferContents(Coordinates origin, BufferCell[,] contents) { // TODO: REIMPLEMENT PSHostRawUserInterface.SetBufferContents(Coordinates origin, BufferCell[,] contents) throw new NotImplementedException("The SetBufferContents method is not (yet) implemented!"); //if (_control.Dispatcher.CheckAccess()) // { // _control.SetBufferContents(origin, contents); // } // else // { // _control.Dispatcher.BeginInvoke(DispatcherPriority.Normal, (Action)delegate // { // _control.SetBufferContents(origin, contents); // }); // } }
public abstract void SetBufferContents(Coordinates origin, BufferCell[,] contents);
public override void ScrollBufferContents(Rectangle source, Coordinates destination, Rectangle clip, BufferCell fill) { throw new NotSupportedException(Resources.PSHostRawUserInterfaceScrollBufferContentsNotSupported); }
/// <summary> /// This functionality is not currently implemented. The call fails with an exception. /// </summary> /// <param name="source">Unused</param> /// <param name="destination">Unused</param> /// <param name="clip">Unused</param> /// <param name="fill">Unused</param> public override void ScrollBufferContents(Rectangle source, Coordinates destination, Rectangle clip, BufferCell fill) { throw new NotImplementedException("The method or operation is not implemented."); }
public override void ScrollBufferContents(Rectangle source, Coordinates destination, Rectangle clip, BufferCell fill) { throw new NotImplementedException(); }
/// <summary> /// This functionality is not currently implemented. The call fails with an exception. /// </summary> /// <param name="origin">Unused</param> /// <param name="contents">Unused</param> public override void SetBufferContents(Coordinates origin, BufferCell[,] contents) { throw new NotImplementedException("The method or operation is not implemented."); }
SetBufferContents(Coordinates origin, BufferCell[,] contents) { if (_externalRawUI == null) { ThrowNotInteractive(); } _externalRawUI.SetBufferContents(origin, contents); }
public override void SetBufferContents(System.Management.Automation.Host.Coordinates origin, System.Management.Automation.Host.BufferCell[,] contents) { return(null); // throw new NotImplementedException(); }