private void LoadColumnEntries(XmlNode columnEntriesNode, TableRowDefinition trd)
{
using (this.StackFrame(columnEntriesNode))
{
int columnEntryIndex = 0;
foreach (XmlNode n in columnEntriesNode.ChildNodes)
{
if (MatchNodeName(n, XmlTags.TableColumnItemNode))
{
TableRowItemDefinition rid = LoadColumnEntry(n, columnEntryIndex++);
if (rid != null)
{
trd.rowItemDefinitionList.Add(rid);
}
else
{
// we failed one entry: fatal error to percolate up
// remove all the entries
trd.rowItemDefinitionList = null;
return; // fatal error
}
}
else
{
this.ProcessUnknownNode(n);
}
}
}
}
private TableRowDefinition LoadRowEntryDefinition(XmlNode rowEntryNode, int index)
{
using (this.StackFrame(rowEntryNode, index))
{
bool appliesToNodeFound = false; // cardinality 0..1
bool columnEntriesNodeFound = false; // cardinality 1
bool multiLineFound = false; // cardinality 0..1
TableRowDefinition trd = new TableRowDefinition();
foreach (XmlNode n in rowEntryNode.ChildNodes)
{
if (MatchNodeName(n, XmlTags.EntrySelectedByNode))
{
if (appliesToNodeFound)
{
this.ProcessDuplicateNode(n);
return(null); // fatal error
}
appliesToNodeFound = true;
// optional section
trd.appliesTo = LoadAppliesToSection(n, true);
}
else if (MatchNodeName(n, XmlTags.TableColumnItemsNode))
{
if (columnEntriesNodeFound)
{
this.ProcessDuplicateNode(n);
return(null); //fatal
}
LoadColumnEntries(n, trd);
if (trd.rowItemDefinitionList == null)
{
return(null); // fatal error
}
}
else if (MatchNodeName(n, XmlTags.MultiLineNode))
{
if (multiLineFound)
{
this.ProcessDuplicateNode(n);
return(null); //fatal
}
multiLineFound = true;
if (!this.ReadBooleanNode(n, out trd.multiLine))
{
return(null); //fatal error
}
}
else
{
this.ProcessUnknownNode(n);
}
}
return(trd);
}
}
internal TableRowDefinition Copy()
{
TableRowDefinition tableRowDefinition = new TableRowDefinition();
tableRowDefinition.appliesTo = this.appliesTo;
tableRowDefinition.multiLine = this.multiLine;
foreach (TableRowItemDefinition rowItemDefinition in this.rowItemDefinitionList)
{
tableRowDefinition.rowItemDefinitionList.Add(rowItemDefinition);
}
return(tableRowDefinition);
}
internal TableRowDefinition Copy()
{
TableRowDefinition definition = new TableRowDefinition {
appliesTo = this.appliesTo,
multiLine = this.multiLine
};
foreach (TableRowItemDefinition definition2 in this.rowItemDefinitionList)
{
definition.rowItemDefinitionList.Add(definition2);
}
return definition;
}
internal TableRowDefinition Copy()
{
TableRowDefinition definition = new TableRowDefinition {
appliesTo = this.appliesTo,
multiLine = this.multiLine
};
foreach (TableRowItemDefinition definition2 in this.rowItemDefinitionList)
{
definition.rowItemDefinitionList.Add(definition2);
}
return(definition);
}
private void LoadRowEntriesSection(TableControlBody tableBody, XmlNode rowEntriesNode)
{
using (this.StackFrame(rowEntriesNode))
{
int rowEntryIndex = 0;
foreach (XmlNode n in rowEntriesNode.ChildNodes)
{
if (MatchNodeName(n, XmlTags.TableRowEntryNode))
{
TableRowDefinition trd = LoadRowEntryDefinition(n, rowEntryIndex++);
if (trd == null)
{
//Error at XPath {0} in file {1}: {2} failed to load.
this.ReportError(StringUtil.Format(FormatAndOutXmlLoadingStrings.LoadTagFailed, ComputeCurrentXPath(), FilePath, XmlTags.TableRowEntryNode));
tableBody.defaultDefinition = null;
return; // fatal error
}
// determine if we have a default entry and if it's already set
if (trd.appliesTo == null)
{
if (tableBody.defaultDefinition == null)
{
tableBody.defaultDefinition = trd;
}
else
{
//Error at XPath {0} in file {1}: There cannot be more than one default {2}.
this.ReportError(StringUtil.Format(FormatAndOutXmlLoadingStrings.TooManyDefaultShapeEntry, ComputeCurrentXPath(), FilePath, XmlTags.TableRowEntryNode));
tableBody.defaultDefinition = null;
return; // fatal error
}
}
else
{
tableBody.optionalDefinitionList.Add(trd);
}
}
else
{
this.ProcessUnknownNode(n);
}
}
if (tableBody.defaultDefinition == null)
{
//Error at XPath {0} in file {1}: There must be at least one default {2}.
this.ReportError(StringUtil.Format(FormatAndOutXmlLoadingStrings.NoDefaultShapeEntry, ComputeCurrentXPath(), FilePath, XmlTags.TableRowEntryNode));
}
}
}
/// <summary>
/// Returns a Shallow Copy of the current object.
/// </summary>
/// <returns></returns>
internal TableRowDefinition Copy()
{
TableRowDefinition result = new TableRowDefinition
{
appliesTo = this.appliesTo,
multiLine = this.multiLine
};
foreach (TableRowItemDefinition trid in this.rowItemDefinitionList)
{
result.rowItemDefinitionList.Add(trid);
}
return(result);
}
internal TableControlRow(TableRowDefinition rowdefinition)
{
this._columns = new List<TableControlColumn>();
foreach (TableRowItemDefinition definition in rowdefinition.rowItemDefinitionList)
{
TableControlColumn column;
FieldPropertyToken token = definition.formatTokenList[0] as FieldPropertyToken;
if (token != null)
{
column = new TableControlColumn(token.expression.expressionValue, definition.alignment, token.expression.isScriptBlock);
}
else
{
column = new TableControlColumn();
}
this._columns.Add(column);
}
}
private TableRowDefinition LoadRowEntryDefinition(System.Xml.XmlNode rowEntryNode, int index)
{
using (base.StackFrame(rowEntryNode, index))
{
bool flag = false;
bool flag2 = false;
bool flag3 = false;
TableRowDefinition trd = new TableRowDefinition();
foreach (System.Xml.XmlNode node in rowEntryNode.ChildNodes)
{
if (base.MatchNodeName(node, "EntrySelectedBy"))
{
if (flag)
{
base.ProcessDuplicateNode(node);
return null;
}
flag = true;
trd.appliesTo = this.LoadAppliesToSection(node, true);
}
else if (base.MatchNodeName(node, "TableColumnItems"))
{
if (flag2)
{
base.ProcessDuplicateNode(node);
return null;
}
this.LoadColumnEntries(node, trd);
if (trd.rowItemDefinitionList == null)
{
return null;
}
}
else if (base.MatchNodeName(node, "Wrap"))
{
if (flag3)
{
base.ProcessDuplicateNode(node);
return null;
}
flag3 = true;
if (!this.ReadBooleanNode(node, out trd.multiLine))
{
return null;
}
}
else
{
base.ProcessUnknownNode(node);
}
}
return trd;
}
}
private void LoadRowEntriesSectionFromObjectModel(TableControlBody tableBody, List<TableControlRow> rowEntries, int viewIndex, string typeName)
{
foreach (TableControlRow row in rowEntries)
{
TableRowDefinition trd = new TableRowDefinition();
if (row.Columns.Count > 0)
{
this.LoadColumnEntriesFromObjectModel(trd, row.Columns, viewIndex, typeName);
if (trd.rowItemDefinitionList == null)
{
tableBody.defaultDefinition = null;
return;
}
}
tableBody.defaultDefinition = trd;
}
if (tableBody.defaultDefinition == null)
{
base.ReportErrorForLoadingFromObjectModel(StringUtil.Format(FormatAndOutXmlLoadingStrings.NoDefaultShapeEntryInFormattingData, new object[] { typeName, viewIndex, "TableRowEntry" }), typeName);
}
}
private void LoadColumnEntriesFromObjectModel(TableRowDefinition trd, List<TableControlColumn> columns, int viewIndex, string typeName)
{
foreach (TableControlColumn column in columns)
{
TableRowItemDefinition item = new TableRowItemDefinition();
if (column.DisplayEntry != null)
{
ExpressionToken token = this.LoadExpressionFromObjectModel(column.DisplayEntry, viewIndex, typeName);
if (token == null)
{
trd.rowItemDefinitionList = null;
break;
}
FieldPropertyToken token2 = new FieldPropertyToken {
expression = token
};
item.formatTokenList.Add(token2);
}
item.alignment = (int) column.Alignment;
trd.rowItemDefinitionList.Add(item);
}
}
private void LoadColumnEntries(System.Xml.XmlNode columnEntriesNode, TableRowDefinition trd)
{
using (base.StackFrame(columnEntriesNode))
{
int num = 0;
foreach (System.Xml.XmlNode node in columnEntriesNode.ChildNodes)
{
if (base.MatchNodeName(node, "TableColumnItem"))
{
TableRowItemDefinition item = this.LoadColumnEntry(node, num++);
if (item != null)
{
trd.rowItemDefinitionList.Add(item);
continue;
}
trd.rowItemDefinitionList = null;
return;
}
base.ProcessUnknownNode(node);
}
}
}
/// <summary>
/// Load the column items into the TableRowDefinition
/// </summary>
/// <param name="trd"></param>
/// <param name="columns"></param>
/// <param name="viewIndex"></param>
/// <param name="typeName"></param>
private void LoadColumnEntriesFromObjectModel(TableRowDefinition trd, List<TableControlColumn> columns, int viewIndex, string typeName)
{
foreach (TableControlColumn column in columns)
{
TableRowItemDefinition rid = new TableRowItemDefinition();
// Contain:
// DisplayEntry --- Expression cardinality: 0..1
// Alignment --- Alignment cardinality: 0..1
if (column.DisplayEntry != null)
{
ExpressionToken expression = LoadExpressionFromObjectModel(column.DisplayEntry, viewIndex, typeName);
if (expression == null)
{
trd.rowItemDefinitionList = null;
return;
}
FieldPropertyToken fpt = new FieldPropertyToken();
fpt.expression = expression;
fpt.fieldFormattingDirective.formatString = column.FormatString;
rid.formatTokenList.Add(fpt);
}
rid.alignment = (int)column.Alignment;
trd.rowItemDefinitionList.Add(rid);
}
}
/// <summary>
/// Load row enties, set the defaultDefinition of the TableControlBody.
/// </summary>
/// <param name="tableBody"></param>
/// <param name="rowEntries"></param>
/// <param name="viewIndex"></param>
/// <param name="typeName"></param>
private void LoadRowEntriesSectionFromObjectModel(TableControlBody tableBody, List<TableControlRow> rowEntries, int viewIndex, string typeName)
{
foreach (TableControlRow row in rowEntries)
{
TableRowDefinition trd = new TableRowDefinition { multiLine = row.Wrap };
// Contains:
// Columns --- TableColumnItems cardinality: 0..1
// No SelectedBy is supplied in the TableControlRow
if (row.Columns.Count > 0)
{
LoadColumnEntriesFromObjectModel(trd, row.Columns, viewIndex, typeName);
// trd.rowItemDefinitionList is null, it means there was a failure
if (trd.rowItemDefinitionList == null)
{
tableBody.defaultDefinition = null;
return;
}
}
if (row.SelectedBy != null)
{
trd.appliesTo = LoadAppliesToSectionFromObjectModel(row.SelectedBy.TypeNames, row.SelectedBy.SelectionCondition);
tableBody.optionalDefinitionList.Add(trd);
}
else
{
tableBody.defaultDefinition = trd;
}
}
// rowEntries must not be empty
if (tableBody.defaultDefinition == null)
{
this.ReportErrorForLoadingFromObjectModel(
StringUtil.Format(FormatAndOutXmlLoadingStrings.NoDefaultShapeEntryInFormattingData, typeName, viewIndex, XmlTags.TableRowEntryNode), typeName);
return;
}
}
private void LoadColumnEntries(XmlNode columnEntriesNode, TableRowDefinition trd)
{
using (this.StackFrame(columnEntriesNode))
{
int columnEntryIndex = 0;
foreach (XmlNode n in columnEntriesNode.ChildNodes)
{
if (MatchNodeName(n, XmlTags.TableColumnItemNode))
{
TableRowItemDefinition rid = LoadColumnEntry(n, columnEntryIndex++);
if (rid != null)
{
trd.rowItemDefinitionList.Add(rid);
}
else
{
// we failed one entry: fatal error to percolate up
// remove all the entries
trd.rowItemDefinitionList = null;
return; // fatal error
}
}
else
{
this.ProcessUnknownNode(n);
}
}
}
}
/// <summary>
/// Returns a Shallow Copy of the current object.
/// </summary>
/// <returns></returns>
internal TableRowDefinition Copy()
{
TableRowDefinition result = new TableRowDefinition
{
appliesTo = this.appliesTo,
multiLine = this.multiLine
};
foreach (TableRowItemDefinition trid in this.rowItemDefinitionList)
{
result.rowItemDefinitionList.Add(trid);
}
return result;
}
private List <TableRowItemDefinition> GetActiveTableRowDefinition(TableControlBody tableBody, PSObject so,
out bool multiLine)
{
multiLine = tableBody.defaultDefinition.multiLine;
if (tableBody.optionalDefinitionList.Count == 0)
{
// we do not have any override, use default
return(tableBody.defaultDefinition.rowItemDefinitionList);
}
// see if we have an override that matches
TableRowDefinition matchingRowDefinition = null;
var typeNames = so.InternalTypeNames;
TypeMatch match = new TypeMatch(expressionFactory, this.dataBaseInfo.db, typeNames);
foreach (TableRowDefinition x in tableBody.optionalDefinitionList)
{
if (match.PerfectMatch(new TypeMatchItem(x, x.appliesTo)))
{
matchingRowDefinition = x;
break;
}
}
if (matchingRowDefinition == null)
{
matchingRowDefinition = match.BestMatch as TableRowDefinition;
}
if (matchingRowDefinition == null)
{
Collection <string> typesWithoutPrefix = Deserializer.MaskDeserializationPrefix(typeNames);
if (typesWithoutPrefix != null)
{
match = new TypeMatch(expressionFactory, this.dataBaseInfo.db, typesWithoutPrefix);
foreach (TableRowDefinition x in tableBody.optionalDefinitionList)
{
if (match.PerfectMatch(new TypeMatchItem(x, x.appliesTo)))
{
matchingRowDefinition = x;
break;
}
}
if (matchingRowDefinition == null)
{
matchingRowDefinition = match.BestMatch as TableRowDefinition;
}
}
}
if (matchingRowDefinition == null)
{
// no matching override, use default
return(tableBody.defaultDefinition.rowItemDefinitionList);
}
// the overriding row definition takes the precedence
if (matchingRowDefinition.multiLine)
{
multiLine = matchingRowDefinition.multiLine;
}
// we have an override, we need to compute the merge of the active cells
List <TableRowItemDefinition> activeRowItemDefinitionList = new List <TableRowItemDefinition>();
int col = 0;
foreach (TableRowItemDefinition rowItem in matchingRowDefinition.rowItemDefinitionList)
{
// check if the row is an override or not
if (rowItem.formatTokenList.Count == 0)
{
// it's a place holder, use the default
activeRowItemDefinitionList.Add(tableBody.defaultDefinition.rowItemDefinitionList[col]);
}
else
{
// use the override
activeRowItemDefinitionList.Add(rowItem);
}
col++;
}
return(activeRowItemDefinitionList);
}
private List <TableRowItemDefinition> GetActiveTableRowDefinition(TableControlBody tableBody, PSObject so, out bool multiLine)
{
multiLine = tableBody.defaultDefinition.multiLine;
if (tableBody.optionalDefinitionList.Count == 0)
{
return(tableBody.defaultDefinition.rowItemDefinitionList);
}
TableRowDefinition bestMatch = null;
ConsolidatedString internalTypeNames = so.InternalTypeNames;
TypeMatch match = new TypeMatch(base.expressionFactory, base.dataBaseInfo.db, internalTypeNames);
foreach (TableRowDefinition definition2 in tableBody.optionalDefinitionList)
{
if (match.PerfectMatch(new TypeMatchItem(definition2, definition2.appliesTo)))
{
bestMatch = definition2;
break;
}
}
if (bestMatch == null)
{
bestMatch = match.BestMatch as TableRowDefinition;
}
if (bestMatch == null)
{
Collection <string> typeNames = Deserializer.MaskDeserializationPrefix(internalTypeNames);
if (typeNames != null)
{
match = new TypeMatch(base.expressionFactory, base.dataBaseInfo.db, typeNames);
foreach (TableRowDefinition definition3 in tableBody.optionalDefinitionList)
{
if (match.PerfectMatch(new TypeMatchItem(definition3, definition3.appliesTo)))
{
bestMatch = definition3;
break;
}
}
if (bestMatch == null)
{
bestMatch = match.BestMatch as TableRowDefinition;
}
}
}
if (bestMatch == null)
{
return(tableBody.defaultDefinition.rowItemDefinitionList);
}
if (bestMatch.multiLine)
{
multiLine = bestMatch.multiLine;
}
List <TableRowItemDefinition> list = new List <TableRowItemDefinition>();
int num = 0;
foreach (TableRowItemDefinition definition4 in bestMatch.rowItemDefinitionList)
{
if (definition4.formatTokenList.Count == 0)
{
list.Add(tableBody.defaultDefinition.rowItemDefinitionList[num]);
}
else
{
list.Add(definition4);
}
num++;
}
return(list);
}
internal TableControlRow(TableRowDefinition rowdefinition) : this()
{
Wrap = rowdefinition.multiLine;
if (rowdefinition.appliesTo != null)
{
SelectedBy = EntrySelectedBy.Get(rowdefinition.appliesTo.referenceList);
}
foreach (TableRowItemDefinition itemdef in rowdefinition.rowItemDefinitionList)
{
FieldPropertyToken fpt = itemdef.formatTokenList[0] as FieldPropertyToken;
TableControlColumn column;
if (fpt != null)
{
column = new TableControlColumn(fpt.expression.expressionValue, itemdef.alignment,
fpt.expression.isScriptBlock, fpt.fieldFormattingDirective.formatString);
}
else
{
column = new TableControlColumn();
}
Columns.Add(column);
}
}
private TableRowDefinition LoadRowEntryDefinition(XmlNode rowEntryNode, int index)
{
using (this.StackFrame(rowEntryNode, index))
{
bool appliesToNodeFound = false; // cardinality 0..1
bool columnEntriesNodeFound = false; // cardinality 1
bool multiLineFound = false; // cardinality 0..1
TableRowDefinition trd = new TableRowDefinition();
foreach (XmlNode n in rowEntryNode.ChildNodes)
{
if (MatchNodeName(n, XmlTags.EntrySelectedByNode))
{
if (appliesToNodeFound)
{
this.ProcessDuplicateNode(n);
return null; // fatal error
}
appliesToNodeFound = true;
// optional section
trd.appliesTo = LoadAppliesToSection(n, true);
}
else if (MatchNodeName(n, XmlTags.TableColumnItemsNode))
{
if (columnEntriesNodeFound)
{
this.ProcessDuplicateNode(n);
return null; //fatal
}
LoadColumnEntries(n, trd);
if (trd.rowItemDefinitionList == null)
{
return null; // fatal error
}
}
else if (MatchNodeName(n, XmlTags.MultiLineNode))
{
if (multiLineFound)
{
this.ProcessDuplicateNode(n);
return null; //fatal
}
multiLineFound = true;
if (!this.ReadBooleanNode(n, out trd.multiLine))
{
return null; //fatal error
}
}
else
{
this.ProcessUnknownNode(n);
}
}
return trd;
}
}