private void ProcessCachedGroupOnTable(TableHeaderInfo thi, List <PacketInfoData> objects) { if (thi.tableColumnInfoList.Count == 0) { return; } int[] widths = new int[thi.tableColumnInfoList.Count]; for (int k = 0; k < thi.tableColumnInfoList.Count; k++) { string label = thi.tableColumnInfoList[k].label; if (string.IsNullOrEmpty(label)) { label = thi.tableColumnInfoList[k].propertyName; } if (string.IsNullOrEmpty(label)) { widths[k] = 0; } else { widths[k] = _lo.DisplayCells.Length(label); } } int cellCount; // scratch variable foreach (PacketInfoData o in objects) { FormatEntryData fed = o as FormatEntryData; if (fed == null) { continue; } TableRowEntry tre = fed.formatEntryInfo as TableRowEntry; int kk = 0; foreach (FormatPropertyField fpf in tre.formatPropertyFieldList) { cellCount = _lo.DisplayCells.Length(fpf.propertyValue); if (widths[kk] < cellCount) { widths[kk] = cellCount; } kk++; } } TableFormattingHint hint = new TableFormattingHint(); hint.columnWidths = widths; _formattingHint = hint; }
internal static FormatEntryData GenerateOutOfBandData(TerminatingErrorContext errorContext, PSPropertyExpressionFactory expressionFactory, TypeInfoDataBase db, PSObject so, int enumerationLimit, bool useToStringFallback, out List <ErrorRecord> errors) { errors = null; var typeNames = so.InternalTypeNames; ViewDefinition view = DisplayDataQuery.GetOutOfBandView(expressionFactory, db, typeNames); ViewGenerator outOfBandViewGenerator; if (view != null) { // process an out of band view retrieved from the display database if (view.mainControl is ComplexControlBody) { outOfBandViewGenerator = new ComplexViewGenerator(); } else { outOfBandViewGenerator = new ListViewGenerator(); } outOfBandViewGenerator.Initialize(errorContext, expressionFactory, db, view, null); } else { if (DefaultScalarTypes.IsTypeInList(typeNames) || !HasNonRemotingProperties(so)) { // we force a ToString() on well known types return(GenerateOutOfBandObjectAsToString(so)); } if (!useToStringFallback) { return(null); } // we must check we have enough properties for a list view if (new PSPropertyExpression("*").ResolveNames(so).Count == 0) { return(null); } // we do not have a view, we default to list view // process an out of band view as a default outOfBandViewGenerator = new ListViewGenerator(); outOfBandViewGenerator.Initialize(errorContext, expressionFactory, so, db, null); } FormatEntryData fed = outOfBandViewGenerator.GeneratePayload(so, enumerationLimit); fed.outOfBand = true; fed.writeStream = so.WriteStream; errors = outOfBandViewGenerator.ErrorManager.DrainFailedResultList(); return(fed); }
internal override void ProcessPayload(FormatEntryData fed) { ComplexViewEntry formatEntryInfo = fed.formatEntryInfo as ComplexViewEntry; if ((formatEntryInfo != null) && (formatEntryInfo.formatValueList != null)) { this.writer.WriteObject(formatEntryInfo.formatValueList); } }
private void SendCommentOutOfBand(string msg) { FormatEntryData fed = OutOfBandFormatViewManager.GenerateOutOfBandObjectAsToString(PSObjectHelper.AsPSObject(msg)); if (fed != null) { this.WriteObject(fed); } }
private void UpdateObjectCount(PacketInfoData o) { FormatEntryData data = o as FormatEntryData; if ((data != null) && !data.outOfBand) { this.currentObjectCount++; } }
/// <summary> /// write a row into the list /// </summary> /// <param name="fed">FormatEntryData to process</param> internal override void ProcessPayload(FormatEntryData fed) { ListViewEntry lve = fed.formatEntryInfo as ListViewEntry; InternalInitialize(lve); string[] values = GetValues(lve); _listWriter.WriteProperties(values, this.InnerCommand._lo); this.InnerCommand._lo.WriteLine(""); }
/// <summary> /// test if an object coming from the pipeline needs to be /// preprocessed by the default formatter /// </summary> /// <param name="o">object to examine for formatting</param> /// <returns>whether the object needs to be shunted to preprocessing</returns> private bool NeedsPreprocessing(object o) { FormatEntryData fed = o as FormatEntryData; if (fed != null) { // we got an already pre-processed object if (!fed.outOfBand) { // we allow out of band data in any state ValidateCurrentFormattingState(FormattingState.InsideGroup, o); } return(false); } else if (o is FormatStartData) { // when encountering FormatStartDate out of sequence, // pretend that the previous formatting directives were properly closed if (_currentFormattingState == FormattingState.InsideGroup) { this.EndProcessing(); this.BeginProcessing(); } // we got a Fs message, we enter a sequence ValidateCurrentFormattingState(FormattingState.Reset, o); _currentFormattingState = FormattingState.Formatting; return(false); } else if (o is FormatEndData) { // we got a Fe message, we exit a sequence ValidateCurrentFormattingState(FormattingState.Formatting, o); _currentFormattingState = FormattingState.Reset; return(false); } else if (o is GroupStartData) { ValidateCurrentFormattingState(FormattingState.Formatting, o); _currentFormattingState = FormattingState.InsideGroup; return(false); } else if (o is GroupEndData) { ValidateCurrentFormattingState(FormattingState.InsideGroup, o); _currentFormattingState = FormattingState.Formatting; return(false); } // this is a raw object return(true); }
private void WritePayloadObject(PSObject so) { FormatEntryData o = this.viewManager.ViewGenerator.GeneratePayload(so, this.enumerationLimit); o.SetStreamTypeFromPSObject(so); this.WriteObject(o); List <ErrorRecord> errorRecordList = this.viewManager.ViewGenerator.ErrorManager.DrainFailedResultList(); this.WriteErrorRecords(errorRecordList); }
internal override FormatEntryData GeneratePayload(PSObject so, int enumerationLimit) { FormatEntryData fed = new FormatEntryData(); if (this.dataBaseInfo.view != null) fed.formatEntryInfo = GenerateComplexViewEntryFromDataBaseInfo(so, enumerationLimit); else fed.formatEntryInfo = GenerateComplexViewEntryFromProperties(so, enumerationLimit); return fed; }
/// <summary> /// write a row into the list /// </summary> /// <param name="fed">FormatEntryData to process</param> internal override void ProcessPayload(FormatEntryData fed) { ComplexViewEntry cve = fed.formatEntryInfo as ComplexViewEntry; if (cve == null || cve.formatValueList == null) { return; } _writer.WriteObject(cve.formatValueList); }
internal override void ProcessPayload(FormatEntryData fed) { WideViewEntry formatEntryInfo = fed.formatEntryInfo as WideViewEntry; FormatPropertyField formatPropertyField = formatEntryInfo.formatPropertyField; this.buffer.Add(formatPropertyField.propertyValue); if (this.buffer.IsFull) { this.WriteStringBuffer(); } }
internal override FormatEntryData GeneratePayload(PSObject so, int enumerationLimit) { FormatEntryData data = new FormatEntryData(); if (base.dataBaseInfo.view != null) { data.formatEntryInfo = this.GenerateComplexViewEntryFromDataBaseInfo(so, enumerationLimit); return data; } data.formatEntryInfo = this.GenerateComplexViewEntryFromProperties(so, enumerationLimit); return data; }
/// <summary> /// write a row into the table /// </summary> /// <param name="fed">FormatEntryData to process</param> internal override void ProcessPayload(FormatEntryData fed) { WideViewEntry wve = fed.formatEntryInfo as WideViewEntry; FormatPropertyField fpf = wve.formatPropertyField as FormatPropertyField; _buffer.Add(fpf.propertyValue); if (_buffer.IsFull) { WriteStringBuffer(); } }
internal static FormatEntryData GenerateOutOfBandObjectAsToString(PSObject so) { FormatEntryData data = new FormatEntryData { outOfBand = true }; RawTextFormatEntry entry = new RawTextFormatEntry { text = so.ToString() }; data.formatEntryInfo = entry; return data; }
/// <summary> /// write a payplad object by properly wrapping it into /// a FormatEntry object /// </summary> /// <param name="so">object to process</param> private void WritePayloadObject(PSObject so) { Diagnostics.Assert(so != null, "object so cannot be null"); FormatEntryData fed = _viewManager.ViewGenerator.GeneratePayload(so, _enumerationLimit); fed.SetStreamTypeFromPSObject(so); this.WriteObject(fed); List <ErrorRecord> errors = _viewManager.ViewGenerator.ErrorManager.DrainFailedResultList(); WriteErrorRecords(errors); }
internal static FormatEntryData GenerateOutOfBandObjectAsToString(PSObject so) { FormatEntryData data = new FormatEntryData { outOfBand = true }; RawTextFormatEntry entry = new RawTextFormatEntry { text = so.ToString() }; data.formatEntryInfo = entry; return(data); }
internal override FormatEntryData GeneratePayload(PSObject so, int enumerationLimit) { FormatEntryData data = new FormatEntryData(); if (base.dataBaseInfo.view != null) { data.formatEntryInfo = this.GenerateListViewEntryFromDataBaseInfo(so, enumerationLimit); return(data); } data.formatEntryInfo = this.GenerateListViewEntryFromProperties(so, enumerationLimit); return(data); }
private void ProcessOutOfBandPayload(FormatEntryData fed) { // try if it is raw text RawTextFormatEntry rte = fed.formatEntryInfo as RawTextFormatEntry; if (rte != null) { if (fed.isHelpObject) { ComplexWriter complexWriter = new ComplexWriter(); complexWriter.Initialize(_lo, _lo.ColumnNumber); complexWriter.WriteString(rte.text); } else { _lo.WriteLine(rte.text); } return; } // try if it is a complex entry ComplexViewEntry cve = fed.formatEntryInfo as ComplexViewEntry; if (cve != null && cve.formatValueList != null) { ComplexWriter complexWriter = new ComplexWriter(); complexWriter.Initialize(_lo, int.MaxValue); complexWriter.WriteObject(cve.formatValueList); return; } // try if it is a list view ListViewEntry lve = fed.formatEntryInfo as ListViewEntry; if (lve != null && lve.listViewFieldList != null) { ListWriter listWriter = new ListWriter(); _lo.WriteLine(""); string[] properties = ListOutputContext.GetProperties(lve); listWriter.Initialize(properties, _lo.ColumnNumber, _lo.DisplayCells); string[] values = ListOutputContext.GetValues(lve); listWriter.WriteProperties(values, _lo); _lo.WriteLine(""); return; } }
private void UpdateObjectCount(PacketInfoData o) { // add only of it's not a control message // and it's not out of band FormatEntryData fed = o as FormatEntryData; if (fed == null || fed.outOfBand) { return; } _currentObjectCount++; }
internal static FormatEntryData GenerateOutOfBandObjectAsToString(PSObject so) { FormatEntryData fed = new FormatEntryData(); fed.outOfBand = true; RawTextFormatEntry rawTextEntry = new RawTextFormatEntry(); rawTextEntry.text = so.ToString(); fed.formatEntryInfo = rawTextEntry; return(fed); }
internal void Process(object o) { PacketInfoData formatData = o as PacketInfoData; FormatEntryData formatEntryData = formatData as FormatEntryData; if (formatEntryData != null) { OutputContext c = null; if (!formatEntryData.outOfBand) { c = (OutputContext)this.stack.Peek(); } this.payload(formatEntryData, c); } else { bool flag = formatData is FormatStartData; bool flag2 = formatData is GroupStartData; if (flag || flag2) { OutputContext context2 = this.contextCreation(this.ActiveOutputContext, formatData); this.stack.Push(context2); if (flag) { this.fs(context2); } else if (flag2) { this.gs(context2); } } else { GroupEndData fe = formatData as GroupEndData; FormatEndData data4 = formatData as FormatEndData; if ((fe != null) || (data4 != null)) { OutputContext context3 = (OutputContext)this.stack.Peek(); if (data4 != null) { this.fe(data4, context3); } else if (fe != null) { this.ge(fe, context3); } this.stack.Pop(); } } } }
internal override FormatEntryData GeneratePayload(PSObject so, int enumerationLimit) { FormatEntryData fed = new FormatEntryData(); if (this.dataBaseInfo.view != null) { fed.formatEntryInfo = GenerateListViewEntryFromDataBaseInfo(so, enumerationLimit); } else { fed.formatEntryInfo = GenerateListViewEntryFromProperties(so, enumerationLimit); } return(fed); }
private void Notify() { if (this.notificationCallBack != null) { List <PacketInfoData> objects = new List <PacketInfoData>(); foreach (PacketInfoData data in this.queue) { FormatEntryData data2 = data as FormatEntryData; if ((data2 == null) || !data2.outOfBand) { objects.Add(data); } } this.notificationCallBack(this.formatStartData, objects); } }
private bool ProcessOutOfBand(PSObject so, bool isProcessingError) { List <ErrorRecord> list; FormatEntryData o = OutOfBandFormatViewManager.GenerateOutOfBandData(base.TerminatingErrorContext, this.expressionFactory, this._typeInfoDataBase, so, this.enumerationLimit, true, out list); if (!isProcessingError) { this.WriteErrorRecords(list); } if (o != null) { this.WriteObject(o); return(true); } return(false); }
private void ProcessCachedGroupOnTable(TableHeaderInfo thi, List <PacketInfoData> objects) { if (thi.tableColumnInfoList.Count != 0) { int[] numArray = new int[thi.tableColumnInfoList.Count]; for (int i = 0; i < thi.tableColumnInfoList.Count; i++) { string label = thi.tableColumnInfoList[i].label; if (string.IsNullOrEmpty(label)) { label = thi.tableColumnInfoList[i].propertyName; } if (string.IsNullOrEmpty(label)) { numArray[i] = 0; } else { numArray[i] = this.lo.DisplayCells.Length(label); } } foreach (PacketInfoData data in objects) { FormatEntryData data2 = data as FormatEntryData; if (data2 != null) { TableRowEntry formatEntryInfo = data2.formatEntryInfo as TableRowEntry; int index = 0; foreach (FormatPropertyField field in formatEntryInfo.formatPropertyFieldList) { int num2 = this.lo.DisplayCells.Length(field.propertyValue); if (numArray[index] < num2) { numArray[index] = num2; } index++; } } } TableFormattingHint hint = new TableFormattingHint { columnWidths = numArray }; this.formattingHint = hint; } }
private void WriteNewLineObject() { FormatEntryData fed = new FormatEntryData(); fed.outOfBand = true; ComplexViewEntry cve = new ComplexViewEntry(); FormatEntry fe = new FormatEntry(); cve.formatValueList.Add(fe); // Formating system writes newline before each object // so no need to add newline here like: // fe.formatValueList.Add(new FormatNewLine()); fed.formatEntryInfo = cve; this.WriteObject(fed); }
internal static FormatEntryData GenerateOutOfBandData(TerminatingErrorContext errorContext, MshExpressionFactory expressionFactory, TypeInfoDataBase db, PSObject so, int enumerationLimit, bool useToStringFallback, out List <ErrorRecord> errors) { ViewGenerator generator; errors = null; ConsolidatedString internalTypeNames = so.InternalTypeNames; ViewDefinition view = DisplayDataQuery.GetOutOfBandView(expressionFactory, db, internalTypeNames); if (view != null) { if (view.mainControl is ComplexControlBody) { generator = new ComplexViewGenerator(); } else { generator = new ListViewGenerator(); } generator.Initialize(errorContext, expressionFactory, db, view, null); } else { if (DefaultScalarTypes.IsTypeInList(internalTypeNames) || IsPropertyLessObject(so)) { return(GenerateOutOfBandObjectAsToString(so)); } if (!useToStringFallback) { return(null); } if (new MshExpression("*").ResolveNames(so).Count <= 0) { return(null); } generator = new ListViewGenerator(); generator.Initialize(errorContext, expressionFactory, so, db, null); } FormatEntryData data = generator.GeneratePayload(so, enumerationLimit); data.outOfBand = true; data.SetStreamTypeFromPSObject(so); errors = generator.ErrorManager.DrainFailedResultList(); return(data); }
private bool NeedsPreprocessing(object o) { FormatEntryData data = o as FormatEntryData; if (data != null) { if (!data.outOfBand) { this.ValidateCurrentFormattingState(FormattingState.InsideGroup, o); } return(false); } if (o is FormatStartData) { if (this.currentFormattingState == FormattingState.InsideGroup) { this.EndProcessing(); this.BeginProcessing(); } this.ValidateCurrentFormattingState(FormattingState.Reset, o); this.currentFormattingState = FormattingState.Formatting; return(false); } if (o is FormatEndData) { this.ValidateCurrentFormattingState(FormattingState.Formatting, o); this.currentFormattingState = FormattingState.Reset; return(false); } if (o is GroupStartData) { this.ValidateCurrentFormattingState(FormattingState.Formatting, o); this.currentFormattingState = FormattingState.InsideGroup; return(false); } if (o is GroupEndData) { this.ValidateCurrentFormattingState(FormattingState.InsideGroup, o); this.currentFormattingState = FormattingState.Formatting; return(false); } return(true); }
private bool ProcessOutOfBand(PSObject so, bool isProcessingError) { List <ErrorRecord> errors; FormatEntryData fed = OutOfBandFormatViewManager.GenerateOutOfBandData(this.TerminatingErrorContext, _expressionFactory, _typeInfoDataBase, so, _enumerationLimit, true, out errors); if (!isProcessingError) { WriteErrorRecords(errors); } if (fed != null) { this.WriteObject(fed); return(true); } return(false); }
protected void WriteInternalErrorMessage(string message) { FormatEntryData o = new FormatEntryData { outOfBand = true }; ComplexViewEntry entry = new ComplexViewEntry(); FormatEntry item = new FormatEntry(); entry.formatValueList.Add(item); item.formatValueList.Add(new FormatNewLine()); FormatTextField field = new FormatTextField { text = message }; item.formatValueList.Add(field); item.formatValueList.Add(new FormatNewLine()); o.formatEntryInfo = entry; this.WriteObject(o); }
private void ProcessOutOfBandPayload(FormatEntryData fed) { RawTextFormatEntry formatEntryInfo = fed.formatEntryInfo as RawTextFormatEntry; if (formatEntryInfo != null) { if (fed.isHelpObject) { ComplexWriter writer = new ComplexWriter(); writer.Initialize(this.lo, this.lo.ColumnNumber); writer.WriteString(formatEntryInfo.text); } else { this.lo.WriteLine(formatEntryInfo.text); } } else { ComplexViewEntry entry2 = fed.formatEntryInfo as ComplexViewEntry; if ((entry2 != null) && (entry2.formatValueList != null)) { ComplexWriter writer2 = new ComplexWriter(); writer2.Initialize(this.lo, this.lo.ColumnNumber); writer2.WriteObject(entry2.formatValueList); } else { ListViewEntry lve = fed.formatEntryInfo as ListViewEntry; if ((lve != null) && (lve.listViewFieldList != null)) { ListWriter writer3 = new ListWriter(); this.lo.WriteLine(""); string[] properties = ListOutputContext.GetProperties(lve); writer3.Initialize(properties, this.lo.ColumnNumber, this.lo.DisplayCells); string[] values = ListOutputContext.GetValues(lve); writer3.WriteProperties(values, this.lo); this.lo.WriteLine(""); } } } }
private bool ProcessOutOfBandObjectOutsideDocumentSequence(PSObject so) { if (this.ShouldProcessOutOfBand) { List <ErrorRecord> list; FormatEntryData o = null; if (so.InternalTypeNames.Count == 0) { return(false); } o = OutOfBandFormatViewManager.GenerateOutOfBandData(base.TerminatingErrorContext, this.expressionFactory, this._typeInfoDataBase, so, this.enumerationLimit, false, out list); this.WriteErrorRecords(list); if (o != null) { this.WriteObject(o); return(true); } } return(false); }
internal override FormatEntryData GeneratePayload(PSObject so, int enumerationLimit) { TableRowEntry entry; FormatEntryData data = new FormatEntryData(); if (base.dataBaseInfo.view != null) { entry = this.GenerateTableRowEntryFromDataBaseInfo(so, enumerationLimit); } else { entry = this.GenerateTableRowEntryFromFromProperties(so, enumerationLimit); entry.multiLine = base.dataBaseInfo.db.defaultSettingsSection.MultilineTables; } data.formatEntryInfo = entry; if ((base.parameters != null) && (base.parameters.shapeParameters != null)) { TableSpecificParameters shapeParameters = (TableSpecificParameters) base.parameters.shapeParameters; if ((shapeParameters != null) && shapeParameters.multiLine.HasValue) { entry.multiLine = shapeParameters.multiLine.Value; } } return data; }
/// <summary> /// write a row into the table /// </summary> /// <param name="fed">FormatEntryData to process</param> internal override void ProcessPayload(FormatEntryData fed) { int headerColumns = this.CurrentTableHeaderInfo.tableColumnInfoList.Count; if (headerColumns == 0) { return; } TableRowEntry tre = fed.formatEntryInfo as TableRowEntry; // need to make sure we have matching counts: the header count will have to prevail string[] values = new string[headerColumns]; int[] alignment = new int[headerColumns]; int fieldCount = tre.formatPropertyFieldList.Count; for (int k = 0; k < headerColumns; k++) { if (k < fieldCount) { values[k] = tre.formatPropertyFieldList[k].propertyValue; alignment[k] = tre.formatPropertyFieldList[k].alignment; } else { values[k] = ""; alignment[k] = TextAlignment.Left; // hard coded default } } this.Writer.GenerateRow(values, this.InnerCommand._lo, tre.multiLine, alignment, InnerCommand._lo.DisplayCells); }
private void ProcessOutOfBandPayload(FormatEntryData fed) { // try if it is raw text RawTextFormatEntry rte = fed.formatEntryInfo as RawTextFormatEntry; if (rte != null) { if (fed.isHelpObject) { ComplexWriter complexWriter = new ComplexWriter(); complexWriter.Initialize(_lo, _lo.ColumnNumber); complexWriter.WriteString(rte.text); } else { _lo.WriteLine(rte.text); } return; } // try if it is a complex entry ComplexViewEntry cve = fed.formatEntryInfo as ComplexViewEntry; if (cve != null && cve.formatValueList != null) { ComplexWriter complexWriter = new ComplexWriter(); complexWriter.Initialize(_lo, _lo.ColumnNumber); complexWriter.WriteObject(cve.formatValueList); return; } // try if it is a list view ListViewEntry lve = fed.formatEntryInfo as ListViewEntry; if (lve != null && lve.listViewFieldList != null) { ListWriter listWriter = new ListWriter(); _lo.WriteLine(""); string[] properties = ListOutputContext.GetProperties(lve); listWriter.Initialize(properties, _lo.ColumnNumber, _lo.DisplayCells); string[] values = ListOutputContext.GetValues(lve); listWriter.WriteProperties(values, _lo); _lo.WriteLine(""); return; } }
/// <summary> /// called when there is an entry to process, overrides will do /// things such as writing a row in a table /// </summary> /// <param name="fed">FormatEntryData to process</param> internal virtual void ProcessPayload(FormatEntryData fed) { }
/// <summary> /// write a row into the list /// </summary> /// <param name="fed">FormatEntryData to process</param> internal override void ProcessPayload(FormatEntryData fed) { ComplexViewEntry cve = fed.formatEntryInfo as ComplexViewEntry; if (cve == null || cve.formatValueList == null) return; _writer.WriteObject(cve.formatValueList); }
/// <summary> /// process the current payload object /// </summary> /// <param name="fed">FormatEntryData to process</param> /// <param name="c">currently active context</param> private void ProcessPayload(FormatEntryData fed, FormatMessagesContextManager.OutputContext c) { // we assume FormatEntryData as a standard wrapper if (fed == null) { PSTraceSource.NewArgumentNullException("fed"); } if (fed.formatEntryInfo == null) { PSTraceSource.NewArgumentNullException("fed.formatEntryInfo"); } WriteStreamType oldWSState = _lo.WriteStream; try { _lo.WriteStream = fed.writeStream; if (c == null) { ProcessOutOfBandPayload(fed); } else { GroupOutputContext goc = (GroupOutputContext)c; goc.ProcessPayload(fed); } } finally { _lo.WriteStream = oldWSState; } }
internal override FormatEntryData GeneratePayload(PSObject so, int enumerationLimit) { FormatEntryData fed = new FormatEntryData(); TableRowEntry tre; if (this.dataBaseInfo.view != null) { tre = GenerateTableRowEntryFromDataBaseInfo(so, enumerationLimit); } else { tre = GenerateTableRowEntryFromFromProperties(so, enumerationLimit); // get the global setting for multiline tre.multiLine = this.dataBaseInfo.db.defaultSettingsSection.MultilineTables; } fed.formatEntryInfo = tre; // override from command line, if there if (this.parameters != null && this.parameters.shapeParameters != null) { TableSpecificParameters tableSpecific = (TableSpecificParameters)this.parameters.shapeParameters; if (tableSpecific != null && tableSpecific.multiLine.HasValue) { tre.multiLine = tableSpecific.multiLine.Value; } } return fed; }
private void ProcessPayload(FormatEntryData fed, FormatMessagesContextManager.OutputContext c) { if (fed == null) { PSTraceSource.NewArgumentNullException("fed"); } if (fed.formatEntryInfo == null) { PSTraceSource.NewArgumentNullException("fed.formatEntryInfo"); } WriteStreamType writeStream = this.lo.WriteStream; try { this.lo.WriteStream = fed.writeStream; if (c == null) { this.ProcessOutOfBandPayload(fed); } else { ((GroupOutputContext) c).ProcessPayload(fed); } } finally { this.lo.WriteStream = writeStream; } }
internal override void ProcessPayload(FormatEntryData fed) { int count = this.CurrentTableHeaderInfo.tableColumnInfoList.Count; if (count != 0) { TableRowEntry formatEntryInfo = fed.formatEntryInfo as TableRowEntry; string[] values = new string[count]; int[] alignment = new int[count]; int num2 = formatEntryInfo.formatPropertyFieldList.Count; for (int i = 0; i < count; i++) { if (i < num2) { values[i] = formatEntryInfo.formatPropertyFieldList[i].propertyValue; alignment[i] = formatEntryInfo.formatPropertyFieldList[i].alignment; } else { values[i] = ""; alignment[i] = 1; } } base.Writer.GenerateRow(values, base.InnerCommand.lo, formatEntryInfo.multiLine, alignment, base.InnerCommand.lo.DisplayCells); } }
protected void WriteInternalErrorMessage(string message) { FormatEntryData fed = new FormatEntryData(); fed.outOfBand = true; ComplexViewEntry cve = new ComplexViewEntry(); FormatEntry fe = new FormatEntry(); cve.formatValueList.Add(fe); fe.formatValueList.Add(new FormatNewLine()); // get a field for the message FormatTextField ftf = new FormatTextField(); ftf.text = message; fe.formatValueList.Add(ftf); fe.formatValueList.Add(new FormatNewLine()); fed.formatEntryInfo = cve; this.WriteObject(fed); }
internal static FormatEntryData GenerateOutOfBandObjectAsToString(PSObject so) { FormatEntryData fed = new FormatEntryData(); fed.outOfBand = true; RawTextFormatEntry rawTextEntry = new RawTextFormatEntry(); rawTextEntry.text = so.ToString(); fed.formatEntryInfo = rawTextEntry; return fed; }