internal void GenerateHeader(string[] values, LineOutput lo) { if (!this.disabled && !this.hideHeader) { this.GenerateRow(values, lo, true, null, lo.DisplayCells); string[] strArray = new string[values.Length]; for (int i = 0; i < this.si.columnInfo.Length; i++) { if (this.si.columnInfo[i].width <= 0) { strArray[i] = ""; } else { int width = this.si.columnInfo[i].width; if (!string.IsNullOrEmpty(values[i])) { int num3 = lo.DisplayCells.Length(values[i]); if (num3 < width) { width = num3; } } strArray[i] = new string('-', width); } } this.GenerateRow(strArray, lo, false, null, lo.DisplayCells); } }
/// <summary> /// internal helper to split a line that is too long to fit and pad it to the left /// with a given string /// </summary> /// <param name="prependString">string to add to the left.</param> /// <param name="line">line to print.</param> /// <param name="lo">LineOuput to write to.</param> private void WriteSingleLineHelper(string prependString, string line, LineOutput lo) { if (line == null) { line = string.Empty; } // compute the width of the field for the value string (in screen cells) int fieldCellCount = _columnWidth - _propertyLabelsDisplayLength; // split the lines StringCollection sc = StringManipulationHelper.GenerateLines(lo.DisplayCells, line, fieldCellCount, fieldCellCount); // padding to use in the lines after the first string padding = StringUtil.Padding(_propertyLabelsDisplayLength); // display the string collection for (int k = 0; k < sc.Count; k++) { if (k == 0) { lo.WriteLine(prependString + sc[k]); } else { lo.WriteLine(padding + sc[k]); } } }
private void WriteProperty(int k, string propertyValue, LineOutput lo) { if (propertyValue == null) { propertyValue = ""; } string[] strArray = StringManipulationHelper.SplitLines(propertyValue); string str = null; for (int i = 0; i < strArray.Length; i++) { string prependString = null; if (i == 0) { prependString = this.propertyLabels[k]; } else { if (str == null) { str = prependString = new string(' ', this.propertyLabelsDisplayLength); } prependString = str; } this.WriteSingleLineHelper(prependString, strArray[i], lo); } }
internal void GenerateHeader(string[] values, LineOutput lo) { if (!this.disabled && !this.hideHeader) { this.GenerateRow(values, lo, true, null, lo.DisplayCells); string[] strArray = new string[values.Length]; for (int i = 0; i < this.si.columnInfo.Length; i++) { if (this.si.columnInfo[i].width <= 0) { strArray[i] = ""; } else { int width = this.si.columnInfo[i].width; if (!string.IsNullOrEmpty(values[i])) { int num3 = lo.DisplayCells.Length(values[i]); if (num3 < width) { width = num3; } } strArray[i] = new string('-', width); } } this.GenerateRow(strArray, lo, false, null, lo.DisplayCells); } }
/// <summary> /// helper, writing a single property to the screen. /// It wraps the value of the property if it is tool long to fit /// </summary> /// <param name="k">index of property to write.</param> /// <param name="propertyValue">string value of the property to write.</param> /// <param name="lo">LineOutput interface to write to.</param> private void WriteProperty(int k, string propertyValue, LineOutput lo) { if (propertyValue == null) { propertyValue = string.Empty; } // make sure we honor embedded newlines string[] lines = StringManipulationHelper.SplitLines(propertyValue); // padding to use in the lines after the first string padding = null; for (int i = 0; i < lines.Length; i++) { string prependString = null; if (i == 0) { prependString = _propertyLabels[k]; } else { if (padding == null) { padding = StringUtil.Padding(_propertyLabelsDisplayLength); } prependString = padding; } WriteSingleLineHelper(prependString, lines[i], lo); } }
internal int GenerateHeader(string[] values, LineOutput lo) { if (_disabled || _hideHeader) { return(0); } else if (_header != null) { foreach (string line in _header) { if (ExperimentalFeature.IsEnabled("PSAnsiRendering")) { lo.WriteLine(PSStyle.Instance.Formatting.TableHeader + line + PSStyle.Instance.Reset); } else { lo.WriteLine(line); } } return(_header.Count); } _header = new List <string>(); // generate the row with the header labels GenerateRow(values, lo, true, null, lo.DisplayCells, _header, isHeader: true); // generate an array of "--" as header markers below // the column header labels string[] breakLine = new string[values.Length]; for (int k = 0; k < breakLine.Length; k++) { // the column can be hidden if (_si.columnInfo[k].width <= 0) { breakLine[k] = string.Empty; continue; } // the title can be larger than the width int count = _si.columnInfo[k].width; if (!string.IsNullOrEmpty(values[k])) { int labelDisplayCells = lo.DisplayCells.Length(values[k]); if (labelDisplayCells < count) { count = labelDisplayCells; } } // NOTE: we can do this because "-" is a single cell character // on all devices. If changed to some other character, this assumption // would be invalidated breakLine[k] = StringUtil.DashPadding(count); } GenerateRow(breakLine, lo, false, null, lo.DisplayCells, _header, isHeader: true); return(_header.Count); }
/// <summary> /// write the values of the properties of an object /// </summary> /// <param name="values">array with the values in form of formatted strings.</param> /// <param name="lo">LineOutput interface to write to.</param> internal void WriteProperties(string[] values, LineOutput lo) { if (_disabled) { return; } string[] valuesToPrint = null; if (values == null) { // we have nothing, but we have to create an empty array valuesToPrint = new string[_propertyLabels.Length]; for (int k = 0; k < _propertyLabels.Length; k++) { valuesToPrint[k] = string.Empty; } } else if (values.Length < _propertyLabels.Length) { // need to pad to the end of the array valuesToPrint = new string[_propertyLabels.Length]; for (int k = 0; k < _propertyLabels.Length; k++) { if (k < values.Length) { valuesToPrint[k] = values[k]; } else { valuesToPrint[k] = string.Empty; } } } else if (values.Length > _propertyLabels.Length) { // need to trim valuesToPrint = new string[_propertyLabels.Length]; for (int k = 0; k < _propertyLabels.Length; k++) { valuesToPrint[k] = values[k]; } } else { // perfect match valuesToPrint = values; } Debug.Assert(lo != null, "LineOutput is null"); for (int k = 0; k < _propertyLabels.Length; k++) { WriteProperty(k, valuesToPrint[k], lo); } }
protected override void BeginProcessing() { if (this.lineOutput == null) { this.ProcessNullLineOutput(); } Microsoft.PowerShell.Commands.Internal.Format.LineOutput lineOutput = this.lineOutput as Microsoft.PowerShell.Commands.Internal.Format.LineOutput; if (lineOutput == null) { this.ProcessWrongTypeLineOutput(this.lineOutput); } ((OutCommandInner)base.implementation).LineOutput = lineOutput; base.BeginProcessing(); }
internal void GenerateRow(string[] values, LineOutput lo, bool multiLine, int[] alignment, DisplayCells dc) { if (_disabled) { return; } // build the current row alignment settings int cols = _si.columnInfo.Length; int[] currentAlignment = new int[cols]; if (alignment == null) { for (int i = 0; i < cols; i++) { currentAlignment[i] = _si.columnInfo[i].alignment; } } else { for (int i = 0; i < cols; i++) { if (alignment[i] == TextAlignment.Undefined) { currentAlignment[i] = _si.columnInfo[i].alignment; } else { currentAlignment[i] = alignment[i]; } } } if (multiLine) { string[] lines = GenerateTableRow(values, currentAlignment, lo.DisplayCells); for (int k = 0; k < lines.Length; k++) { lo.WriteLine(lines[k]); } } else { lo.WriteLine(GenerateRow(values, currentAlignment, dc)); } }
internal void GenerateRow(string[] values, LineOutput lo, bool multiLine, ReadOnlySpan <int> alignment, DisplayCells dc, List <string> generatedRows) { if (_disabled) { return; } // build the current row alignment settings int cols = _si.columnInfo.Length; Span <int> currentAlignment = cols <= OutCommandInner.StackAllocThreshold ? stackalloc int[cols] : new int[cols]; if (alignment == null) { for (int i = 0; i < currentAlignment.Length; i++) { currentAlignment[i] = _si.columnInfo[i].alignment; } } else { for (int i = 0; i < currentAlignment.Length; i++) { if (alignment[i] == TextAlignment.Undefined) { currentAlignment[i] = _si.columnInfo[i].alignment; } else { currentAlignment[i] = alignment[i]; } } } if (multiLine) { foreach (string line in GenerateTableRow(values, currentAlignment, lo.DisplayCells)) { generatedRows?.Add(line); lo.WriteLine(line); } } else { string line = GenerateRow(values, currentAlignment, dc); generatedRows?.Add(line); lo.WriteLine(line); } }
internal void WriteProperties(string[] values, LineOutput lo) { if (!this.disabled) { string[] strArray = null; if (values == null) { strArray = new string[this.propertyLabels.Length]; for (int j = 0; j < this.propertyLabels.Length; j++) { strArray[j] = ""; } } else if (values.Length < this.propertyLabels.Length) { strArray = new string[this.propertyLabels.Length]; for (int k = 0; k < this.propertyLabels.Length; k++) { if (k < values.Length) { strArray[k] = values[k]; } else { strArray[k] = ""; } } } else if (values.Length > this.propertyLabels.Length) { strArray = new string[this.propertyLabels.Length]; for (int m = 0; m < this.propertyLabels.Length; m++) { strArray[m] = values[m]; } } else { strArray = values; } for (int i = 0; i < this.propertyLabels.Length; i++) { this.WriteProperty(i, strArray[i], lo); } } }
internal void WriteProperties(string[] values, LineOutput lo) { if (!this.disabled) { string[] strArray = null; if (values == null) { strArray = new string[this.propertyLabels.Length]; for (int j = 0; j < this.propertyLabels.Length; j++) { strArray[j] = ""; } } else if (values.Length < this.propertyLabels.Length) { strArray = new string[this.propertyLabels.Length]; for (int k = 0; k < this.propertyLabels.Length; k++) { if (k < values.Length) { strArray[k] = values[k]; } else { strArray[k] = ""; } } } else if (values.Length > this.propertyLabels.Length) { strArray = new string[this.propertyLabels.Length]; for (int m = 0; m < this.propertyLabels.Length; m++) { strArray[m] = values[m]; } } else { strArray = values; } for (int i = 0; i < this.propertyLabels.Length; i++) { this.WriteProperty(i, strArray[i], lo); } } }
/// <summary> /// Internal helper to split a line that is too long to fit and pad it to the left /// with a given string. /// </summary> /// <param name="prependString">String to add to the left.</param> /// <param name="line">Line to print.</param> /// <param name="lo">LineOuput to write to.</param> private void WriteSingleLineHelper(string prependString, string line, LineOutput lo) { if (line == null) { line = string.Empty; } // compute the width of the field for the value string (in screen cells) int fieldCellCount = _columnWidth - _propertyLabelsDisplayLength; // split the lines StringCollection sc = StringManipulationHelper.GenerateLines(lo.DisplayCells, line, fieldCellCount, fieldCellCount); // padding to use in the lines after the first string padding = StringUtil.Padding(_propertyLabelsDisplayLength); // display the string collection for (int k = 0; k < sc.Count; k++) { if (k == 0) { if (ExperimentalFeature.IsEnabled("PSAnsiRendering")) { lo.WriteLine(PSStyle.Instance.Formatting.FormatAccent + prependString + PSStyle.Instance.Reset + sc[k]); } else { lo.WriteLine(prependString + sc[k]); } } else { if (ExperimentalFeature.IsEnabled("PSAnsiRendering")) { lo.WriteLine(padding + PSStyle.Instance.Formatting.FormatAccent + PSStyle.Instance.Reset + sc[k]); } else { lo.WriteLine(padding + sc[k]); } } } }
internal void GenerateHeader(string[] values, LineOutput lo) { if (_disabled) { return; } if (_hideHeader) { return; } // generate the row with the header labels GenerateRow(values, lo, true, null, lo.DisplayCells); // generate an array of "--" as header markers below // the column header labels string[] breakLine = new string[values.Length]; for (int k = 0; k < breakLine.Length; k++) { // the column can be hidden if (_si.columnInfo[k].width <= 0) { breakLine[k] = ""; continue; } // the title can be larger than the width int count = _si.columnInfo[k].width; if (!string.IsNullOrEmpty(values[k])) { int labelDisplayCells = lo.DisplayCells.Length(values[k]); if (labelDisplayCells < count) { count = labelDisplayCells; } } // NOTE: we can do this because "-" is a single cell character // on all devices. If changed to some other character, this assumption // would be invalidated breakLine[k] = StringUtil.DashPadding(count); } GenerateRow(breakLine, lo, false, null, lo.DisplayCells); }
internal void GenerateRow(string[] values, LineOutput lo, bool multiLine, int[] alignment, DisplayCells dc) { if (!this.disabled) { int length = this.si.columnInfo.Length; int[] numArray = new int[length]; if (alignment == null) { for (int i = 0; i < length; i++) { numArray[i] = this.si.columnInfo[i].alignment; } } else { for (int j = 0; j < length; j++) { if (alignment[j] == 0) { numArray[j] = this.si.columnInfo[j].alignment; } else { numArray[j] = alignment[j]; } } } if (multiLine) { string[] strArray = this.GenerateTableRow(values, numArray, lo.DisplayCells); for (int k = 0; k < strArray.Length; k++) { lo.WriteLine(strArray[k]); } } else { lo.WriteLine(this.GenerateRow(values, numArray, dc)); } } }
private void WriteSingleLineHelper(string prependString, string line, LineOutput lo) { if (line == null) { line = ""; } int firstLineLen = this.columnWidth - this.propertyLabelsDisplayLength; StringCollection strings = StringManipulationHelper.GenerateLines(lo.DisplayCells, line, firstLineLen, firstLineLen); string str = new string(' ', this.propertyLabelsDisplayLength); for (int i = 0; i < strings.Count; i++) { if (i == 0) { lo.WriteLine(prependString + strings[i]); } else { lo.WriteLine(str + strings[i]); } } }
private void WriteSingleLineHelper(string prependString, string line, LineOutput lo) { if (line == null) { line = ""; } int firstLineLen = this.columnWidth - this.propertyLabelsDisplayLength; StringCollection strings = StringManipulationHelper.GenerateLines(lo.DisplayCells, line, firstLineLen, firstLineLen); string str = new string(' ', this.propertyLabelsDisplayLength); for (int i = 0; i < strings.Count; i++) { if (i == 0) { lo.WriteLine(prependString + strings[i]); } else { lo.WriteLine(str + strings[i]); } } }
/// <summary> /// Initialization method to be called before any other operation. /// </summary> /// <param name="lineOutput">LineOutput interfaces to write to.</param> /// <param name="numberOfTextColumns">Number of columns used to write out.</param> internal void Initialize(LineOutput lineOutput, int numberOfTextColumns) { _lo = lineOutput; _textColumns = numberOfTextColumns; }
internal void Initialize(LineOutput lineOutput, ExecutionContext context) { this.lo = lineOutput; this.InitializeCommandsHardWired(context); }
internal void Initialize(LineOutput lineOutput, int numberOfTextColumns) { this.lo = lineOutput; this.textColumns = numberOfTextColumns; }
internal void GenerateRow(string[] values, LineOutput lo, bool multiLine, ReadOnlySpan <int> alignment, DisplayCells dc, List <string> generatedRows, bool isHeader = false) { if (_disabled) { return; } // build the current row alignment settings int cols = _si.columnInfo.Length; Span <int> currentAlignment = cols <= OutCommandInner.StackAllocThreshold ? stackalloc int[cols] : new int[cols]; if (alignment.IsEmpty) { for (int i = 0; i < currentAlignment.Length; i++) { currentAlignment[i] = _si.columnInfo[i].alignment; } } else { for (int i = 0; i < currentAlignment.Length; i++) { if (alignment[i] == TextAlignment.Undefined) { currentAlignment[i] = _si.columnInfo[i].alignment; } else { currentAlignment[i] = alignment[i]; } } } if (multiLine) { foreach (string line in GenerateTableRow(values, currentAlignment, lo.DisplayCells)) { generatedRows?.Add(line); if (ExperimentalFeature.IsEnabled("PSAnsiRendering") && isHeader) { lo.WriteLine(PSStyle.Instance.Formatting.TableHeader + line + PSStyle.Instance.Reset); } else { lo.WriteLine(line); } } } else { string line = GenerateRow(values, currentAlignment, dc); generatedRows?.Add(line); if (ExperimentalFeature.IsEnabled("PSAnsiRendering") && isHeader) { lo.WriteLine(PSStyle.Instance.Formatting.TableHeader + line + PSStyle.Instance.Reset); } else { lo.WriteLine(line); } } }
/// <summary> /// write the values of the properties of an object /// </summary> /// <param name="values">array with the values in form of formatted strings</param> /// <param name="lo">LineOutput interface to write to</param> internal void WriteProperties(string[] values, LineOutput lo) { if (_disabled) return; string[] valuesToPrint = null; if (values == null) { // we have nothing, but we have to create an empty array valuesToPrint = new string[_propertyLabels.Length]; for (int k = 0; k < _propertyLabels.Length; k++) valuesToPrint[k] = ""; } else if (values.Length < _propertyLabels.Length) { // need to pad to the end of the array valuesToPrint = new string[_propertyLabels.Length]; for (int k = 0; k < _propertyLabels.Length; k++) { if (k < values.Length) valuesToPrint[k] = values[k]; else valuesToPrint[k] = ""; } } else if (values.Length > _propertyLabels.Length) { // need to trim valuesToPrint = new string[_propertyLabels.Length]; for (int k = 0; k < _propertyLabels.Length; k++) valuesToPrint[k] = values[k]; } else { // perfect match valuesToPrint = values; } Debug.Assert(lo != null, "LineOutput is null"); for (int k = 0; k < _propertyLabels.Length; k++) { WriteProperty(k, valuesToPrint[k], lo); } }
internal void GenerateRow(string[] values, LineOutput lo, bool multiLine, int[] alignment, DisplayCells dc) { if (_disabled) return; // build the current row alignment settings int cols = _si.columnInfo.Length; int[] currentAlignment = new int[cols]; if (alignment == null) { for (int i = 0; i < cols; i++) { currentAlignment[i] = _si.columnInfo[i].alignment; } } else { for (int i = 0; i < cols; i++) { if (alignment[i] == TextAlignment.Undefined) currentAlignment[i] = _si.columnInfo[i].alignment; else currentAlignment[i] = alignment[i]; } } if (multiLine) { string[] lines = GenerateTableRow(values, currentAlignment, lo.DisplayCells); for (int k = 0; k < lines.Length; k++) { lo.WriteLine(lines[k]); } } else { lo.WriteLine(GenerateRow(values, currentAlignment, dc)); } }
internal void GenerateHeader(string[] values, LineOutput lo) { if (_disabled) return; if (_hideHeader) return; // generate the row with the header labels GenerateRow(values, lo, true, null, lo.DisplayCells); // generate an array of "--" as header markers below // the column header labels string[] breakLine = new string[values.Length]; for (int k = 0; k < _si.columnInfo.Length; k++) { // the column can be hidden if (_si.columnInfo[k].width <= 0) { breakLine[k] = ""; continue; } // the title can be larger than the width int count = _si.columnInfo[k].width; if (!string.IsNullOrEmpty(values[k])) { int labelDisplayCells = lo.DisplayCells.Length(values[k]); if (labelDisplayCells < count) count = labelDisplayCells; } // NOTE: we can do this because "-" is a single cell character // on all devices. If changed to some other character, this assumption // would be invalidated breakLine[k] = new string('-', count); } GenerateRow(breakLine, lo, false, null, lo.DisplayCells); }
internal void Initialize(LineOutput lineOutput, ExecutionContext context) { this.lo = lineOutput; this.InitializeCommandsHardWired(context); }
internal void GenerateRow(string[] values, LineOutput lo, bool multiLine, int[] alignment, DisplayCells dc) { if (!this.disabled) { int length = this.si.columnInfo.Length; int[] numArray = new int[length]; if (alignment == null) { for (int i = 0; i < length; i++) { numArray[i] = this.si.columnInfo[i].alignment; } } else { for (int j = 0; j < length; j++) { if (alignment[j] == 0) { numArray[j] = this.si.columnInfo[j].alignment; } else { numArray[j] = alignment[j]; } } } if (multiLine) { string[] strArray = this.GenerateTableRow(values, numArray, lo.DisplayCells); for (int k = 0; k < strArray.Length; k++) { lo.WriteLine(strArray[k]); } } else { lo.WriteLine(this.GenerateRow(values, numArray, dc)); } } }
/// <summary> /// helper, writing a single property to the screen. /// It wraps the value of the property if it is tool long to fit /// </summary> /// <param name="k">index of property to write</param> /// <param name="propertyValue">string value of the property to write</param> /// <param name="lo">LineOutput interface to write to</param> private void WriteProperty(int k, string propertyValue, LineOutput lo) { if (propertyValue == null) propertyValue = ""; // make sure we honor embedded newlines string[] lines = StringManipulationHelper.SplitLines(propertyValue); // padding to use in the lines after the first string padding = null; for (int i = 0; i < lines.Length; i++) { string prependString = null; if (i == 0) prependString = _propertyLabels[k]; else { if (padding == null) padding = prependString = new string(' ', _propertyLabelsDisplayLength); prependString = padding; } WriteSingleLineHelper(prependString, lines[i], lo); } }
/// <summary> /// internal helper to split a line that is too long to fit and pad it to the left /// with a given string /// </summary> /// <param name="prependString">string to add to the left</param> /// <param name="line">line to print</param> /// <param name="lo">LineOuput to write to</param> private void WriteSingleLineHelper(string prependString, string line, LineOutput lo) { if (line == null) line = ""; // compute the width of the field for the value string (in screen cells) int fieldCellCount = _columnWidth - _propertyLabelsDisplayLength; // split the lines StringCollection sc = StringManipulationHelper.GenerateLines(lo.DisplayCells, line, fieldCellCount, fieldCellCount); // padding to use in the lines after the first string padding = new string(' ', _propertyLabelsDisplayLength); // display the string collection for (int k = 0; k < sc.Count; k++) { if (k == 0) { lo.WriteLine(prependString + sc[k]); } else { lo.WriteLine(padding + sc[k]); } } }
internal override void ExecuteBufferPlayBack(LineOutput.DoPlayBackCall playback) { this.playbackCall = playback; this.DoPrint(); }
private void WriteProperty(int k, string propertyValue, LineOutput lo) { if (propertyValue == null) { propertyValue = ""; } string[] strArray = StringManipulationHelper.SplitLines(propertyValue); string str = null; for (int i = 0; i < strArray.Length; i++) { string prependString = null; if (i == 0) { prependString = this.propertyLabels[k]; } else { if (str == null) { str = prependString = new string(' ', this.propertyLabelsDisplayLength); } prependString = str; } this.WriteSingleLineHelper(prependString, strArray[i], lo); } }