protected FormatPropertyField GenerateFormatPropertyField(List <FormatToken> formatTokenList, PSObject so, int enumerationLimit, out PSPropertyExpressionResult result)
        {
            result = null;
            FormatPropertyField fpf = new FormatPropertyField();

            if (formatTokenList.Count != 0)
            {
                FormatToken        token = formatTokenList[0];
                FieldPropertyToken fpt   = token as FieldPropertyToken;
                if (fpt != null)
                {
                    PSPropertyExpression ex = this.expressionFactory.CreateFromExpressionToken(fpt.expression, this.dataBaseInfo.view.loadingInfo);
                    fpf.propertyValue = this.GetExpressionDisplayValue(so, enumerationLimit, ex, fpt.fieldFormattingDirective, out result);
                }
                else
                {
                    TextToken tt = token as TextToken;
                    if (tt != null)
                    {
                        fpf.propertyValue = this.dataBaseInfo.db.displayResourceManagerCache.GetTextTokenString(tt);
                    }
                }
            }
            else
            {
                fpf.propertyValue = string.Empty;
            }

            return(fpf);
        }
Exemple #2
0
        internal GroupStartData GenerateGroupStartData(PSObject firstObjectInGroup, int enumerationLimit)
        {
            GroupStartData data = new GroupStartData();

            if (this.groupingManager != null)
            {
                object currentGroupingKeyPropertyValue = this.groupingManager.CurrentGroupingKeyPropertyValue;
                if (currentGroupingKeyPropertyValue == AutomationNull.Value)
                {
                    return(data);
                }
                PSObject    so      = PSObjectHelper.AsPSObject(currentGroupingKeyPropertyValue);
                ControlBase control = null;
                TextToken   tt      = null;
                if (((this.dataBaseInfo.view != null) && (this.dataBaseInfo.view.groupBy != null)) && (this.dataBaseInfo.view.groupBy.startGroup != null))
                {
                    control = this.dataBaseInfo.view.groupBy.startGroup.control;
                    tt      = this.dataBaseInfo.view.groupBy.startGroup.labelTextToken;
                }
                data.groupingEntry = new GroupingEntry();
                if (control == null)
                {
                    string            textTokenString;
                    StringFormatError formatErrorObject = null;
                    if (this.errorManager.DisplayFormatErrorString)
                    {
                        formatErrorObject = new StringFormatError();
                    }
                    string formatErrorString = PSObjectHelper.SmartToString(so, this.expressionFactory, enumerationLimit, formatErrorObject);
                    if ((formatErrorObject != null) && (formatErrorObject.exception != null))
                    {
                        this.errorManager.LogStringFormatError(formatErrorObject);
                        if (this.errorManager.DisplayFormatErrorString)
                        {
                            formatErrorString = this.errorManager.FormatErrorString;
                        }
                    }
                    FormatEntry item = new FormatEntry();
                    data.groupingEntry.formatValueList.Add(item);
                    FormatTextField field = new FormatTextField();
                    if (tt != null)
                    {
                        textTokenString = this.dataBaseInfo.db.displayResourceManagerCache.GetTextTokenString(tt);
                    }
                    else
                    {
                        textTokenString = this.groupingManager.GroupingKeyDisplayName;
                    }
                    field.text = StringUtil.Format(FormatAndOut_format_xxx.GroupStartDataIndentedAutoGeneratedLabel, textTokenString);
                    item.formatValueList.Add(field);
                    FormatPropertyField field2 = new FormatPropertyField {
                        propertyValue = formatErrorString
                    };
                    item.formatValueList.Add(field2);
                    return(data);
                }
                new ComplexControlGenerator(this.dataBaseInfo.db, this.dataBaseInfo.view.loadingInfo, this.expressionFactory, this.dataBaseInfo.view.formatControlDefinitionHolder.controlDefinitionList, this.ErrorManager, enumerationLimit, this.errorContext).GenerateFormatEntries(50, control, firstObjectInGroup, data.groupingEntry.formatValueList);
            }
            return(data);
        }
Exemple #3
0
        protected FormatPropertyField GenerateFormatPropertyField(List <FormatToken> formatTokenList, PSObject so, int enumerationLimit, out MshExpressionResult result)
        {
            result = null;
            FormatPropertyField field = new FormatPropertyField();

            if (formatTokenList.Count != 0)
            {
                FormatToken        token  = formatTokenList[0];
                FieldPropertyToken token2 = token as FieldPropertyToken;
                if (token2 != null)
                {
                    MshExpression ex = this.expressionFactory.CreateFromExpressionToken(token2.expression, this.dataBaseInfo.view.loadingInfo);
                    field.propertyValue = this.GetExpressionDisplayValue(so, enumerationLimit, ex, token2.fieldFormattingDirective, out result);
                    return(field);
                }
                TextToken tt = token as TextToken;
                if (tt != null)
                {
                    field.propertyValue = this.dataBaseInfo.db.displayResourceManagerCache.GetTextTokenString(tt);
                }
                return(field);
            }
            field.propertyValue = "";
            return(field);
        }
Exemple #4
0
        private ListViewEntry GenerateListViewEntryFromDataBaseInfo(PSObject so, int enumerationLimit)
        {
            ListViewEntry lve = new ListViewEntry();

            ListControlEntryDefinition activeListControlEntryDefinition =
                GetActiveListControlEntryDefinition(_listBody, so);

            foreach (ListControlItemDefinition listItem in activeListControlEntryDefinition.itemDefinitionList)
            {
                if (!EvaluateDisplayCondition(so, listItem.conditionToken))
                {
                    continue;
                }

                ListViewField lvf = new ListViewField();
                PSPropertyExpressionResult result;
                lvf.formatPropertyField = GenerateFormatPropertyField(listItem.formatTokenList, so, enumerationLimit, out result);

                // we need now to provide a label
                if (listItem.label != null)
                {
                    // if the directive provides one, we use it
                    lvf.label = this.dataBaseInfo.db.displayResourceManagerCache.GetTextTokenString(listItem.label);
                }
                else if (result != null)
                {
                    // if we got a valid match from the Mshexpression, use it as a label
                    lvf.label = result.ResolvedExpression.ToString();
                }
                else
                {
                    // we did fail getting a result (i.e. property does not exist on the object)

                    // we try to fall back and see if we have an un-resolved PSPropertyExpression
                    FormatToken        token = listItem.formatTokenList[0];
                    FieldPropertyToken fpt   = token as FieldPropertyToken;
                    if (fpt != null)
                    {
                        PSPropertyExpression ex = this.expressionFactory.CreateFromExpressionToken(fpt.expression, this.dataBaseInfo.view.loadingInfo);

                        // use the un-resolved PSPropertyExpression string as a label
                        lvf.label = ex.ToString();
                    }
                    else
                    {
                        TextToken tt = token as TextToken;
                        if (tt != null)
                        {
                            // we had a text token, use it as a label (last resort...)
                            lvf.label = this.dataBaseInfo.db.displayResourceManagerCache.GetTextTokenString(tt);
                        }
                    }
                }

                lve.listViewFieldList.Add(lvf);
            }

            return(lve);
        }
 internal string GetTextTokenString(TextToken tt)
 {
     if (tt.resource != null)
     {
         string resString = this.GetString(tt.resource);
         if (resString != null)
             return resString;
     }
     return tt.text;
 }
 internal string GetTextTokenString(TextToken tt)
 {
     if (tt.resource != null)
     {
         string resString = this.GetString(tt.resource);
         if (resString != null)
         {
             return(resString);
         }
     }
     return(tt.text);
 }
 internal string GetTextTokenString(TextToken tt)
 {
     if (tt.resource != null)
     {
         string str = this.GetString(tt.resource);
         if (str != null)
         {
             return str;
         }
     }
     return tt.text;
 }
Exemple #8
0
 internal string GetTextTokenString(TextToken tt)
 {
     if (tt.resource != null)
     {
         string str = this.GetString(tt.resource);
         if (str != null)
         {
             return(str);
         }
     }
     return(tt.text);
 }
        private ListViewEntry GenerateListViewEntryFromDataBaseInfo(PSObject so, int enumerationLimit)
        {
            ListViewEntry entry = new ListViewEntry();

            foreach (ListControlItemDefinition definition2 in this.GetActiveListControlEntryDefinition(this.listBody, so).itemDefinitionList)
            {
                if (base.EvaluateDisplayCondition(so, definition2.conditionToken))
                {
                    MshExpressionResult result;
                    ListViewField       item = new ListViewField {
                        formatPropertyField = base.GenerateFormatPropertyField(definition2.formatTokenList, so, enumerationLimit, out result)
                    };
                    if (definition2.label != null)
                    {
                        item.label = base.dataBaseInfo.db.displayResourceManagerCache.GetTextTokenString(definition2.label);
                    }
                    else if (result != null)
                    {
                        item.label = result.ResolvedExpression.ToString();
                    }
                    else
                    {
                        FormatToken        token  = definition2.formatTokenList[0];
                        FieldPropertyToken token2 = token as FieldPropertyToken;
                        if (token2 != null)
                        {
                            item.label = base.expressionFactory.CreateFromExpressionToken(token2.expression, base.dataBaseInfo.view.loadingInfo).ToString();
                        }
                        else
                        {
                            TextToken tt = token as TextToken;
                            if (tt != null)
                            {
                                item.label = base.dataBaseInfo.db.displayResourceManagerCache.GetTextTokenString(tt);
                            }
                        }
                    }
                    entry.listViewFieldList.Add(item);
                }
            }
            return(entry);
        }
        /// <summary>
        /// Load ListItems into ListControlItemDefinition
        /// </summary>
        /// <param name="lved"></param>
        /// <param name="listItems"></param>
        /// <param name="viewIndex"></param>
        /// <param name="typeName"></param>
        private void LoadListControlItemDefinitionsFromObjectModel(ListControlEntryDefinition lved, List<ListControlEntryItem> listItems, int viewIndex, string typeName)
        {
            foreach (ListControlEntryItem listItem in listItems)
            {
                ListControlItemDefinition lvid = new ListControlItemDefinition();

                // Contains:
                //   DisplayEntry --- Expression  cardinality 0..1
                //   Label        --- Label       cardinality 0..1
                if (listItem.DisplayEntry != null)
                {
                    ExpressionToken expression = LoadExpressionFromObjectModel(listItem.DisplayEntry, viewIndex, typeName);
                    if (expression == null)
                    {
                        lved.itemDefinitionList = null;
                        return; // fatal
                    }
                    FieldPropertyToken fpt = new FieldPropertyToken();
                    fpt.expression = expression;
                    fpt.fieldFormattingDirective.formatString = listItem.FormatString;
                    lvid.formatTokenList.Add(fpt);
                }

                if (!String.IsNullOrEmpty(listItem.Label))
                {
                    TextToken tt = new TextToken();
                    tt.text = listItem.Label;
                    lvid.label = tt;
                }

                lved.itemDefinitionList.Add(lvid);
            }

            // we must have at least a definition in th elist
            if (lved.itemDefinitionList.Count == 0)
            {
                //Error: At least one list view item must be specified.
                this.ReportErrorForLoadingFromObjectModel(
                    StringUtil.Format(FormatAndOutXmlLoadingStrings.NoListViewItemInFormattingData, typeName, viewIndex), typeName);
                lved.itemDefinitionList = null;
                return; //fatal
            }
        }
        /// <summary>
        /// Load the headers defined for columns
        /// </summary>
        /// <param name="tableBody"></param>
        /// <param name="headers"></param>
        private void LoadHeadersSectionFromObjectModel(TableControlBody tableBody, List<TableControlColumnHeader> headers)
        {
            foreach (TableControlColumnHeader header in headers)
            {
                TableColumnHeaderDefinition chd = new TableColumnHeaderDefinition();

                // Contains:
                //   Label     --- Label     cardinality 0..1
                //   Width     --- Width     cardinality 0..1
                //   Alignment --- Alignment cardinality 0..1
                if (!String.IsNullOrEmpty(header.Label))
                {
                    TextToken tt = new TextToken();
                    tt.text = header.Label;
                    chd.label = tt;
                }

                chd.width = header.Width;
                chd.alignment = (int)header.Alignment;
                tableBody.header.columnHeaderDefinitionList.Add(chd);
            }
        }
        private TextToken LoadTextToken(XmlNode n)
        {
            TextToken tt = new TextToken();

            if (!LoadStringResourceReference(n, out tt.resource))
            {
                return null;
            }
            if (tt.resource != null)
            {
                // inner text is optional
                tt.text = n.InnerText;
                return tt;
            }

            // inner text is mandatory
            tt.text = this.GetMandatoryInnerText(n);

            if (tt.text == null)
                return null;

            return tt;
        }
Exemple #13
0
        private TableHeaderInfo GenerateTableHeaderInfoFromDataBaseInfo(PSObject so)
        {
            bool            flag;
            TableHeaderInfo info = new TableHeaderInfo();
            List <TableRowItemDefinition> list = this.GetActiveTableRowDefinition(this.tableBody, so, out flag);

            info.hideHeader = this.HideHeaders;
            int num = 0;

            foreach (TableRowItemDefinition definition in list)
            {
                TableColumnInfo             item        = new TableColumnInfo();
                TableColumnHeaderDefinition definition2 = null;
                if (this.tableBody.header.columnHeaderDefinitionList.Count > 0)
                {
                    definition2 = this.tableBody.header.columnHeaderDefinitionList[num];
                }
                if (definition2 != null)
                {
                    item.width     = definition2.width;
                    item.alignment = definition2.alignment;
                    if (definition2.label != null)
                    {
                        item.label = base.dataBaseInfo.db.displayResourceManagerCache.GetTextTokenString(definition2.label);
                    }
                }
                if (item.alignment == 0)
                {
                    item.alignment = definition.alignment;
                }
                if (item.label == null)
                {
                    FormatToken token = null;
                    if (definition.formatTokenList.Count > 0)
                    {
                        token = definition.formatTokenList[0];
                    }
                    if (token != null)
                    {
                        FieldPropertyToken token2 = token as FieldPropertyToken;
                        if (token2 != null)
                        {
                            item.label = token2.expression.expressionValue;
                        }
                        else
                        {
                            TextToken tt = token as TextToken;
                            if (tt != null)
                            {
                                item.label = base.dataBaseInfo.db.displayResourceManagerCache.GetTextTokenString(tt);
                            }
                        }
                    }
                    else
                    {
                        item.label = "";
                    }
                }
                info.tableColumnInfoList.Add(item);
                num++;
            }
            return(info);
        }
        internal GroupStartData GenerateGroupStartData(PSObject firstObjectInGroup, int enumerationLimit)
        {
            GroupStartData startGroup = new GroupStartData();

            if (_groupingManager is null)
            {
                return(startGroup);
            }

            object currentGroupingValue = _groupingManager.CurrentGroupingKeyPropertyValue;

            if (currentGroupingValue == AutomationNull.Value)
            {
                return(startGroup);
            }

            PSObject so = PSObjectHelper.AsPSObject(currentGroupingValue);

            // we need to determine how to display the group header
            ControlBase control        = null;
            TextToken   labelTextToken = null;

            if (this.dataBaseInfo.view != null && this.dataBaseInfo.view.groupBy != null)
            {
                if (this.dataBaseInfo.view.groupBy.startGroup != null)
                {
                    // NOTE: from the database constraints, only one of the
                    // two will be non null
                    control        = this.dataBaseInfo.view.groupBy.startGroup.control;
                    labelTextToken = this.dataBaseInfo.view.groupBy.startGroup.labelTextToken;
                }
            }

            startGroup.groupingEntry = new GroupingEntry();

            if (control is null)
            {
                // we do not have a control, we auto generate a
                // snippet of complex display using a label

                StringFormatError formatErrorObject = null;
                if (_errorManager.DisplayFormatErrorString)
                {
                    // we send a format error object down to the formatting calls
                    // only if we want to show the formatting error strings
                    formatErrorObject = new StringFormatError();
                }

                string currentGroupingValueDisplay = PSObjectHelper.SmartToString(so, this.expressionFactory, enumerationLimit, formatErrorObject);

                if (formatErrorObject != null && formatErrorObject.exception != null)
                {
                    // if we did no thave any errors in the expression evaluation
                    // we might have errors in the formatting, if present
                    _errorManager.LogStringFormatError(formatErrorObject);
                    if (_errorManager.DisplayFormatErrorString)
                    {
                        currentGroupingValueDisplay = _errorManager.FormatErrorString;
                    }
                }

                FormatEntry fe = new FormatEntry();
                startGroup.groupingEntry.formatValueList.Add(fe);

                FormatTextField ftf = new FormatTextField();

                // determine what the label should be. If we have a label from the
                // database, let's use it, else fall back to the string provided
                // by the grouping manager
                string label;
                if (labelTextToken != null)
                {
                    label = this.dataBaseInfo.db.displayResourceManagerCache.GetTextTokenString(labelTextToken);
                }
                else
                {
                    label = _groupingManager.GroupingKeyDisplayName;
                }

                ftf.text = StringUtil.Format(FormatAndOut_format_xxx.GroupStartDataIndentedAutoGeneratedLabel, label);

                fe.formatValueList.Add(ftf);

                FormatPropertyField fpf = new FormatPropertyField();

                fpf.propertyValue = currentGroupingValueDisplay;
                fe.formatValueList.Add(fpf);
            }
            else
            {
                // NOTE: we set a max depth to protect ourselves from infinite loops
                const int maxTreeDepth = 50;
                ComplexControlGenerator controlGenerator =
                    new ComplexControlGenerator(this.dataBaseInfo.db,
                                                this.dataBaseInfo.view.loadingInfo,
                                                this.expressionFactory,
                                                this.dataBaseInfo.view.formatControlDefinitionHolder.controlDefinitionList,
                                                this.ErrorManager,
                                                enumerationLimit,
                                                this.errorContext);

                controlGenerator.GenerateFormatEntries(maxTreeDepth,
                                                       control, firstObjectInGroup, startGroup.groupingEntry.formatValueList);
            }

            return(startGroup);
        }
Exemple #15
0
        private ListControlItemDefinition LoadListControlItemDefinition(XmlNode propertyEntryNode)
        {
            using (this.StackFrame(propertyEntryNode))
            {
                // process Mshexpression, format string and text token
                ViewEntryNodeMatch match            = new ViewEntryNodeMatch(this);
                List <XmlNode>     unprocessedNodes = new List <XmlNode>();
                if (!match.ProcessExpressionDirectives(propertyEntryNode, unprocessedNodes))
                {
                    return(null); // fatal error
                }

                // process the remaining nodes
                TextToken       labelToken     = null;
                ExpressionToken condition      = null;
                bool            labelNodeFound = false;                  // cardinality 0..1
                bool            itemSelectionConditionNodeFound = false; // cardinality 0..1

                foreach (XmlNode n in unprocessedNodes)
                {
                    if (MatchNodeName(n, XmlTags.ItemSelectionConditionNode))
                    {
                        if (itemSelectionConditionNodeFound)
                        {
                            this.ProcessDuplicateNode(n);
                            return(null); // fatal error
                        }
                        itemSelectionConditionNodeFound = true;
                        condition = LoadItemSelectionCondition(n);
                        if (condition == null)
                        {
                            return(null); // fatal error
                        }
                    }
                    else if (MatchNodeNameWithAttributes(n, XmlTags.LabelNode))
                    {
                        if (labelNodeFound)
                        {
                            this.ProcessDuplicateNode(n);
                            return(null); // fatal error
                        }
                        labelNodeFound = true;
                        labelToken     = LoadLabel(n);
                        if (labelToken == null)
                        {
                            return(null); // fatal error
                        }
                    }
                    else
                    {
                        this.ProcessUnknownNode(n);
                    }
                }

                // finally build the item to return
                ListControlItemDefinition lvid = new ListControlItemDefinition();

                // add the label
                lvid.label = labelToken;

                // add condition
                lvid.conditionToken = condition;

                // add either the text token or the MshExpression with optional format string
                if (match.TextToken != null)
                {
                    lvid.formatTokenList.Add(match.TextToken);
                }
                else
                {
                    FieldPropertyToken fpt = new FieldPropertyToken();
                    fpt.expression = match.Expression;
                    fpt.fieldFormattingDirective.formatString = match.FormatString;
                    lvid.formatTokenList.Add(fpt);
                }
                return(lvid);
            }
        }
 private TextToken LoadTextToken(System.Xml.XmlNode n)
 {
     TextToken token = new TextToken();
     if (!this.LoadStringResourceReference(n, out token.resource))
     {
         return null;
     }
     if (token.resource != null)
     {
         token.text = n.InnerText;
         return token;
     }
     token.text = base.GetMandatoryInnerText(n);
     if (token.text == null)
     {
         return null;
     }
     return token;
 }
 private void LoadHeadersSectionFromObjectModel(TableControlBody tableBody, List<TableControlColumnHeader> headers)
 {
     foreach (TableControlColumnHeader header in headers)
     {
         TableColumnHeaderDefinition item = new TableColumnHeaderDefinition();
         if (!string.IsNullOrEmpty(header.Label))
         {
             TextToken token = new TextToken {
                 text = header.Label
             };
             item.label = token;
         }
         item.width = header.Width;
         item.alignment = (int) header.Alignment;
         tableBody.header.columnHeaderDefinitionList.Add(item);
     }
 }
 private void ExecuteFormatTokenList(TraversalInfo level, PSObject so, List <FormatToken> formatTokenList, List <FormatValue> formatValueList)
 {
     if (so == null)
     {
         throw PSTraceSource.NewArgumentNullException("so");
     }
     if (level.Level != level.MaxDepth)
     {
         FormatEntry item = new FormatEntry();
         formatValueList.Add(item);
         foreach (FormatToken token in formatTokenList)
         {
             TextToken tt = token as TextToken;
             if (tt != null)
             {
                 FormatTextField field = new FormatTextField {
                     text = this.db.displayResourceManagerCache.GetTextTokenString(tt)
                 };
                 item.formatValueList.Add(field);
             }
             else if (token is NewLineToken)
             {
                 item.formatValueList.Add(new FormatNewLine());
             }
             else
             {
                 FrameToken token3 = token as FrameToken;
                 if (token3 != null)
                 {
                     FormatEntry entry2 = new FormatEntry {
                         frameInfo = new FrameInfo()
                     };
                     entry2.frameInfo.firstLine        = token3.frameInfoDefinition.firstLine;
                     entry2.frameInfo.leftIndentation  = token3.frameInfoDefinition.leftIndentation;
                     entry2.frameInfo.rightIndentation = token3.frameInfoDefinition.rightIndentation;
                     this.ExecuteFormatTokenList(level, so, token3.itemDefinition.formatTokenList, entry2.formatValueList);
                     item.formatValueList.Add(entry2);
                 }
                 else
                 {
                     CompoundPropertyToken token4 = token as CompoundPropertyToken;
                     if ((token4 != null) && this.EvaluateDisplayCondition(so, token4.conditionToken))
                     {
                         object result = null;
                         if ((token4.expression == null) || string.IsNullOrEmpty(token4.expression.expressionValue))
                         {
                             result = so;
                         }
                         else
                         {
                             List <MshExpressionResult> values = this.expressionFactory.CreateFromExpressionToken(token4.expression, this.loadingInfo).GetValues(so);
                             if (values.Count > 0)
                             {
                                 result = values[0].Result;
                                 if (values[0].Exception != null)
                                 {
                                     this.errorManager.LogMshExpressionFailedResult(values[0], so);
                                 }
                             }
                         }
                         if ((token4.control == null) || (token4.control is FieldControlBody))
                         {
                             if (result == null)
                             {
                                 result = "";
                             }
                             FieldFormattingDirective fieldFormattingDirective = null;
                             StringFormatError        formatErrorObject        = null;
                             if (token4.control != null)
                             {
                                 fieldFormattingDirective = ((FieldControlBody)token4.control).fieldFormattingDirective;
                                 if ((fieldFormattingDirective != null) && this.errorManager.DisplayFormatErrorString)
                                 {
                                     formatErrorObject = new StringFormatError();
                                 }
                             }
                             IEnumerable         enumerable = PSObjectHelper.GetEnumerable(result);
                             FormatPropertyField field2     = new FormatPropertyField();
                             if (token4.enumerateCollection && (enumerable != null))
                             {
                                 foreach (object obj3 in enumerable)
                                 {
                                     if (obj3 != null)
                                     {
                                         field2 = new FormatPropertyField {
                                             propertyValue = PSObjectHelper.FormatField(fieldFormattingDirective, obj3, this.enumerationLimit, formatErrorObject, this.expressionFactory)
                                         };
                                         item.formatValueList.Add(field2);
                                     }
                                 }
                             }
                             else
                             {
                                 field2 = new FormatPropertyField {
                                     propertyValue = PSObjectHelper.FormatField(fieldFormattingDirective, result, this.enumerationLimit, formatErrorObject, this.expressionFactory)
                                 };
                                 item.formatValueList.Add(field2);
                             }
                             if ((formatErrorObject != null) && (formatErrorObject.exception != null))
                             {
                                 this.errorManager.LogStringFormatError(formatErrorObject);
                                 field2.propertyValue = this.errorManager.FormatErrorString;
                             }
                         }
                         else if (result != null)
                         {
                             IEnumerable enumerable2 = PSObjectHelper.GetEnumerable(result);
                             if (token4.enumerateCollection && (enumerable2 != null))
                             {
                                 foreach (object obj4 in enumerable2)
                                 {
                                     if (obj4 != null)
                                     {
                                         this.ExecuteFormatControl(level.NextLevel, token4.control, PSObject.AsPSObject(obj4), item.formatValueList);
                                     }
                                 }
                             }
                             else
                             {
                                 this.ExecuteFormatControl(level.NextLevel, token4.control, PSObjectHelper.AsPSObject(result), item.formatValueList);
                             }
                         }
                     }
                 }
             }
         }
     }
 }
 private void LoadListControlItemDefinitionsFromObjectModel(ListControlEntryDefinition lved, List<ListControlEntryItem> listItems, int viewIndex, string typeName)
 {
     foreach (ListControlEntryItem item in listItems)
     {
         ListControlItemDefinition definition = new ListControlItemDefinition();
         if (item.DisplayEntry != null)
         {
             ExpressionToken token = this.LoadExpressionFromObjectModel(item.DisplayEntry, viewIndex, typeName);
             if (token == null)
             {
                 lved.itemDefinitionList = null;
                 return;
             }
             FieldPropertyToken token2 = new FieldPropertyToken {
                 expression = token
             };
             definition.formatTokenList.Add(token2);
         }
         if (!string.IsNullOrEmpty(item.Label))
         {
             TextToken token3 = new TextToken {
                 text = item.Label
             };
             definition.label = token3;
         }
         lved.itemDefinitionList.Add(definition);
     }
     if (lved.itemDefinitionList.Count == 0)
     {
         base.ReportErrorForLoadingFromObjectModel(StringUtil.Format(FormatAndOutXmlLoadingStrings.NoListViewItemInFormattingData, typeName, viewIndex), typeName);
         lved.itemDefinitionList = null;
     }
 }
        private TableHeaderInfo GenerateTableHeaderInfoFromDataBaseInfo(PSObject so)
        {
            TableHeaderInfo thi = new TableHeaderInfo();

            bool dummy;
            List <TableRowItemDefinition> activeRowItemDefinitionList = GetActiveTableRowDefinition(_tableBody, so, out dummy);

            thi.hideHeader   = this.HideHeaders;
            thi.repeatHeader = this.RepeatHeader;

            int col = 0;

            foreach (TableRowItemDefinition rowItem in activeRowItemDefinitionList)
            {
                TableColumnInfo             ci        = new TableColumnInfo();
                TableColumnHeaderDefinition colHeader = null;
                if (_tableBody.header.columnHeaderDefinitionList.Count > 0)
                {
                    colHeader = _tableBody.header.columnHeaderDefinitionList[col];
                }

                if (colHeader != null)
                {
                    ci.width     = colHeader.width;
                    ci.alignment = colHeader.alignment;
                    if (colHeader.label != null)
                    {
                        ci.label = this.dataBaseInfo.db.displayResourceManagerCache.GetTextTokenString(colHeader.label);
                    }
                }

                if (ci.alignment == TextAlignment.Undefined)
                {
                    ci.alignment = rowItem.alignment;
                }

                if (ci.label == null)
                {
                    FormatToken token = null;
                    if (rowItem.formatTokenList.Count > 0)
                    {
                        token = rowItem.formatTokenList[0];
                    }
                    if (token != null)
                    {
                        FieldPropertyToken fpt = token as FieldPropertyToken;
                        if (fpt != null)
                        {
                            ci.label = fpt.expression.expressionValue;
                        }
                        else
                        {
                            TextToken tt = token as TextToken;
                            if (tt != null)
                            {
                                ci.label = this.dataBaseInfo.db.displayResourceManagerCache.GetTextTokenString(tt);
                            }
                        }
                    }
                    else
                    {
                        ci.label = string.Empty;
                    }
                }

                thi.tableColumnInfoList.Add(ci);
                col++;
            }

            return(thi);
        }
Exemple #21
0
        private void ExecuteFormatTokenList(TraversalInfo level,
                                            PSObject so, List <FormatToken> formatTokenList, List <FormatValue> formatValueList)
        {
            if (so == null)
            {
                throw PSTraceSource.NewArgumentNullException("so");
            }

            // guard against infinite loop
            if (level.Level == level.MaxDepth)
            {
                return;
            }

            FormatEntry fe = new FormatEntry();

            formatValueList.Add(fe);
            #region foreach loop
            foreach (FormatToken t in formatTokenList)
            {
                TextToken tt = t as TextToken;
                if (tt != null)
                {
                    FormatTextField ftf = new FormatTextField();
                    ftf.text = _db.displayResourceManagerCache.GetTextTokenString(tt);
                    fe.formatValueList.Add(ftf);
                    continue;
                }
                var newline = t as NewLineToken;
                if (newline != null)
                {
                    for (int i = 0; i < newline.count; i++)
                    {
                        fe.formatValueList.Add(new FormatNewLine());
                    }
                    continue;
                }
                FrameToken ft = t as FrameToken;
                if (ft != null)
                {
                    // instantiate a new entry and attach a frame info object
                    FormatEntry feFrame = new FormatEntry();
                    feFrame.frameInfo = new FrameInfo();

                    // add the frame info
                    feFrame.frameInfo.firstLine        = ft.frameInfoDefinition.firstLine;
                    feFrame.frameInfo.leftIndentation  = ft.frameInfoDefinition.leftIndentation;
                    feFrame.frameInfo.rightIndentation = ft.frameInfoDefinition.rightIndentation;

                    // execute the list inside the frame
                    ExecuteFormatTokenList(level, so, ft.itemDefinition.formatTokenList, feFrame.formatValueList);

                    // add the frame computation results to the current format entry
                    fe.formatValueList.Add(feFrame);
                    continue;
                }
                #region CompoundPropertyToken
                CompoundPropertyToken cpt = t as CompoundPropertyToken;
                if (cpt != null)
                {
                    if (!EvaluateDisplayCondition(so, cpt.conditionToken))
                    {
                        // token not active, skip it
                        continue;
                    }

                    // get the property from the object
                    object val = null;

                    // if no expression was specified, just use the
                    // object itself
                    if (cpt.expression == null || string.IsNullOrEmpty(cpt.expression.expressionValue))
                    {
                        val = so;
                    }
                    else
                    {
                        PSPropertyExpression ex = _expressionFactory.CreateFromExpressionToken(cpt.expression, _loadingInfo);
                        List <PSPropertyExpressionResult> resultList = ex.GetValues(so);
                        if (resultList.Count > 0)
                        {
                            val = resultList[0].Result;
                            if (resultList[0].Exception != null)
                            {
                                _errorManager.LogPSPropertyExpressionFailedResult(resultList[0], so);
                            }
                        }
                    }

                    // if the token is has a formatting string, it's a leaf node,
                    // do the formatting and we will be done
                    if (cpt.control == null || cpt.control is FieldControlBody)
                    {
                        // Since it is a leaf node we just consider it an empty string and go
                        // on with formatting
                        if (val == null)
                        {
                            val = string.Empty;
                        }
                        FieldFormattingDirective fieldFormattingDirective = null;
                        StringFormatError        formatErrorObject        = null;
                        if (cpt.control != null)
                        {
                            fieldFormattingDirective = ((FieldControlBody)cpt.control).fieldFormattingDirective;
                            if (fieldFormattingDirective != null && _errorManager.DisplayFormatErrorString)
                            {
                                formatErrorObject = new StringFormatError();
                            }
                        }

                        IEnumerable         e   = PSObjectHelper.GetEnumerable(val);
                        FormatPropertyField fpf = new FormatPropertyField();
                        if (cpt.enumerateCollection && e != null)
                        {
                            foreach (object x in e)
                            {
                                if (x == null)
                                {
                                    // nothing to process
                                    continue;
                                }
                                fpf = new FormatPropertyField();

                                fpf.propertyValue = PSObjectHelper.FormatField(fieldFormattingDirective, x, _enumerationLimit, formatErrorObject, _expressionFactory);
                                fe.formatValueList.Add(fpf);
                            }
                        }
                        else
                        {
                            fpf = new FormatPropertyField();

                            fpf.propertyValue = PSObjectHelper.FormatField(fieldFormattingDirective, val, _enumerationLimit, formatErrorObject, _expressionFactory);
                            fe.formatValueList.Add(fpf);
                        }
                        if (formatErrorObject != null && formatErrorObject.exception != null)
                        {
                            _errorManager.LogStringFormatError(formatErrorObject);
                            fpf.propertyValue = _errorManager.FormatErrorString;
                        }
                    }
                    else
                    {
                        // An empty result that is not a leaf node should not be expanded
                        if (val == null)
                        {
                            continue;
                        }
                        IEnumerable e = PSObjectHelper.GetEnumerable(val);
                        if (cpt.enumerateCollection && e != null)
                        {
                            foreach (object x in e)
                            {
                                if (x == null)
                                {
                                    // nothing to process
                                    continue;
                                }

                                // proceed with the recursion
                                ExecuteFormatControl(level.NextLevel, cpt.control, PSObject.AsPSObject(x), fe.formatValueList);
                            }
                        }
                        else
                        {
                            // proceed with the recursion
                            ExecuteFormatControl(level.NextLevel, cpt.control, PSObjectHelper.AsPSObject(val), fe.formatValueList);
                        }
                    }
                }
                #endregion CompoundPropertyToken
            }
            #endregion foreach loop
        }
        private List <FormatToken> LoadComplexControlTokenListDefinitions(XmlNode bodyNode)
        {
            using (this.StackFrame(bodyNode))
            {
                List <FormatToken> formatTokenList = new List <FormatToken>();

                int compoundPropertyIndex = 0;
                int newLineIndex          = 0;
                int textIndex             = 0;
                int frameIndex            = 0;

                foreach (XmlNode n in bodyNode.ChildNodes)
                {
                    if (MatchNodeName(n, XmlTags.ExpressionBindingNode))
                    {
                        CompoundPropertyToken cpt = LoadCompoundProperty(n, compoundPropertyIndex++);

                        if (cpt == null)
                        {
                            //Error at XPath {0} in file {1}: {2} failed to load.
                            this.ReportError(StringUtil.Format(FormatAndOutXmlLoadingStrings.LoadTagFailed, ComputeCurrentXPath(), FilePath, XmlTags.ExpressionBindingNode));
                            return(null);
                        }

                        formatTokenList.Add(cpt);
                    }
                    else if (MatchNodeName(n, XmlTags.NewLineNode))
                    {
                        NewLineToken nlt = LoadNewLine(n, newLineIndex++);

                        if (nlt == null)
                        {
                            //Error at XPath {0} in file {1}: {2} failed to load.
                            this.ReportError(StringUtil.Format(FormatAndOutXmlLoadingStrings.LoadTagFailed, ComputeCurrentXPath(), FilePath, XmlTags.NewLineNode));
                            return(null);
                        }

                        formatTokenList.Add(nlt);
                    }
                    else if (MatchNodeNameWithAttributes(n, XmlTags.TextNode))
                    {
                        TextToken tt = LoadText(n, textIndex++);

                        if (tt == null)
                        {
                            //Error at XPath {0} in file {1}: {2} failed to load.
                            this.ReportError(StringUtil.Format(FormatAndOutXmlLoadingStrings.LoadTagFailed, ComputeCurrentXPath(), FilePath, XmlTags.TextNode));
                            return(null);
                        }

                        formatTokenList.Add(tt);
                    }
                    else if (MatchNodeName(n, XmlTags.FrameNode))
                    {
                        FrameToken frame = LoadFrameDefinition(n, frameIndex++);

                        if (frame == null)
                        {
                            //Error at XPath {0} in file {1}: {2} failed to load.
                            this.ReportError(StringUtil.Format(FormatAndOutXmlLoadingStrings.LoadTagFailed, ComputeCurrentXPath(), FilePath, XmlTags.FrameNode));
                            return(null);
                        }

                        formatTokenList.Add(frame);
                    }
                    else
                    {
                        this.ProcessUnknownNode(n);
                    }
                }

                if (formatTokenList.Count == 0)
                {
                    //Error at XPath {0} in file {1}: Empty custom control token list.
                    this.ReportError(StringUtil.Format(FormatAndOutXmlLoadingStrings.EmptyCustomControlList, ComputeCurrentXPath(), FilePath));
                    return(null);
                }

                return(formatTokenList);
            }
        }